Thread: Checking for child process errors?

You can do either (or both).
- the parent reads a pipe attached to the stderr of the child process.
- the parent uses wait() to obtain the exit status, then uses various 'W' macros (see man page) to analyse the status.

I think you should post an actual example of what you're trying to do.

Originally Posted by Blasz

I don't think I would want to use wait(), as if I sent correct information to the child program, I don't want the parent to stall at wait(), if the child program will not exit, until further input is sent.

Whether you want to or not, you must call wait(). If you do not, your program is incorrect. You don't have to call it RIGHT AWAY... But you have to call it.

If you detect error by reading the child's output, how do you expect to not stall there as well? You try to read from a pipe and... it blocks until the child writes something.

If you want asynchronous notification when the child terminates, install a signal handler for the SIGCHLD signal. When this signal triggers, you can call waitpid() on the child's PID, it will NOT block, and you can get the return status.

Alternatively, you can poll the child with waitpid() and the WNOHANG flag -- if the child hasn't terminated yet, it doesn't block.

Originally Posted by brewbuck

Whether you want to or not, you must call wait(). If you do not, your program is incorrect.

Why?

Originally Posted by Blasz

How would I make the child print to stderr when an error occurred?

fprintf(stderr). But I think what Salem means here is that if I do this at the command line:

[root/etc] asdf
bash: asdf: command not found


That error message is printed to stderr by the shell. This will happen via exec calls too, you might be able to catch it with read() on the child's stderr (but I doubt it, since this is not the exec'd process's stderr). What would work is to use popen() to read the programs stdout, and append 2>&1 to redirect it's stderr to stdout, which popen supplies. I've done that a lot, it works.

Originally Posted by MK27

Why?

Because a terminated child is a zombie until the parent calls wait(). It's the same thing as never free()'ing what you malloc(), or never fclose()'ing what you fopen(). Yes, the system will clean up your mess for you when you terminate, but it's not right, and it CERTAINLY doesn't fly in a program where you launch children repeatedly.

Originally Posted by brewbuck

Because a terminated child is a zombie until the parent calls wait(). It's the same thing as never free()'ing what you malloc(), or never fclose()'ing what you fopen().

Fair enough -- altho it is not quite the same thing since zombie resources have already, in fact, been freed by the kernel. They just remain in the process list.

Originally Posted by Blasz

Can you suggest a good site that tells you how to setup a sighandler?

The man page didn't really help.

Why is it that everyone complains about Google but no one seems to use it? First hit on grepping for SIGCHILD example:

Code:

#include <sys/types.h>  /* include this before any other sys headers */
#include <sys/wait.h>   /* header for waitpid() and various macros */
#include <signal.h>     /* header for signal functions */
#include <stdio.h>      /* header for fprintf() */
#include <unistd.h>     /* header for fork() */

void sig_chld(int);     /* prototype for our SIGCHLD handler */

int main() 
{
    struct sigaction act;
    pid_t pid;

    /* Assign sig_chld as our SIGCHLD handler */
    act.sa_handler = sig_chld;

    /* We don't want to block any other signals in this example */
    sigemptyset(&act.sa_mask);

    /*
     * We're only interested in children that have terminated, not ones
     * which have been stopped (eg user pressing control-Z at terminal)
     */
    act.sa_flags = SA_NOCLDSTOP;

    /*
     * Make these values effective. If we were writing a real 
     * application, we would probably save the old value instead of 
     * passing NULL.
     */
    if (sigaction(SIGCHLD, &act, NULL) < 0) 
    {
        fprintf(stderr, "sigaction failed\n");
        return 1;
    }

    /* Fork */
    switch (pid = fork())
    {
    case -1:
        fprintf(stderr, "fork failed\n");
        return 1;

    case 0:                         /* child -- finish straight away */
        _exit(7);                   /* exit status = 7 */

    default:                        /* parent */
        sleep(10);                  /* give child time to finish */
    }

    return 0;
}

/*
 * The signal handler function -- only gets called when a SIGCHLD
 * is received, ie when a child terminates
 */
void sig_chld(int signo) 
{
    int status, child_val;

    /* Wait for any child without blocking */
    if (waitpid(-1, &status, WNOHANG) < 0) 
    {
        /*
         * calling standard I/O functions like fprintf() in a 
         * signal handler is not recommended, but probably OK 
         * in toy programs like this one.
         */
        fprintf(stderr, "waitpid failed\n");
        return;
    }

    /*
     * We now have the info in 'status' and can manipulate it using
     * the macros in wait.h.
     */
    if (WIFEXITED(status))                /* did child exit normally? */
    {
        child_val = WEXITSTATUS(status); /* get child's exit status */
        printf("child's exited normally with status %d\n", child_val);
    }
}