There are two classic server designs:

The flow inside the server main loop:

The parent uses fork() to create a child, then immediately loops back to msgrcv(). The child independently calls serveRequest() and then calls _exit() (not exit()) to avoid flushing stdio buffers that belong to the parent.

When a child process exits, it does not immediately disappear from the kernel’s process table. The kernel keeps a small record of it — its exit status — until the parent calls wait() or waitpid() to collect it. This dead-but-not-yet-collected process is called a zombie.

When a child process terminates, the kernel sends SIGCHLD to the parent. The server installs a signal handler called grimReaper() for SIGCHLD. This handler calls waitpid() to reap any finished children.

The grimReaper Handler

static void
grimReaper(int sig)
{
    int savedErrno;

    savedErrno = errno; /* Save errno — waitpid() may change it */

    /* Loop until all finished children are reaped.
       WNOHANG: do not block if no child has exited yet.
       Returns 0 when no more zombies, -1 on error. */
    while (waitpid(-1, NULL, WNOHANG) > 0)
        continue;

    errno = savedErrno; /* Restore errno */
}

Three critical points in this handler:

The server main loop calls msgrcv(), which blocks. When SIGCHLD fires (because a child died), the signal handler runs and then control returns to msgrcv(). What happens then depends on the SA_RESTART flag:

The server sets SA_RESTART when installing the SIGCHLD handler. However, not all system calls honor SA_RESTART. The server therefore also wraps msgrcv() in a loop:

/* Install SIGCHLD handler with SA_RESTART */
struct sigaction sa;
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART;     /* restart slow syscalls after handler */
sa.sa_handler = grimReaper;
sigaction(SIGCHLD, &sa, NULL);

/* Main server loop with EINTR restart logic */
for (;;) {
    msgLen = msgrcv(serverId, &req, REQ_MSG_SIZE, 0, 0);
    if (msgLen == -1) {
        if (errno == EINTR)   /* interrupted by SIGCHLD handler */
            continue;          /* restart msgrcv() manually */
        errMsg("msgrcv");
        break;
    }
    /* fork child to handle request ... */
}

After fork(), both parent and child share the same stdio buffers (because they are copied on fork). If the child calls exit():

• exit() flushes all stdio buffers.
• This could double-flush any partial output the parent has buffered.
• The result would be corrupted or duplicated output on stdout/stderr.

_exit() terminates immediately without flushing stdio buffers, so the parent’s buffers are left intact.

if (pid == 0) {              /* We are the child */
    serveRequest(&req);      /* Do the work         */
    _exit(EXIT_SUCCESS);     /* Do NOT flush stdio! */
}
/* Parent falls through and loops back to msgrcv() */

This skeleton shows all the concurrency and signal handling pieces together:

#include <sys/msg.h>
#include <signal.h>
#include <errno.h>
#include <sys/wait.h>
#include "svmsg_file.h"

static void
grimReaper(int sig)
{
    int savedErrno = errno;
    while (waitpid(-1, NULL, WNOHANG) > 0)
        continue;
    errno = savedErrno;
}

int
main(void)
{
    int serverId;
    struct requestMsg req;
    ssize_t msgLen;
    pid_t pid;
    struct sigaction sa;

    /* 1. Create well-known server queue */
    serverId = msgget(SERVER_KEY,
                  IPC_CREAT | IPC_EXCL | S_IRUSR | S_IWUSR | S_IWGRP);

    /* 2. Install SIGCHLD handler */
    sigemptyset(&sa.sa_mask);
    sa.sa_flags   = SA_RESTART;
    sa.sa_handler = grimReaper;
    sigaction(SIGCHLD, &sa, NULL);

    /* 3. Main request loop */
    for (;;) {
        msgLen = msgrcv(serverId, &req, REQ_MSG_SIZE, 0, 0);
        if (msgLen == -1) {
            if (errno == EINTR) continue; /* SIGCHLD interrupted us */
            break;
        }

        pid = fork();
        if (pid == -1) break;

        if (pid == 0) {            /* Child */
            serveRequest(&req);
            _exit(EXIT_SUCCESS);
        }
        /* Parent: fall through, loop to get next request */
    }

    /* 4. Remove server queue on exit */
    msgctl(serverId, IPC_RMID, NULL);
    return 0;
}

This is a very common interview topic. After fork(), the child gets:

1. What is the difference between an iterative and a concurrent server? When would you choose each?
2. What is a zombie process? How does it differ from an orphan process?
3. Why does the SIGCHLD handler use a while loop around waitpid() instead of calling it once?
4. What is the purpose of WNOHANG in waitpid(-1, NULL, WNOHANG)?
5. Why does the grimReaper handler save and restore errno?
6. What does SA_RESTART do and why is it still not enough — why does the server also check for EINTR?
7. Why does the child call _exit() instead of exit()?
8. What does the child process inherit from the parent after fork()?
9. How does the child process know which client to respond to without extra IPC with the parent?
10. What would happen if the server did NOT install a SIGCHLD handler and how would you detect the resulting problem?
11. Can two child processes from the same server both try to send messages to the same client queue simultaneously? What would happen?