Get PID of a child process after finishing in FreeBSD and C language

Question

I'm trying to handle SIGCHLD properly, but I don't manage to get the PID of the process inside the handler so I can change the value of one parameter inside an structure.

Here is the code:

typedef struct
{
    int active_state;
    int pid;
}Worker;

typedef struct
{
    Worker worker;
    int used_state;//this can be USED or UNUSED
}WorkersTable;

WorkersTable *table; //I put this in a shared memory map and works correctly

Here is the code for the handler.Inside this file there is a global variable called dead_child_pid that I want to to to store the pid of the dead child to be used alter.

void handler_SIGCHLD(int signal)
{
    pid_t child_pid;
    int e;
    do
    {
        child_pid=wait3(&e,WNOHANG,NULL);
    }while(child_pid>(pid_t)0);
    mark_unused=1;
}

When handler_SIGCHLD is called and at the end we I put mark_unused=1, the following code is accessed:

if(mark_unused)
    {
        /*put the current position at the table as unused*/
        int counter_find_pid=0;
        while(counter_find_pid<MAX_WORKERS&&table[contador_find_pid].used_state==USED&&table[counter_find_pid].worker.pid!=dead_child_pid)
        {
            counter_find_pid++;
        }
        table[counter_find_pid].used_state=UNUSED;
    }

Answer 1

void handler_SIGCHLD(int signal)
{
    pid_t child_pid;
    int e;
    do
    {
        child_pid=wait3(&e,WNOHANG,NULL);
    }while(child_pid>(pid_t)0);
    mark_unused=1;
}

The valid wait3 return values are

1. the pid of a child
2. 0 if there are children that have not changed state
3. -1 on error

You are not going to get out of that loop until child_pid is either 0 or -1, in which case the previous values (of the child pids that died) have been overwritten. You'll need to find a way to save the valid pids of the dead children somewhere while still in the loop or change the loop. You can put your global dead_child_pid in the handler but make it volatile.

Edit

You want something more like this but if this is a serious application this also needs enhancement because the handler can potentially be called while you are processing the dead children array down stream. Then you have to consider blocking SIGCHLD while you manipulate things.

// somewhere, probably global scope
volatile currentlyDeadChilren = 0;
volatile pid_t dead_children[MAX_DEAD_CHILDREN];    

void handler_SIGCHLD(int signal)
{
    pid_t child_pid;

    int e;

    do
    {
        child_pid=wait3(&e,WNOHANG,NULL);

        if (child_pid > 0)
            dead_children[currentlyDeadChildren++] = child_pid;        

    }while(child_pid>(pid_t)0);

    mark_unused=1;
}