Unix signal processing

int system_call_x(...)
{
    while ((rc=the_real_system_call_x(...)) == ERROR && errno == EINTR)
        ;
    return(rc)
}

#include <errno.h>              /* for errno() */
#include <linux/limits.h>       /* for ARG_MAX */
#include <signal.h>             /* for signal(), SIG* */
#include <stdio.h>              /* for sprintf(), stderr, ... */
#include <stdlib.h>             /* for exit() */
#include <string.h>             /* for strerror() */
#include <sys/types.h>          /* for wait() */
#include <sys/wait.h>           /* for wait() */
#include <unistd.h>             /* for sleep(), fork() and execlp() */
#include "funcs.h"              /* for infomsg(), errormsg() */

/*
 *  Macros
 */

#define A_LONG_TIME             3600
#define CHILD_RUN_TIME          10
#define WAIT_INSTEAD_OF_SLEEP   TRUE

/*
 *  Type and struct definitions
 */

/*
 *  Global variables
 */

/*
 *  Forward declarations
 */

pid_t start_child_sleep(void);

/*
 *  Functions
 */

int main(
int argc,
char *argv[])
{
    int wstatus;
    pid_t pid;

    /*
     *  Initialise.
     */

    /*
     *  Start child.
     */

    infomsg("parent starting one child ...");
    pid = start_child_sleep();

    /*
     *  Monitor child
     */

    infomsg("parent sees child has pid %d and waits for it ...", pid);
#if WAIT_INSTEAD_OF_SLEEP
    pid = wait(&wstatus);
#else
    sleep(A_LONG_TIME);
#endif

    /*
     *  Clean up and exit.
     */

    infomsg("parent cleaning up and exiting ...");
    return(0);
}

pid_t start_child_sleep(
)
{
    pid_t pid;
    char buf[ARG_MAX];

    if ((pid=fork()) < 0)
        errormsg("fork() failed: %s", strerror(errno));
    else if (pid > 0)
        return(pid);

    /*
     *  Only the child gets here
     */

    sprintf(buf, "echo \"child running ...\";"
                 "sleep %d;"
                 "echo \"child exiting ...\"",
                 CHILD_RUN_TIME);
    execlp("/bin/sh", "sh", "-c", buf, (char *) NULL);
    errormsg("exec() failed: %s", strerror(errno));
}

#define WAIT_INSTEAD_OF_SLEEP TRUE

#define WAIT_INSTEAD_OF_SLEEP FALSE

#include <errno.h>              /* for errno() */
#include <linux/limits.h>       /* for ARG_MAX */
#include <signal.h>             /* for signal(), SIG* */
#include <stdio.h>              /* for sprintf(), stderr, ... */
#include <stdlib.h>             /* for exit() */
#include <string.h>             /* for strerror() */
#include <sys/types.h>          /* for wait() */
#include <sys/wait.h>           /* for wait() */
#include <unistd.h>             /* for sleep(), fork() and execlp() */
#include "funcs.h"              /* for infomsg(), errormsg() */

/*
 *  Macros
 */

#define CHILD_RUN_TIME          10

/*
 *  Type and struct definitions
 */

/*
 *  Global variables
 */

int child_reaped = FALSE;

/*
 *  Forward declarations
 */

pid_t start_child_sleep(void);
void sigchld_handler(int);

/*
 *  Functions
 */

int main(
int argc,
char *argv[])
{
    pid_t pid;

    /*
     *  Initialise.
     */

    infomsg("parent setting up signal handlers ...");
    signal(SIGCHLD, sigchld_handler);

    /*
     *  Start child.
     */

    infomsg("parent starting one child ...");
    pid = start_child_sleep();

    /*
     *  Main monitoring loop
     */

    infomsg("parent sees child has pid %d and loops checking flag ...", pid);
    while (TRUE) {

        /*
         *  Exit if no running children.
         */

        if (child_reaped) {
            infomsg("parent sees child_reaped flag and so stops looping ...");
            break;
        }

        /*
         *  Let a little time pass before we reinspect the situation.
         */

        sleep(1);
    }

    /*
     *  Clean up and exit.
     */

    infomsg("parent cleaning up and exiting ...");
    signal(SIGCHLD, SIG_DFL);
    return(0);
}

pid_t start_child_sleep(
)
{
    pid_t pid;
    char buf[ARG_MAX];

    if ((pid=fork()) < 0)
        errormsg("fork() failed: %s", strerror(errno));
    else if (pid > 0)
        return(pid);

    /*
     *  Only the child gets here
     */

    sprintf(buf, "echo \"child running ...\";"
                 "sleep %d;"
                 "echo \"child exiting ...\"",
                 CHILD_RUN_TIME);
    execlp("/bin/sh", "sh", "-c", buf, (char *) NULL);
    errormsg("exec() failed: %s", strerror(errno));
}

void sigchld_handler(
int sig)
{
    int wstatus;
    pid_t pid;

    infomsg("parent received SIGCHLD; reaping and setting child_reaped flag ...");
    pid = wait(&wstatus);
    child_reaped = TRUE;
}

#include <errno.h>              /* for errno() */
#include <linux/limits.h>       /* for ARG_MAX */
#include <signal.h>             /* for signal(), SIG* */
#include <stdio.h>              /* for sprintf(), stderr, ... */
#include <stdlib.h>             /* for exit() */
#include <string.h>             /* for strerror() */
#include <sys/types.h>          /* for wait() */
#include <sys/wait.h>           /* for wait() */
#include <unistd.h>             /* for sleep(), fork() and execlp() */
#include "funcs.h"              /* for infomsg(), errormsg() */

/*
 *  Macros
 */

#define TIMEOUT                 15
#define A_LONG_TIME             3600
#define CHILD_RUN_TIME          10

/*
 *  Type and struct definitions
 */

/*
 *  Global variables
 */

int child_reaped = FALSE;
int timed_out = FALSE;

/*
 *  Forward declarations
 */

pid_t start_child_sleep(void);
void sigchld_handler(int);
void sigalrm_handler(int);

/*
 *  Functions
 */

int main(
int argc,
char *argv[])
{
    pid_t pid;

    /*
     *  Initialise.
     */

    infomsg("parent setting up signal handlers ...");
    signal(SIGCHLD, sigchld_handler);
    signal(SIGALRM, sigalrm_handler);

    /*
     *  Start child.
     */

    infomsg("parent starting one child ...");
    pid = start_child_sleep();

    /*
     *  Schedule timeout alarm.
     */

    infomsg("parent scheduling timeout alarm ...");
    alarm(TIMEOUT);

    /*
     *  Main monitoring loop
     */

    infomsg("parent entering monitoring loop ...");
    while (TRUE) {

        /*
         *  Exit if no running children.
         */

        if (child_reaped) {
            if (!timed_out)
                alarm(0);
            infomsg("parent sees child_reaped flag and so stops looping ...");
            break;
        }

        /*
         *  Kill child if it has reached its timeout time.
         */

        if (timed_out) {
            infomsg("parent sees timed_out flag and so kills child ...");
            kill(pid, SIGTERM);
        }

        /*
         *  Sleep until next signal arrives
         */

        infomsg("parent sleeping until signal arrives ...");
        sleep(A_LONG_TIME);

        /*
         *  If SIGCHLD arrived before SIGALRM then the alarm is still
         *  pending. Cancel it.
         */

        infomsg("parent cancelling alarm ...");
        alarm(0);
    }

    /*
     *  Clean up and exit.
     */

    infomsg("parent cleaning up and exiting ...");
    signal(SIGCHLD, SIG_DFL);
    signal(SIGALRM, SIG_DFL);
    return(0);
}

pid_t start_child_sleep(
)
{
    pid_t pid;
    char buf[ARG_MAX];

    if ((pid=fork()) < 0)
        errormsg("fork() failed: %s", strerror(errno));
    else if (pid > 0)
        return(pid);

    /*
     *  Only the child gets here
     */

    sprintf(buf, "echo \"child running ...\";"
                 "sleep %d;"
                 "echo \"child exiting ...\"",
                 CHILD_RUN_TIME);
    execlp("/bin/sh", "sh", "-c", buf, (char *) NULL);
    errormsg("exec() failed: %s", strerror(errno));
}

void sigchld_handler(
int sig)
{
    int wstatus;
    pid_t pid;

    infomsg("parent received SIGCHLD; reaping and setting child_reaped flag ...");
    pid = wait(&wstatus);
    child_reaped = TRUE;
}

void sigalrm_handler(
int sig)
{
    infomsg("parent received SIGALRM; setting timed_out flag ...");
    timed_out = TRUE;
}

#define CHILD_RUN_TIME  10
...
sprintf(buf, "echo \"child running ...\";"
             "sleep %d;"
             "echo \"child exiting ...\"",
             CHILD_RUN_TIME);
execlp("/bin/sh", "sh", "-c", buf, (char *) NULL);

#define TIMEOUT         15
...
alarm(TIMEOUT);

#define CHILD_RUN_TIME 20

#define MAX_CHILDREN    1000
...
struct child {
    pid_t pid;
    time_t start;
};
...
struct child children[MAX_CHILDREN];

#include <errno.h>              /* for errno() */
#include <linux/limits.h>       /* for ARG_MAX */
#include <signal.h>             /* for signal(), SIG* */
#include <stdio.h>              /* for sprintf(), stderr, ... */
#include <stdlib.h>             /* for exit() */
#include <string.h>             /* for strerror() */
#include <sys/types.h>          /* for wait() */
#include <sys/wait.h>           /* for wait() */
#include <time.h>               /* for time() */
#include <unistd.h>             /* for sleep(), fork() and execlp() */
#include "funcs.h"              /* for infomsg(), errormsg() */

/*
 *  Macros
 */

#define MAX_CHILDREN            1000
#define CHILDREN                5
#define TIMEOUT                 30
#define A_LONG_TIME             3600
#define CHILD_RUN_TIME(n)       n
#define WAITPID_LOOP            FALSE

/*
 *  Type and struct definitions
 */

struct child {
    pid_t  pid;
    time_t start;
};

/*
 *  Global variables
 */

struct child children[MAX_CHILDREN];

/*
 *  Forward declarations
 */

pid_t start_child_sleep(int);
void sigchld_handler(int);
void sigalrm_handler(int);

/*
 *  Functions
 */

int main(
int argc,
char *argv[])
{
    int i;
    int running_children_count, next_timeout, killed_something;
    time_t now;

    /*
     *  Initialise.
     */

    infomsg("parent initialising children status table ...");
    for (i=0; i<MAX_CHILDREN; i++)
        children[i].pid = 0;

    infomsg("parent setting up signal handlers ...");
    signal(SIGCHLD, sigchld_handler);
    signal(SIGALRM, sigalrm_handler);

    /*
     *  Start children.
     */

    infomsg("parent starting %d children ...", CHILDREN);
    for (i=0; i<CHILDREN; i++)
        start_child_sleep(CHILD_RUN_TIME(i));

    /*
     *  Main monitoring loop
     */

    infomsg("parent entering monitoring loop ...");
    while (TRUE) {
        now = time(NULL);

        /*
         *  Exit if no running children.
         */

        infomsg("parent checking for running children ...");
        running_children_count = 0;
        for (i=0; i<MAX_CHILDREN; i++)
            if (children[i].pid != 0)
                running_children_count++;
        infomsg("parent sees %d children still running", running_children_count);
        if (running_children_count == 0)
            break;

        /*
         *  Kill any children that have reached their timeout time and not
         *  been killed already.
         */

        killed_something = FALSE;
        for (i=0; i<MAX_CHILDREN; i++)
            if (children[i].pid != 0 && children[i].start != 0 &&
                    now >= children[i].start+TIMEOUT) {
                kill(children[i].pid, SIGTERM);
                children[i].start = 0;
                killed_something = TRUE;
            }

        /*
         *  Slight optimisation: if something did reach its timeout and got
         *  killed then skip to reassessing if this program can exit.
         */

        if (killed_something)
            continue;

        /*
         *  Schedule timeout alarm.
         */

        infomsg("parent scheduling timeout alarm ...");
        next_timeout = 0;
        for (i=0; i<MAX_CHILDREN; i++)
            if (children[i].pid != 0 && children[i].start != 0)
                if (next_timeout == 0)
                    next_timeout = children[i].start+TIMEOUT - now;
                else if (children[i].start+TIMEOUT - now < next_timeout)
                    next_timeout = children[i].start+TIMEOUT - now;
        if (next_timeout >= 1) {
            infomsg("parent scheduling alarm for %ds ...", next_timeout);
            alarm(next_timeout);
        }

        /*
         *  Sleep until next signal arrives
         *  (unless timeout is so close that we didn't schedule an alarm
         *  so sleeping might not be interrupted).
         */

        infomsg("parent sleeping until signal arrives ...");
        if (next_timeout >= 1)
            sleep(A_LONG_TIME);

        /*
         *  If SIGCHLD arrived before SIGALRM then the alarm is still
         *  pending. Cancel it.
         */

        infomsg("parent cancelling alarm ...");
        alarm(0);
    }

    /*
     *  Clean up and exit.
     */

    infomsg("parent cleaning up and exiting ...");
    signal(SIGCHLD, SIG_DFL);
    signal(SIGALRM, SIG_DFL);
    return(0);
}

pid_t start_child_sleep(
int period)
{
    pid_t pid;
    char buf[ARG_MAX];
    int i;

    /*
     *  Find an empty slot to store info about the process we're
     *  about launch.
     */

    for (i=0; i<MAX_CHILDREN; i++)
        if (children[i].pid == 0)
            break;
    if (i == MAX_CHILDREN)
        errormsg("start_child_sleep: unable to find a free slot");

    /*
     *  Launch a child process and note its pid and start time
     *  in the empty slot.
     */

    sprintf(buf, "echo \"child $$ started ...\";"
                 "sleep %d;"
                 "echo \"child $$ exiting ...\"",
                 period);
    if ((pid=fork()) < 0)
        errormsg("fork() failed: %s", strerror(errno));
    else if (pid > 0) {
        children[i].pid = pid;
        children[i].start = time(NULL);
        return(pid);
    }

    /*
     *  Only the child gets here
     */

    execlp("/bin/sh", "sh", "-c", buf, (char *) NULL);
    errormsg("exec() failed: %s", strerror(errno));
}

void sigchld_handler(
int sig)
{
    int wstatus;
    pid_t pid;
    int i;

#if WAITPID_LOOP
    while ((pid=waitpid(-1, &wstatus, WNOHANG)) > 0) {
        infomsg("parent received SIGCHLD; reaping and clearing child data ...");
        for (i=0; i<MAX_CHILDREN; i++)
            if (children[i].pid == pid) {
                children[i].pid = 0;
                children[i].start = 0;
                break;
            }
    }
#else
    infomsg("parent received SIGCHLD; reaping and clearing child data ...");
    pid = wait(&wstatus);
    for (i=0; i<MAX_CHILDREN; i++)
       if (children[i].pid == pid) {
           children[i].pid = 0;
           children[i].start = 0;
           break;
       }
#endif
}

void sigalrm_handler(
int sig)
{
   infomsg("parent received SIGALRM");
}

#define CHILD_RUN_TIME(n) n

#define CHILD_RUN_TIME(n) 1

#define WAITPID_LOOP FALSE

#define WAITPID_LOOP TRUE

#include <errno.h>              /* for errno() */
#include <linux/limits.h>       /* for ARG_MAX */
#include <signal.h>             /* for signal(), SIG* */
#include <stdio.h>              /* for sprintf(), stderr, ... */
#include <stdlib.h>             /* for exit() */
#include <string.h>             /* for strerror() */
#include <sys/types.h>          /* for wait() */
#include <sys/wait.h>           /* for wait() */
#include <time.h>               /* for time() */
#include <unistd.h>             /* for sleep(), fork() and execlp() */
#include "funcs.h"              /* for infomsg(), errormsg() */

/*
 *  Macros
 */

#define MAX_CHILDREN            1000
#define CHILDREN                500
#define TIMEOUT                 300
#define A_LONG_TIME             3600
#define CHILD_RUN_TIME(n)       1

/*
 *  Type and struct definitions
 */

struct child {
    pid_t  pid;
    time_t start;
};

/*
 *  Global variables
 */

struct child children[MAX_CHILDREN];

/*
 *  Forward declarations
 */

pid_t start_child_sleep(int);
void sigchld_handler(int);
void sigalrm_handler(int);
void sigusr1_handler(int);

/*
 *  Functions
 */

int main(
int argc,
char *argv[])
{
    int i;
    int running_children_count, next_timeout, killed_something;
    time_t now;

    /*
     *  Initialise.
     */

    infomsg("parent initialising children status table ...");
    for (i=0; i<MAX_CHILDREN; i++)
        children[i].pid = 0;

    infomsg("parent setting up signal handlers ...");
    signal(SIGCHLD, sigchld_handler);
    signal(SIGALRM, sigalrm_handler);
    signal(SIGUSR1, sigusr1_handler);

    /*
     *  Start children.
     */

    infomsg("parent starting %d children ...", CHILDREN);
    for (i=0; i<CHILDREN; i++)
        start_child_sleep(CHILD_RUN_TIME(i));

    /*
     *  Main monitoring loop
     */

    infomsg("parent entering monitoring loop ...");
    while (TRUE) {
        now = time(NULL);

        /*
         *  Exit if no running children.
         */

        infomsg("parent checking for running children ...");
        running_children_count = 0;
        for (i=0; i<MAX_CHILDREN; i++)
            if (children[i].pid != 0)
                running_children_count++;
        infomsg("parent sees %d children still running", running_children_count);
        if (running_children_count == 0)
            break;

        /*
         *  Kill any children that have reached their timeout time and not
         *  been killed already.
         */

        killed_something = FALSE;
        for (i=0; i<MAX_CHILDREN; i++)
            if (children[i].pid != 0 && children[i].start != 0 &&
                    now >= children[i].start+TIMEOUT) {
                kill(children[i].pid, SIGTERM);
                children[i].start = 0;
                killed_something = TRUE;
            }

        /*
         *  Slight optimisation: if something did reach its timeout and got
         *  killed then skip to reassessing if this program can exit.
         */

        if (killed_something)
            continue;

        /*
         *  Schedule timeout alarm of next-to-timeout child.
         */

        infomsg("parent scheduling timeout alarm ...");
        next_timeout = 0;
        for (i=0; i<MAX_CHILDREN; i++)
            if (children[i].pid != 0 && children[i].start != 0)
                if (next_timeout == 0)
                    next_timeout = children[i].start+TIMEOUT - now;
                else if (children[i].start+TIMEOUT - now < next_timeout)
                    next_timeout = children[i].start+TIMEOUT - now;
        if (next_timeout >= 1) {
            infomsg("parent scheduling alarm for %ds ...", next_timeout);
            alarm(next_timeout);
        }

        /*
         *  Sleep until next signal arrives
         *  (unless timeout is so close that we didn't schedule an alarm
         *  so sleeping might not be interrupted).
         */

        infomsg("parent sleeping until signal arrives ...");
        if (next_timeout >= 1)
            sleep(A_LONG_TIME);

        /*
         *  If SIGCHLD arrived before SIGALRM then the alarm is still
         *  pending. Cancel it.
         */

        infomsg("parent cancelling alarm ...");
        alarm(0);
    }

    /*
     *  Clean up and exit.
     */

    infomsg("parent cleaning up and exiting ...");
    signal(SIGCHLD, SIG_DFL);
    signal(SIGALRM, SIG_DFL);
    signal(SIGUSR1, SIG_DFL);
    return(0);
}

pid_t start_child_sleep(
int period)
{
    pid_t pid;
    char buf[ARG_MAX];
    int i;

    /*
     *  Find an empty slot to store info about the process we're
     *  about launch.
     */

    for (i=0; i<MAX_CHILDREN; i++)
        if (children[i].pid == 0)
            break;
    if (i == MAX_CHILDREN)
        errormsg("start_child_sleep: unable to find a free slot");

    /*
     *  Launch a child process and note its pid and start time
     *  in the empty slot.
     */

    sprintf(buf, "echo \"child $$ started ...\";"
                 "sleep %d;"
                 "echo \"child $$ exiting ...\"",
                 period);
    if ((pid=fork()) < 0)
        errormsg("fork() failed: %s", strerror(errno));
    else if (pid > 0) {
        children[i].pid = pid;
        children[i].start = time(NULL);
        return(pid);
    }

    /*
     *  Only the child gets here
     */

    execlp("/bin/sh", "sh", "-c", buf, (char *) NULL);
    errormsg("exec() failed: %s", strerror(errno));
}

void sigchld_handler(
int sig)
{
    int wstatus;
    pid_t pid;
    int i;

    while ((pid=waitpid(-1, &wstatus, WNOHANG)) > 0) {
        infomsg("parent received SIGCHLD; reaping and clearing child data ...");
        for (i=0; i<MAX_CHILDREN; i++)
            if (children[i].pid == pid) {
                children[i].pid = 0;
                children[i].start = 0;
                break;
            }
    }
}

void sigalrm_handler(
int sig)
{
   infomsg("parent received SIGALRM");
}

void sigusr1_handler(
int sig)
{
   int i;

   finfomsg(stderr, "parent received SIGUSR1");
   for (i=0; i<MAX_CHILDREN; i++)
       if (children[i].pid != 0)
           finfomsg(stderr, "slot:%04d; pid:%05d, start=%ld", 
                    i, children[i].pid, children[i].start);
}

#!/bin/bash

[ $# = 1 -a -x "$1" ] || { echo "Usage: ${0##*/} <script>" >&2; exit 1; }
SCRIPT=$1

PATH=$PATH:.
I=0
while :; do
    ((I++))
    $SCRIPT >/dev/null &
    PID=$!
    sleep 3
    if [ -d /proc/$PID ]; then
        echo "$SCRIPT (pid $PID) hung on ${I}th attempt; children dump follows ..."
        kill -USR1 $PID
        break
    fi
done

#include <arpa/inet.h>          /* for inet_ntoa() */
#include <errno.h>              /* for errno() */
#include <netinet/in.h>
#include <signal.h>             /* for signal(), SIG* */
#include <stdio.h>              /* for sprintf(), stderr, ... */
#include <stdlib.h>             /* for exit() */
#include <string.h>             /* for strerror() */
#include <sys/types.h>          /* for wait() */
#include <sys/wait.h>           /* for wait() */
#include <time.h>               /* for time() */
#include <unistd.h>             /* for sleep(), fork() and execlp() */
#include <sys/socket.h>
#include "funcs.h"              /* for infomsg(), errormsg() */

/*
 *  Macros
 */

#define MAX_CHILDREN            1000
#define MYPORT                  2345
#define MAXPENDING              10
#define CHILD_RUN_TIME          20

/*
 *  Type and struct definitions
 */

struct child {
    pid_t  pid;
    time_t start;
};

/*
 *  Global variables
 */

struct child children[MAX_CHILDREN];

/*
 *  Forward declarations
 */

pid_t start_child_server(int);
void sigchld_handler(int);

/*
 *  Functions
 */

int main(
int argc,
char *argv[])
{
    int i;
    int listening_sfd, toclient_sfd;
    struct sockaddr_in listening_spars;
    struct sockaddr_in toclient_spars;
    int actual_toclient_spars_size;
    int sockoptval;

    /*
     *  Initialise.
     */

    infomsg("parent setting up listening socket ...");
    /* create addressless IPv4 TCP socket */
    if ((listening_sfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
        errormsg("socket() failed");
    /* ensure bind() doesn't find old stale socket */
    sockoptval = 1;
    setsockopt(listening_sfd, SOL_SOCKET, SO_REUSEADDR,
               &sockoptval, sizeof(sockoptval));
    /* define other socket parameters */
    memset(&listening_spars, 0, sizeof(struct sockaddr_in));
    listening_spars.sin_family = AF_INET;         /* IPv4 */
    listening_spars.sin_port = htons(MYPORT);     /* port */
    listening_spars.sin_addr.s_addr = INADDR_ANY; /* listen on all NICs */
    /* apply socket parameters */
    if (bind(listening_sfd, (struct sockaddr *) &listening_spars,
             sizeof(struct sockaddr)) == -1)
        errormsg("bind() failed");
    /* mark socket for listening */
    if (listen(listening_sfd, MAXPENDING) == -1)
        errormsg("listen() failed");

    infomsg("parent initialising children status table ...");
    for (i=0; i<MAX_CHILDREN; i++)
        children[i].pid = 0;

    infomsg("parent setting up signal handlers ...");
    signal(SIGCHLD, sigchld_handler);

    /*
     *  Main monitoring loop
     */

    infomsg("parent entering monitoring loop ...");
    while (TRUE) {
        /* wait for incoming connection, move it to a new socket */
        infomsg("parent awaiting incoming connection ...");
        actual_toclient_spars_size = sizeof(struct sockaddr_in);
        if ((toclient_sfd = accept(listening_sfd, 
                                   (struct sockaddr *) &toclient_spars,
                                   &actual_toclient_spars_size)) == -1) {
            infomsg("accept() failed");
            continue;
        }

        /*
         *  Start child server to talk to client.
         */

        infomsg("parent starting one child ...");
        start_child_server(toclient_sfd);
        /* child server uses toclient_sfd, not parent server */
        close(toclient_sfd);
    }

    /*
     *  Clean up and exit.
     */

    infomsg("parent cleaning up and exiting ...");
    signal(SIGCHLD, SIG_DFL);
    return(0);
}

pid_t start_child_server(
int toclient_sfd)
{
    pid_t pid;
    int i;
    const char *msg = "this is a message from the server to the client\n";

    /*
     *  Find an empty slot to store info about the process we're
     *  about launch.
     */

    for (i=0; i<MAX_CHILDREN; i++)
        if (children[i].pid == 0)
            break;
    if (i == MAX_CHILDREN)
        errormsg("start_child_sleep: unable to find a free slot");

    /*
     *  Launch a child server and note its pid and start time
     *  in the empty slot.
     */

    if ((pid=fork()) < 0)
        errormsg("fork() failed: %s", strerror(errno));
    else if (pid > 0) {
        children[i].pid = pid;
        children[i].start = time(NULL);
        return(pid);
    }

    /*
     *  Only the child gets here
     */

    infomsg("child is pid %d", (int) getpid());
    infomsg("child sending message to client ...");
    if (send(toclient_sfd, msg, strlen(msg), 0) == -1)
        errormsg("send");
    infomsg("child sleeping a bit ...");
    sleep(CHILD_RUN_TIME);
    infomsg("child exiting ...");
    close(toclient_sfd);
    exit(EXIT_SUCCESS);
}

void sigchld_handler(
int sig)
{
    int wstatus;
    pid_t pid;
    int i;

    while ((pid=waitpid(-1, &wstatus, WNOHANG)) > 0) {
        infomsg("parent received SIGCHLD; reaping and clearing child data ...");
        for (i=0; i<MAX_CHILDREN; i++)
            if (children[i].pid == pid) {
                children[i].pid = 0;
                children[i].start = 0;
                break;
            }
    }
}

#include <errno.h>              /* for errno() */
#include <linux/limits.h>       /* for ARG_MAX */
#include <signal.h>             /* for signal(), SIG* */
#include <stdio.h>              /* for sprintf(), stderr, ... */
#include <stdlib.h>             /* for exit() */
#include <string.h>             /* for strerror() */
#include <sys/types.h>          /* for wait() */
#include <sys/wait.h>           /* for wait() */
#include <time.h>               /* for time() */
#include <unistd.h>             /* for sleep(), fork() and execlp() */
#include "funcs.h"              /* for infomsg(), errormsg() */

/*
 *  Macros
 */

#define MAX_CHILDREN            1000
#define CHILDREN                5
#define INTER_CHILD_INTERVAL    10
#define CHILD_RUN_TIME(n)       (((n+getpid())*7)%19) /* stupid pseudo RNG */

/*
 *  Type and struct definitions
 */

struct child {
    pid_t  pid;
    time_t start;
};

/*
 *  Global variables
 */

struct child children[MAX_CHILDREN];

/*
 *  Forward declarations
 */

pid_t start_child_sleep(int);
void sigchld_handler(int);

/*
 *  Functions
 */

int main(
int argc,
char *argv[])
{
    int i, j;
    int running_children_count;
    time_t now;

    /*
     *  Initialise.
     */

    infomsg("parent initialising children status table ...");
    for (i=0; i<MAX_CHILDREN; i++)
        children[i].pid = 0;

    infomsg("parent setting up signal handlers ...");
    signal(SIGCHLD, sigchld_handler);

    /*
     *  Main monitoring loop
     */

    infomsg("parent entering monitoring loop ...");
    j = 0;
    while (TRUE) {
        now = time(NULL);

        /*
         *  Exit if no running child processes *and*
         *  we've already started desired number
         */

        if (j < CHILDREN)
            infomsg("parent sees some children not started yet");
        else {
            infomsg("parent checking for running children ...");
            running_children_count = 0;
            for (i=0; i<MAX_CHILDREN; i++)
                if (children[i].pid != 0)
                    running_children_count++;
            infomsg("parent sees %d children still running", running_children_count);
            if (running_children_count == 0 && j == CHILDREN)
                break;
        }

        /*
         *  Every INTER_CHILD_INTERVAL seconds start another child process.
         */

        if (j<CHILDREN) {
            infomsg("parent starting one child ...");
            start_child_sleep(CHILD_RUN_TIME(j));
            j++;
            infomsg("parent sleeping %ds ...", INTER_CHILD_INTERVAL);
            sleep(INTER_CHILD_INTERVAL);
        }
    }

    /*
     *  Clean up and exit.
     */

    infomsg("parent cleaning up and exiting ...");
    signal(SIGCHLD, SIG_DFL);
    return(0);
}

pid_t start_child_sleep(
int period)
{
    pid_t pid;
    int i;
    char buf[ARG_MAX];

    /*
     *  Find an empty slot to store info about the process we're
     *  about launch.
     */

    for (i=0; i<MAX_CHILDREN; i++)
        if (children[i].pid == 0)
            break;
    if (i == MAX_CHILDREN)
        errormsg("start_child_sleep: unable to find a free slot");

    /*
     *  Launch a child process and note its pid and start time
     *  in the empty slot.
     */

    if ((pid=fork()) < 0)
        errormsg("fork() failed: %s", strerror(errno));
    else if (pid > 0) {
        children[i].pid = pid;
        children[i].start = time(NULL);
        return(pid);
    }

    /*
     *  Only the child gets here
     */

    sprintf(buf, "echo \"child $$ started ...\";"
                 "sleep %d;"
                 "echo \"child $$ exiting ...\"",
                 period);
    infomsg("child running for %ds ...", period);
    execlp("/bin/sh", "sh", "-c", buf, (char *) NULL);
    errormsg("exec() failed: %s", strerror(errno));
}

void sigchld_handler(
int sig)
{
    int wstatus;
    pid_t pid;
    int i;

    while ((pid=waitpid(-1, &wstatus, WNOHANG)) > 0) {
        infomsg("parent received SIGCHLD; reaping and clearing child data ...");
        for (i=0; i<MAX_CHILDREN; i++)
            if (children[i].pid == pid) {
                children[i].pid = 0;
                children[i].start = 0;
                break;
            }
    }
}

start_sleep_time = time(NULL);
while (TRUE) {
    /* how long to sleep? */
    desired_sleep_time = start_sleep_time + INTER_CHILD_INTERVAL - time(NULL);
    /* if  slept full amount then no need to sleep more */
    if (sleep(desired_sleep_time) == desired_sleep_time)
        break;
    /* if didn't sleep full amount but not due to signal then exit sleep loop */
    if (errno != EINTR)
        break;
}

#include <errno.h>              /* for errno() */
#include <linux/limits.h>       /* for ARG_MAX */
#include <signal.h>             /* for signal(), SIG* */
#include <stdio.h>              /* for sprintf(), stderr, ... */
#include <stdlib.h>             /* for exit() */
#include <string.h>             /* for strerror() */
#include <sys/types.h>          /* for wait() */
#include <sys/wait.h>           /* for wait() */
#include <time.h>               /* for time() */
#include <unistd.h>             /* for sleep(), fork() and execlp() */
#include "funcs.h"              /* for infomsg(), errormsg() */

/*
 *  Macros
 */

#define MAX_CHILDREN            1000
#define CHILDREN                500
#define TIMEOUT                 300
#define A_LONG_TIME             3600
#define CHILD_RUN_TIME(n)       1
#define HANDLE_MULTIPLE_PENDING_SIGCHLDS_IN_ONE_GO TRUE

/*
 *  Type and struct definitions
 */

struct child {
    pid_t  pid;
    time_t start;
};

/*
 *  Global variables
 */

struct child children[MAX_CHILDREN];

/*
 *  Forward declarations
 */

pid_t start_child_sleep(int);
void sigchld_handler(int);
void sigalrm_handler(int);
void sigusr1_handler(int);

/*
 *  Functions
 */

int main(
int argc,
char *argv[])
{
    int i;
    int running_children_count, next_timeout, killed_something;
    time_t now;
    sigset_t sigset, old_sigset, suspend_sigset;
    struct sigaction act, old_chld_act, old_alrm_act, old_usr1_act;

    /*
     *  Initialise.
     */

    infomsg("parent initialising children status table ...");
    for (i=0; i<MAX_CHILDREN; i++)
        children[i].pid = 0;

    infomsg("parent setting up signal handlers ...");
    /* cause delivery of SIGCHLD, SIGARLM and SIGUSR1 to be delayed until we call sigsuspend() */
    sigemptyset(&sigset);
    sigaddset(&sigset, SIGCHLD);
    sigaddset(&sigset, SIGALRM);
    sigaddset(&sigset, SIGUSR1);
    sigprocmask(SIG_BLOCK, &sigset, &old_sigset);
    /* later we need list of signals blocked before sigprocmask() call,
       but *excluding* SIGCHLD, etc. */
    memcpy(&suspend_sigset, &old_sigset, sizeof(sigset_t));
    sigdelset(&suspend_sigset, SIGCHLD);
    sigdelset(&suspend_sigset, SIGALRM);
    sigdelset(&suspend_sigset, SIGUSR1);
    /* on SIGCHLD call sigchld_handler() and delay delivery of other signals while in it */
    sigemptyset(&sigset);
    sigaddset(&sigset, SIGALRM);
    sigaddset(&sigset, SIGUSR1);
    memset(&act, 0, sizeof(struct sigaction));
    act.sa_mask = sigset; 
    act.sa_flags = 0;  
    act.sa_handler = sigchld_handler;
    sigaction(SIGCHLD, &act, &old_chld_act);
    /* on SIGARLM call sigalrm_handler() and delay delivery of other signals while in it */
    sigemptyset(&sigset);
    sigaddset(&sigset, SIGCHLD);
    sigaddset(&sigset, SIGUSR1);
    memset(&act, 0, sizeof(struct sigaction));
    act.sa_mask = sigset;
    act.sa_flags = 0; 
    act.sa_handler = sigalrm_handler;
    sigaction(SIGALRM, &act, &old_alrm_act);
    /* on SIGUSR1 call sigusr1_handler() and delay delivery of other signals while in it */
    sigemptyset(&sigset);
    sigaddset(&sigset, SIGCHLD);
    sigaddset(&sigset, SIGALRM);
    memset(&act, 0, sizeof(struct sigaction));
    act.sa_mask = sigset;
    act.sa_flags = SA_RESTART;  
    act.sa_handler = sigusr1_handler;
    sigaction(SIGUSR1, &act, &old_usr1_act);

    /*
     *  Start children.
     */

    infomsg("parent starting %d children ...", CHILDREN);
    for (i=0; i<CHILDREN; i++)
        start_child_sleep(CHILD_RUN_TIME(i));

    /*
     *  Main monitoring loop
     */

    infomsg("parent entering monitoring loop ...");
    while (TRUE) {
        now = time(NULL);

        /*
         *  Exit if no running children.
         */

        infomsg("parent checking for running children ...");
        running_children_count = 0;
        for (i=0; i<MAX_CHILDREN; i++)
            if (children[i].pid != 0)
                running_children_count++;
        infomsg("parent sees %d children still running", running_children_count);
        if (running_children_count == 0)
            break;

        /*
         *  Kill any children that have reached their timeout time and not
         *  been killed already.
         */

        killed_something = FALSE;
        for (i=0; i<MAX_CHILDREN; i++)
            if (children[i].pid != 0 && children[i].start != 0 &&
                    now >= children[i].start+TIMEOUT) {
                kill(children[i].pid, SIGTERM);
                children[i].start = 0;
                killed_something = TRUE;
            }

        /*
         *  Slight optimisation: if something did reach its timeout and got
         *  killed then skip to reassessing if this program can exit.
         */

        if (killed_something)
            continue;

        /*
         *  Schedule timeout alarm of next-to-timeout child.
         */

        infomsg("parent scheduling timeout alarm ...");
        next_timeout = 0;
        for (i=0; i<MAX_CHILDREN; i++)
            if (children[i].pid != 0 && children[i].start != 0)
                if (next_timeout == 0)
                    next_timeout = children[i].start+TIMEOUT - now;
                else if (children[i].start+TIMEOUT - now < next_timeout)
                    next_timeout = children[i].start+TIMEOUT - now;
        if (next_timeout >= 1) {
            infomsg("parent scheduling alarm for %ds ...", next_timeout);
            alarm(next_timeout);
        }

        /*
         *  If there are dispatched-but-not-yet-delivered signals then
         *  handle them. If there are none then wait for one.
         */

        infomsg("parent handling any pending signals ...");
        if (next_timeout >= 1)
            sigsuspend(&suspend_sigset);

        /*
         *  If SIGCHLD arrived before SIGALRM then the alarm is still
         *  pending. Cancel it.
         */

        infomsg("parent cancelling alarm ...");
        alarm(0);
    }

    /*
     *  Clean up and exit.
     */

    infomsg("parent cleaning up and exiting ...");
    sigaction(SIGUSR1, &old_usr1_act, NULL);
    sigaction(SIGALRM, &old_alrm_act, NULL);
    sigaction(SIGCHLD, &old_chld_act, NULL);
    sigprocmask(SIG_SETMASK, &old_sigset, NULL);
    return(0);
}

pid_t start_child_sleep(
int period)
{
    pid_t pid;
    char buf[ARG_MAX];
    int i;

    /*
     *  Find an empty slot to store info about the process we're
     *  about launch.
     */

    for (i=0; i<MAX_CHILDREN; i++)
        if (children[i].pid == 0)
            break;
    if (i == MAX_CHILDREN)
        errormsg("start_child_sleep: unable to find a free slot");

    /*
     *  Launch a child process and note its pid and start time
     *  in the empty slot.
     */

    sprintf(buf, "echo \"child $$ started ...\";"
                 "sleep %d;"
                 "echo \"child $$ exiting ...\"",
                 period);
    if ((pid=fork()) < 0)
        errormsg("fork() failed: %s", strerror(errno));
    else if (pid > 0) {
        children[i].pid = pid;
        children[i].start = time(NULL);
        return(pid);
    }

    /*
     *  Only the child gets here
     */

    execlp("/bin/sh", "sh", "-c", buf, (char *) NULL);
    errormsg("exec() failed: %s", strerror(errno));
}

void sigchld_handler(
int sig)
{
    int wstatus;
    pid_t pid;
    int i;

    while ((pid=waitpid(-1, &wstatus, WNOHANG)) > 0) {
        infomsg("parent received SIGCHLD; reaping and clearing child data ...");
        for (i=0; i<MAX_CHILDREN; i++)
            if (children[i].pid == pid) {
                children[i].pid = 0;
                children[i].start = 0;
                break;
            }
#if ! HANDLE_MULTIPLE_PENDING_SIGCHLDS_IN_ONE_GO
        break;
#endif
    }
}

void sigalrm_handler(
int sig)
{
   infomsg("parent received SIGALRM");
}

void sigusr1_handler(
int sig)
{
   int i;

   finfomsg(stderr, "parent received SIGUSR1");
   for (i=0; i<MAX_CHILDREN; i++)
       if (children[i].pid != 0)
           finfomsg(stderr, "slot:%04d; pid:%05d, start=%ld", 
                    i, children[i].pid, children[i].start);
}

#include <arpa/inet.h>          /* for inet_ntoa() */
#include <errno.h>              /* for errno() */
#include <netinet/in.h>
#include <signal.h>             /* for signal(), SIG* */
#include <stdio.h>              /* for sprintf(), stderr, ... */
#include <stdlib.h>             /* for exit() */
#include <string.h>             /* for strerror() */
#include <sys/types.h>          /* for wait() */
#include <sys/wait.h>           /* for wait() */
#include <time.h>               /* for time() */
#include <unistd.h>             /* for sleep(), fork() and execlp() */
#include <sys/socket.h>
#include "funcs.h"              /* for infomsg(), errormsg() */

/*
 *  Macros
 */

#define MAX_CHILDREN            1000
#define MYPORT                  2345
#define MAXPENDING              10
#define CHILD_RUN_TIME          20
#define USE_SA_RESTART          FALSE
#define BLOCK_SIGCHLD           FALSE

/*
 *  Type and struct definitions
 */

struct child {
    pid_t  pid;
    time_t start;
};

/*
 *  Global variables
 */

struct child children[MAX_CHILDREN];

/*
 *  Forward declarations
 */

pid_t start_child_server(int);
void handler(int);

/*
 *  Functions
 */

int main(
int argc,
char *argv[])
{
    int i;
    int listening_sfd, toclient_sfd;
    struct sockaddr_in listening_spars;
    struct sockaddr_in toclient_spars;
    int actual_toclient_spars_size;
    int sockoptval;
    sigset_t sigset, old_sigset, suspend_sigset;
    struct sigaction act, old_chld_act, old_alrm_act, old_usr1_act;

    /*
     *  Initialise.
     */

    infomsg("parent setting up listening socket ...");
    /* create addressless IPv4 TCP socket */
    if ((listening_sfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
        errormsg("socket() failed");
    /* ensure bind() doesn't find old stale socket */
    sockoptval = 1;
    setsockopt(listening_sfd, SOL_SOCKET, SO_REUSEADDR,
               &sockoptval, sizeof(sockoptval));
    /* define other socket parameters */
    memset(&listening_spars, 0, sizeof(struct sockaddr_in));
    listening_spars.sin_family = AF_INET;         /* IPv4 */
    listening_spars.sin_port = htons(MYPORT);     /* port */
    listening_spars.sin_addr.s_addr = INADDR_ANY; /* listen on all NICs */
    /* apply socket parameters */
    if (bind(listening_sfd, (struct sockaddr *) &listening_spars,
             sizeof(struct sockaddr)) == -1)
        errormsg("bind() failed");
    /* mark socket for listening */
    if (listen(listening_sfd, MAXPENDING) == -1)
        errormsg("listen() failed");

    infomsg("parent initialising children status table ...");
    for (i=0; i<MAX_CHILDREN; i++)
        children[i].pid = 0;

    infomsg("parent setting up signal handlers ...");
#if BLOCK_SIGCHLD
    sigemptyset(&sigset);
    sigaddset(&sigset, SIGCHLD);
    /* cause delivery of SIGCHLD, etc to be delayed until we call sigsuspend() */
    sigprocmask(SIG_BLOCK, &sigset, &old_sigset);
    /* later we need list of signals blocked before that sigprocmask() call,
       but *excluding* SIGCHLD, etc. */
    memcpy(&suspend_sigset, &old_sigset, sizeof(sigset_t));
    sigdelset(&suspend_sigset, SIGCHLD);
#endif
    /* establish signals handlers */
    memset(&act, 0, sizeof(struct sigaction));
    act.sa_mask = sigset;
#if USE_SA_RESTART
    act.sa_flags = SA_RESTART;
#else
    act.sa_flags = 0;
#endif
    act.sa_handler = handler;
    sigaction(SIGCHLD, &act, &old_chld_act);

    /*
     *  Main monitoring loop
     */

    infomsg("parent entering monitoring loop ...");
    while (TRUE) {
        /* wait for incoming connection, move it to a new socket */
        infomsg("parent awaiting incoming connection ...");
        actual_toclient_spars_size = sizeof(struct sockaddr_in);
        if ((toclient_sfd = accept(listening_sfd, 
                                   (struct sockaddr *) &toclient_spars,
                                   &actual_toclient_spars_size)) == -1) {
            infomsg("accept() failed");
            continue;
        }

        /*
         *  Start child server to talk to client.
         */

        infomsg("parent starting one child ...");
        start_child_server(toclient_sfd);
        /* child server uses toclient_sfd, not parent server */
        close(toclient_sfd);
    }

    /*
     *  Clean up and exit.
     */

    infomsg("parent cleaning up and exiting ...");
    sigaction(SIGCHLD, &old_chld_act, NULL);
#if BLOCK_SIGCHLD
    sigprocmask(SIG_SETMASK, &old_sigset, NULL);
#endif
    return(0);
}

pid_t start_child_server(
int toclient_sfd)
{
    pid_t pid;
    int i;
    const char *msg = "this is a message from the server to the client\n";

    /*
     *  Find an empty slot to store info about the process we're
     *  about launch.
     */

    for (i=0; i<MAX_CHILDREN; i++)
        if (children[i].pid == 0)
            break;
    if (i == MAX_CHILDREN)
        errormsg("start_child_sleep: unable to find a free slot");

    /*
     *  Launch a child server and note its pid and start time
     *  in the empty slot.
     */

    if ((pid=fork()) < 0)
        errormsg("fork() failed: %s", strerror(errno));
    else if (pid > 0) {
        children[i].pid = pid;
        children[i].start = time(NULL);
        return(pid);
    }

    /*
     *  Only the child gets here
     */

    infomsg("child is pid %d", (int) getpid());
    infomsg("child sending message to client ...");
    if (send(toclient_sfd, msg, strlen(msg), 0) == -1)
        errormsg("send");
    infomsg("child sleeping a bit ...");
    sleep(CHILD_RUN_TIME);
    infomsg("child exiting ...");
    close(toclient_sfd);
    exit(EXIT_SUCCESS);
}

void handler(
int sig)
{
    int wstatus;
    pid_t pid;
    int i;

    switch (sig) {
        case SIGCHLD: while ((pid=waitpid(-1, &wstatus, WNOHANG)) > 0) {
                          infomsg("parent received SIGCHLD; reaping and clearing child data ...");
                          for (i=0; i<MAX_CHILDREN; i++)
                              if (children[i].pid == pid) {
                                  children[i].pid = 0;
                                  children[i].start = 0;
                                  break;
                              }
                      }
                      break;
        default:      errormsg("parent received unexpected signal %d", sig);
                      break;
    }
}

#define USE_SA_RESTART FALSE
#define BLOCK_SIGCHLD FALSE

#define USE_SA_RESTART TRUE
#define BLOCK_SIGCHLD FALSE

#define USE_SA_RESTART FALSE
#define BLOCK_SIGCHLD TRUE

#include <errno.h>              /* for errno() */
#include <linux/limits.h>       /* for ARG_MAX */
#include <signal.h>             /* for signal(), SIG* */
#include <stdio.h>              /* for sprintf(), stderr, ... */
#include <stdlib.h>             /* for exit() */
#include <string.h>             /* for strerror() */
#include <sys/types.h>          /* for wait() */
#include <sys/wait.h>           /* for wait() */
#include <time.h>               /* for time() */
#include <unistd.h>             /* for sleep(), fork() and execlp() */
#include "funcs.h"              /* for infomsg(), errormsg() */

/*
 *  Macros
 */

#define MAX_CHILDREN            10000
#define CHILDREN                5000
#define TIMEOUT                 300
#define A_LONG_TIME             3600
#define CHILD_RUN_TIME(n)       1

/*
 *  Type and struct definitions
 */

struct child {
    pid_t  pid;
    time_t start;
};

/*
 *  Global variables
 */

struct child children[MAX_CHILDREN];

/*
 *  Forward declarations
 */

pid_t start_child_sleep(int);
void handler(int);

/*
 *  Functions
 */

int main(
int argc,
char *argv[])
{
    int i;
    int running_children_count, next_timeout, killed_something;
    time_t now;
    sigset_t sigset, old_sigset, suspend_sigset;
    struct sigaction act, old_chld_act, old_alrm_act, old_usr1_act;

    /*
     *  Initialise.
     */

    infomsg("parent initialising children status table ...");
    for (i=0; i<MAX_CHILDREN; i++)
        children[i].pid = 0;

    infomsg("parent setting up signal handlers ...");
    /*
     *  Define signal set for two purposes: 
     *      (1) for sigprocmask() call, 
     *      (2) for sigaction() we need list of *additional* signals to block
     *          while executing the handler (we specify all three signals, which
     *          is slightly more than *just* the additional signals, but it does
     *          no harm)
     */
    sigemptyset(&sigset);
    sigaddset(&sigset, SIGCHLD);
    sigaddset(&sigset, SIGALRM);
    sigaddset(&sigset, SIGUSR1);
    /* cause delivery of SIGCHLD, etc to be delayed until we call sigsuspend() */
    sigprocmask(SIG_BLOCK, &sigset, &old_sigset);
    /* later we need list of signals blocked before that sigprocmask() call,
       but *excluding* SIGCHLD, etc. */
    memcpy(&suspend_sigset, &old_sigset, sizeof(sigset_t));
    sigdelset(&suspend_sigset, SIGCHLD);
    sigdelset(&suspend_sigset, SIGALRM);
    sigdelset(&suspend_sigset, SIGUSR1);
    /* establish signals handlers */
    memset(&act, 0, sizeof(struct sigaction));
    act.sa_mask = sigset;
    act.sa_flags = SA_RESTART;  
    act.sa_handler = handler;
    sigaction(SIGCHLD, &act, &old_chld_act);
    sigaction(SIGALRM, &act, &old_alrm_act);
    sigaction(SIGUSR1, &act, &old_usr1_act);

    /*
     *  Start children.
     */

    infomsg("parent starting %d children ...", CHILDREN);
    for (i=0; i<CHILDREN; i++)
        start_child_sleep(CHILD_RUN_TIME(i));

    /*
     *  Main monitoring loop
     */

    infomsg("parent entering monitoring loop ...");
    while (TRUE) {
        now = time(NULL);

        /*
         *  Exit if no running children.
         */

        /* infomsg("parent checking for running children ..."); */
        running_children_count = 0;
        for (i=0; i<MAX_CHILDREN; i++)
            if (children[i].pid != 0)
                running_children_count++;
        /* infomsg("%parent sees %d children still running", running_children_count); */
        if (running_children_count == 0)
            break;

        /*
         *  Kill any children that have reached their timeout time and not
         *  been killed already.
         */

        killed_something = FALSE;
        for (i=0; i<MAX_CHILDREN; i++)
            if (children[i].pid != 0 && children[i].start != 0 &&
                    now >= children[i].start+TIMEOUT) {
                kill(children[i].pid, SIGTERM);
                children[i].start = 0;
                killed_something = TRUE;
            }

        /*
         *  Slight optimisation: if something did reach its timeout and got
         *  killed then skip to reassessing if this program can exit.
         */

        if (killed_something)
            continue;

        /*
         *  Schedule timeout alarm of next-to-timeout child.
         */

        /* infomsg("parent scheduling timeout alarm ..."); */
        next_timeout = 0;
        for (i=0; i<MAX_CHILDREN; i++)
            if (children[i].pid != 0 && children[i].start != 0)
                if (next_timeout == 0)
                    next_timeout = children[i].start+TIMEOUT - now;
                else if (children[i].start+TIMEOUT - now < next_timeout)
                    next_timeout = children[i].start+TIMEOUT - now;
        if (next_timeout >= 1) {
            /* infomsg("parent scheduling alarm for %ds ...", next_timeout); */
            alarm(next_timeout);
        }

        /*
         *  If there are dispatched-but-not-yet-delivered signals then
         *  handle them. If there are none then wait for one.
         */

        /* infomsg("parent handling any pending signals ..."); */
        if (next_timeout >= 1)
            sigsuspend(&suspend_sigset);

        /*
         *  If SIGCHLD arrived before SIGALRM then the alarm is still
         *  pending. Cancel it.
         */

        /* infomsg("parent cancelling alarm ..."); */
        alarm(0);
    }

    /*
     *  Clean up and exit.
     */

    infomsg("parent cleaning up and exiting ...");
    sigaction(SIGUSR1, &old_usr1_act, NULL);
    sigaction(SIGALRM, &old_alrm_act, NULL);
    sigaction(SIGCHLD, &old_chld_act, NULL);
    sigprocmask(SIG_SETMASK, &old_sigset, NULL);
    return(0);
}

pid_t start_child_sleep(
int period)
{
    pid_t pid;
    char buf[ARG_MAX];
    int i;

    /*
     *  Find an empty slot to store info about the process we're
     *  about launch.
     */

    for (i=0; i<MAX_CHILDREN; i++)
        if (children[i].pid == 0)
            break;
    if (i == MAX_CHILDREN)
        errormsg("start_child_sleep: unable to find a free slot");

    /*
     *  Launch a child process and note its pid and start time
     *  in the empty slot.
     */

    sprintf(buf, "sleep %d", period);
    if ((pid=fork()) < 0)
        errormsg("fork() failed: %s", strerror(errno));
    else if (pid > 0) {
        children[i].pid = pid;
        children[i].start = time(NULL);
        return(pid);
    }

    /*
     *  Only the child gets here
     */

    execlp("/bin/sh", "sh", "-c", buf, (char *) NULL);
    errormsg("exec() failed: %s", strerror(errno));
}

void handler(
int sig)
{
    int wstatus;
    pid_t pid;
    int i;

    switch (sig) {
        case SIGCHLD: while ((pid=waitpid(-1, &wstatus, WNOHANG)) > 0) {
                          /* infomsg("parent received SIGCHLD; reaping and clearing child data ..."); */
                          for (i=0; i<MAX_CHILDREN; i++)
                              if (children[i].pid == pid) {
                                  children[i].pid = 0;
                                  children[i].start = 0;
                                  break;
                              }
                      }
                      break;
        case SIGALRM: /* infomsg("parent received SIGALRM"); */
                      break;
        case SIGUSR1: finfomsg(stderr, "parent received SIGUSR1");
                      for (i=0; i<MAX_CHILDREN; i++)
                          if (children[i].pid != 0)
                              finfomsg(stderr, "slot:%04d; pid:%05d, start=%ld", 
                                       i, children[i].pid, children[i].start);
                      break;
        default:      errormsg("parent received unexpected signal %d", sig);
                      break;
    }
}

#!/usr/bin/perl

#
#  Modules
#

use POSIX;
use Time::HiRes;
use feature 'state';   #  let doubletime() have a static variable

#
#  Global variables
#

my($MAX_CHILDREN) = 10000;
my($CHILDREN)     = 5000;
my($TIMEOUT)      = 300;
my($A_LONG_TIME)  = 3600;
sub CHILD_RUN_TIME { my($n) = @_; return 1; }
my(@children)     = ();

#
#  Functions
#

sub main
{
    my($i);
    my($running_children_count, $next_timeout, $killed_something);
    my($now);
    my($sigset, $old_sigset, $suspend_sigset);
    my($act, $old_chld_act, $old_alrm_act, $old_usr1_act);

    # 
    #  Initialise.
    # 

    &infomsg("parent initialising children status table ...");
    for ($i=0; $i<$MAX_CHILDREN; $i++) {
        %{$children[$i]} = ();
        $children[$i]{'pid'} = 0;
    }

    &infomsg("parent setting up signal handlers ...");
    # 
    #  Define signal set for two purposes: 
    #      (1) for sigprocmask() call, 
    #      (2) for sigaction() we need list of *additional* signals to block
    #          while executing the handler (we specify all three signals, which
    #          is slightly more than *just* the additional signals, but it does
    #          no harm)
    # 
    $sigset = POSIX::SigSet->new;
    $sigset->addset(POSIX::SIGCHLD);
    $sigset->addset(POSIX::SIGALRM);
    $sigset->addset(POSIX::SIGUSR1);
    $old_sigset = POSIX::SigSet->new;
    #  cause delivery of SIGCHLD, etc to be delayed until we call sigsuspend()
    POSIX::sigprocmask(SIG_BLOCK, $sigset, $old_sigset);
    #  later we need list of signals blocked before that sigprocmask() call, 
    #  but *excluding* SIGCHLD, etc.
    $suspend_sigset = $old_sigset;
    $suspend_sigset->delset(POSIX::SIGCHLD);
    $suspend_sigset->delset(POSIX::SIGALRM);
    $suspend_sigset->delset(POSIX::SIGUSR1);
    #  establish signals handlers
    $act = POSIX::SigAction->new;
    $act->mask($sigset);
    $act->flags(&POSIX::SA_RESTART);
    $act->handler(\&handler);
    $old_chld_act = POSIX::SigAction->new;
    $old_alrm_act = POSIX::SigAction->new;
    $old_usr1_act = POSIX::SigAction->new;
    POSIX::sigaction(SIGCHLD, $act, $old_chld_act);
    POSIX::sigaction(SIGALRM, $act, $old_alrm_act);
    POSIX::sigaction(SIGUSR1, $act, $old_usr1_act);

    #  
    #  Start children.
    #  

    &infomsg("parent starting %d children ...", $CHILDREN);
    for ($i=0; $i<$CHILDREN; $i++) {
        &start_child_sleep(&CHILD_RUN_TIME($i));
    }

    # 
    #  Main monitoring loop
    # 

    &infomsg("parent entering monitoring loop ...");
    while (1) {
        $now = time;
    
        # 
        #  Exit if no running children.
        # 

        &infomsg("parent checking for running children ...");
        $running_children_count = 0;
        for ($i=0; $i<$MAX_CHILDREN; $i++) {
            if ($children[$i]{'pid'} != 0) {
                $running_children_count++;
            }
        }
        &infomsg("parent sees %d children still running", $running_children_count);
        if ($running_children_count == 0) {
            last;
        }

        # 
        #  Kill any children that have reached their timeout time and not
        #  been killed already.
        # 

        $killed_something = 0;
        for ($i=0; $i<$MAX_CHILDREN; $i++) {
            if ($children[$i]{'pid'} != 0 && $children[$i]{'start'} != 0 &&
                    $now >= $children[$i]{'start'}+$TIMEOUT) {
                kill($children[$i]{'pid'}, SIGTERM);
                $children[$i]{'start'} = 0;
                $killed_something = 1;
            }
        }

        # 
        #  Slight optimisation: if something did reach its timeout and got
        #  killed then skip to reassessing if this program can exit.
        # 

        if ($killed_something) {
            next;
        }

        # 
        #  Schedule timeout alarm of next-to-timeout child.
        # 

        &infomsg("parent scheduling timeout alarm ...");
        $next_timeout = 0;
        for ($i=0; $i<$MAX_CHILDREN; $i++) {
            if ($children[$i]{'pid'} != 0 && $children[$i]{'start'} != 0) {
                if ($next_timeout == 0) {
                    $next_timeout = $children[$i]{'start'}+$TIMEOUT - $now;
                } elsif ($children[$i]{'start'}+$TIMEOUT - $now < $next_timeout) {
                    $next_timeout = $children[$i]{'start'}+$TIMEOUT - $now;
                }
            }
        }
        if ($next_timeout >= 1) {
            &infomsg("parent scheduling alarm for %ds ...", $next_timeout);
            POSIX::alarm($next_timeout);
        }

        # 
        #  If there are dispatched-but-not-yet-delivered signals then
        #  handle them. If there are none then wait for one.
        # 

        &infomsg("parent handling any pending signals ...");
        if ($next_timeout >= 1) {
            POSIX::sigsuspend($suspend_sigset);
        }

        # 
        #  If SIGCHLD arrived before SIGALRM then the alarm is still
        #  pending. Cancel it.
        # 

        &infomsg("parent cancelling alarm ...");
        POSIX::alarm(0);
    }

    #
    #  Clean up and exit.
    #

    &infomsg("parent cleaning up and exiting ...");
    #  C allows third argument to be NULL, meaning don't bother telling me
    #  what the old sig action was. But Perl insists on proper third argument.
    #  By chance we have a sig action variable that we no longer need - act -
    #  so we let sigaction() write in there. sigprocmask() on the other hand
    #  seems to accept undef as third argument.
    POSIX::sigaction(SIGUSR1, $old_usr1_act, $act);
    POSIX::sigaction(SIGALRM, $old_alrm_act, $act);
    POSIX::sigaction(SIGCHLD, $old_chld_act, $act);
    POSIX::sigprocmask(SIG_SETMASK, $old_sigset, undef);
    return 0;
}

sub start_child_sleep
{
    my($period) = @_;
    my($pid);
    my($buf);
    my($i);

    # 
    #  Find an empty slot to store info about the process we're
    #  about launch.
    # 

    for ($i=0; $i<$MAX_CHILDREN; $i++) {
        if ($children[$i]{'pid'} == 0) {
            last;
        }
    }
    if ($i == $MAX_CHILDREN) {
        &errormsg("start_child_sleep: unable to find a free slot");
    }

    # 
    #  Launch a child process and note its pid and start time
    #  in the empty slot.
    # 

    $buf = "sleep $period"
    if (($pid=fork) < 0) {
        &errormsg("fork() failed: %s", strerror(errno));
    } elsif ($pid > 0) {
        $children[$i]{'pid'} = $pid;
        $children[$i]{'start'} = time;
        return($pid);
    }

    # 
    #  Only the child gets here
    # 

    exec '/bin/sh', '-c', $buf;
    &errormsg("exec() failed: $!");
}

sub handler
{
    my($sig) = @_;
    my($pid);
    my($i);

    if ($sig eq 'CHLD') {
        while (($pid=waitpid(-1, WNOHANG)) > 0) {
            for ($i=0; $i<$MAX_CHILDREN; $i++) {
                if ($children[$i]{'pid'} == $pid) {
                    $children[$i]{'pid'} = 0;
                    $children[$i]{'start'} = 0;
                    break;
                }
            }
        }
    } elsif ($sig eq 'ALRM') {
        &infomsg("parent received SIGALRM");
    } elsif ($sig eq 'USR1') {
        &finfomsg(\*STDERR, "parent received SIGUSR1");
        for ($i=0; $i<$MAX_CHILDREN; $i++) {
            if ($children[$i]{'pid'} != 0) {
                &finfomsg(\*STDERR, "slot:%04d; pid:%05d, start=%ld", 
                          $i, $children[$i]{'pid'}, $children[$i]{'start'});
            }
        }
    } else {
        &errormsg("parent received unexpected signal %s", $sig);
    }
}

sub doubletime
{
    state $start = undef;  #  static
    my($now);

    $now = Time::HiRes::time();

    if (not defined($start)) {
        $start = $now;
    }

    return($now - $start);
}

sub infomsg
{
    my($fmt, @args) = @_;

    #  substr() strips 'main::' module prefix.
    &real_fmessage(substr((caller(1))[3],6), \*STDOUT, $fmt, @args);
}

sub errormsg
{
    my($fmt, @args) = @_;

    #  substr() strips 'main::' module prefix.
    &real_fmessage(substr((caller(1))[3],6), \*STDOUT, $fmt, @args);
    exit 1;
}

sub finfomsg
{
    my($fp, $fmt, @args) = @_;

    &real_fmessage(substr((caller(1))[3],6), $fp, $fmt, @args);
}

sub ferrormsg
{
    my($fp, $fmt, @args) = @_;

    &real_fmessage(substr((caller(1))[3],6), $fp, $fmt, @args);
    exit 1;
}

sub real_fmessage
{
    my($func, $fp, $fmt, @args) = @_;

    printf $fp "%.06lf: %s: ", &doubletime(), $func;
    printf $fp $fmt, @args;
    printf $fp "\n";
}

&main();

#!/usr/bin/python3

#
#  Modules
#

import inspect
import signal
import time
import os
import sys

#
#  Macros
#

MAX_CHILDREN   = 10000
CHILDREN       = 1000
TIMEOUT        = 300
A_LONG_TIME    = 3600
CHILD_RUN_TIME = lambda n: 1

#
#  Global variables
#

children = []

#
#  Functions
#

def main():

    # 
    #  Initialise.
    # 

    infomsg('parent initialising children status table ...')
    for i in range(0,MAX_CHILDREN):
        children.append({'pid':0})

    infomsg('parent setting up signal handlers ...')
    signal.signal(signal.SIGCHLD, handler)
    signal.signal(signal.SIGALRM, handler)
    signal.signal(signal.SIGUSR1, handler)

    #  
    #  Start children.
    #  

    infomsg('parent starting %d children ...', CHILDREN)
    for i in range(0,CHILDREN):
        start_child_sleep(CHILD_RUN_TIME(i))

    # 
    #  Main monitoring loop
    # 

    infomsg('parent entering monitoring loop ...')
    while True:
        now = int(time.time())

        # 
        #  Exit if no running children.
        # 

        running_children_count = 0
        for i in range(0,MAX_CHILDREN):
            if  children[i]['pid'] != 0:
                running_children_count += 1
        if running_children_count == 0:
            break

        # 
        #  Kill any children that have reached their timeout time and not
        #  been killed already.
        # 

        killed_something = False
        for i in range(0,MAX_CHILDREN):
            if children[i]['pid'] != 0 and children[i]['start'] != 0 and \
                    now >= children[i]['start']+TIMEOUT:
                os.kill(children[i]['pid'], signal.SIGTERM)
                children[i]['start'] = 0
                killed_something = True

        # 
        #  Slight optimisation: if something did reach its timeout and got
        #  killed then skip to reassessing if this program can exit.
        # 

        if killed_something:
            continue

        # 
        #  Schedule timeout alarm of next-to-timeout child.
        # 

        next_timeout = 0
        for i in range(0,MAX_CHILDREN):
            if children[i]['pid'] != 0 and children[i]['start'] != 0:
                if next_timeout == 0:
                    next_timeout = children[i]['start']+TIMEOUT - now
                elif children[i]['start']+TIMEOUT - now < next_timeout:
                    next_timeout = children[i]['start']+TIMEOUT - now
        if next_timeout >= 1:
            signal.alarm(next_timeout)

        # 
        #  If there are dispatched-but-not-yet-delivered signals then
        #  handle them. If there are none then wait for one.
        # 

        if next_timeout >= 1:
             signal.pause()

        # 
        #  If SIGCHLD arrived before SIGALRM then the alarm is still
        #  pending. Cancel it.
        # 

        signal.alarm(0)

    #
    #  Clean up and exit.
    #

    infomsg('parent cleaning up and exiting ...')
    signal.signal(signal.SIGUSR1, signal.SIG_DFL)
    signal.signal(signal.SIGALRM, signal.SIG_DFL)
    signal.signal(signal.SIGCHLD, signal.SIG_DFL)
    return 0

def start_child_sleep(period):
    global children

    # 
    #  Find an empty slot to store info about the process we're
    #  about launch.
    # 

    for i in range(0,MAX_CHILDREN):
        if children[i]['pid'] == 0:
            break
    if i == MAX_CHILDREN:
        errormsg('start_child_sleep: unable to find a free slot')

    # 
    #  Launch a child process and note its pid and start time
    #  in the empty slot.
    # 

    buf = 'sleep %d' % (period)
    try:
        pid = os.fork()
    except:
        errormsg('fork failed')
    if pid > 0:
        children[i]['pid'] = pid
        children[i]['start'] = int(time.time())
        return pid

    # 
    #  Only the child gets here
    # 

    os.execlp('/bin/sh', 'sh', '-c', buf)
    errormsg('exec() failed')

def handler(sig, frame):
    global children

    if sig == signal.SIGCHLD:
        while True:
            #  Seems like waitpid() can either raise an exception or return 0
            try:
                pid = os.waitpid(-1, os.WNOHANG)[0]
            except:
                break
            if pid <= 0:
                break
            for i in range(0,MAX_CHILDREN):
                if children[i]['pid'] == pid:
                    children[i]['pid'] = 0
                    children[i]['start'] = 0
                    break
    elif sig == signal.SIGALRM:
        infomsg('parent received SIGALRM')
    elif sig == signal.SIGUSR1:
        finfomsg(sys.stderr, 'parent received SIGUSR1')
        for i in range(0,MAX_CHILDREN):
            if children[i]['pid'] != 0:
                finfomsg(sys.stderr, 'slot:%04d; pid:%05d, start=%ld', 
                         i, children[i]['pid'], children[i]['start'])
    else:
        errormsg('parent received unexpected signal %s', sig)

def doubletime():
    now = time.time()

    if not hasattr(doubletime, "start"):
         doubletime.start = now

    return now-doubletime.start

def infomsg(fmt, *args):
    real_fmessage(inspect.stack()[1].function, sys.stdout, fmt, *args)

def errormsg(fmt, *args):

    real_fmessage(inspect.stack()[1].function, sys.stdout, fmt, *args)
    sys.exit(1)

def finfomsg(fp, fmt, *args):

    real_fmessage(inspect.stack()[1].function, fp, fmt, *args)

def ferrormsg(fp, fmt, *args):

    real_fmessage(inspect.stack()[1].function, fp, fmt, *args)
    sys.exit(1)

def real_fmessage(func, fp, fmt, *args):

    fp.write('%.06lf: %s: ' % (doubletime(), func))
    fp.write(fmt % args)
    fp.write('\n')

main()

#!/usr/bin/python3

#
#  Modules
#

import inspect
import signal
import time
import os
import sys
import queue

#
#  Macros
#

MAX_CHILDREN   = 10000
CHILDREN       = 1000
TIMEOUT        = 300
A_LONG_TIME    = 3600
CHILD_RUN_TIME = lambda n: 1

#
#  Global variables
#

children = []

#
#  Functions
#

def main():
    global q

    # 
    #  Initialise.
    # 

    infomsg('parent initialising children status table ...')
    for i in range(0,MAX_CHILDREN):
        children.append({'pid':0})

    infomsg('parent setting up signal handlers ...')
    q = queue.Queue()
    signal.signal(signal.SIGCHLD, handler)
    signal.signal(signal.SIGALRM, handler)
    signal.signal(signal.SIGUSR1, handler)

    #  
    #  Start children.
    #  

    infomsg('parent starting %d children ...', CHILDREN)
    for i in range(0,CHILDREN):
        start_child_sleep(CHILD_RUN_TIME(i))

    # 
    #  Main monitoring loop
    # 

    infomsg('parent entering monitoring loop ...')
    while True:
        now = int(time.time())

        #
        #  Deal with incoming messages.
        #

        while True:
            try:
                pid = q.get(False)
            except queue.Empty:
                break
            for i in range(0,MAX_CHILDREN):
                if children[i]['pid'] == pid:
                    children[i]['pid'] = 0
                    children[i]['start'] = 0
                    break
     
    
        # 
        #  Exit if no running children.
        # 

        running_children_count = 0
        for i in range(0,MAX_CHILDREN):
            if  children[i]['pid'] != 0:
                running_children_count += 1
        if running_children_count == 0:
            break

        # 
        #  Kill any children that have reached their timeout time and not
        #  been killed already.
        # 

        killed_something = False
        for i in range(0,MAX_CHILDREN):
            if children[i]['pid'] != 0 and children[i]['start'] != 0 and \
                    now >= children[i]['start']+TIMEOUT:
                os.kill(children[i]['pid'], signal.SIGTERM)
                children[i]['start'] = 0
                killed_something = True

        # 
        #  Slight optimisation: if something did reach its timeout and got
        #  killed then skip to reassessing if this program can exit.
        # 

        if killed_something:
            continue

        # 
        #  Schedule timeout alarm of next-to-timeout child.
        # 

        next_timeout = 0
        for i in range(0,MAX_CHILDREN):
            if children[i]['pid'] != 0 and children[i]['start'] != 0:
                if next_timeout == 0:
                    next_timeout = children[i]['start']+TIMEOUT - now
                elif children[i]['start']+TIMEOUT - now < next_timeout:
                    next_timeout = children[i]['start']+TIMEOUT - now
        if next_timeout >= 1:
            signal.alarm(next_timeout)

        # 
        #  If there are dispatched-but-not-yet-delivered signals then
        #  handle them. If there are none then wait for one.
        # 

        if next_timeout >= 1:
             signal.pause()

        # 
        #  If SIGCHLD arrived before SIGALRM then the alarm is still
        #  pending. Cancel it.
        # 

        signal.alarm(0)

    #
    #  Clean up and exit.
    #

    infomsg('parent cleaning up and exiting ...')
    signal.signal(signal.SIGUSR1, signal.SIG_DFL)
    signal.signal(signal.SIGALRM, signal.SIG_DFL)
    signal.signal(signal.SIGCHLD, signal.SIG_DFL)
    return 0

def start_child_sleep(period):
    global children

    # 
    #  Find an empty slot to store info about the process we're
    #  about launch.
    # 

    for i in range(0,MAX_CHILDREN):
        if children[i]['pid'] == 0:
            break
    if i == MAX_CHILDREN:
        errormsg('start_child_sleep: unable to find a free slot')

    # 
    #  Launch a child process and note its pid and start time
    #  in the empty slot.
    # 

    buf = 'sleep %d' % (period)
    try:
        pid = os.fork()
    except:
        errormsg('fork failed')
    if pid > 0:
        children[i]['pid'] = pid
        children[i]['start'] = int(time.time())
        return pid

    # 
    #  Only the child gets here
    # 

    os.execlp('/bin/sh', 'sh', '-c', buf)
    errormsg('exec() failed')

def handler(sig, frame):
    global q

    if sig == signal.SIGCHLD:
        while True:
            #  Seems like waitpid() can either raise an exception or return 0
            try:
                pid = os.waitpid(-1, os.WNOHANG)[0]
            except:
                break
            if pid <= 0:
                break
            q.put(pid)
    elif sig == signal.SIGALRM:
        infomsg('parent received SIGALRM')
    elif sig == signal.SIGUSR1:
        finfomsg(sys.stderr, 'parent received SIGUSR1')
        for i in range(0,MAX_CHILDREN):
            if children[i]['pid'] != 0:
                finfomsg(sys.stderr, 'slot:%04d; pid:%05d, start=%ld', 
                         i, children[i]['pid'], children[i]['start'])
    else:
        errormsg('parent received unexpected signal %s', sig)

def doubletime():
    now = time.time()

    if not hasattr(doubletime, "start"):
         doubletime.start = now

    return now-doubletime.start

def infomsg(fmt, *args):
    real_fmessage(inspect.stack()[1].function, sys.stdout, fmt, *args)

def errormsg(fmt, *args):

    real_fmessage(inspect.stack()[1].function, sys.stdout, fmt, *args)
    sys.exit(1)

def finfomsg(fp, fmt, *args):

    real_fmessage(inspect.stack()[1].function, fp, fmt, *args)

def ferrormsg(fp, fmt, *args):

    real_fmessage(inspect.stack()[1].function, fp, fmt, *args)
    sys.exit(1)

def real_fmessage(func, fp, fmt, *args):

    fp.write('%.06lf: %s: ' % (doubletime(), func))
    fp.write(fmt % args)
    fp.write('\n')

main()

#!/usr/bin/python3

#
#  Modules
#

import inspect
import signal
import time
import os
import sys
import sysv_ipc

#
#  Macros
#

MAX_CHILDREN   = 10000
CHILDREN       = 1000
TIMEOUT        = 300
A_LONG_TIME    = 3600
CHILD_RUN_TIME = lambda n: 1

#
#  Global variables
#

children = []

#
#  Functions
#

def main():
    global q

    # 
    #  Initialise.
    # 

    infomsg('parent initialising children status table ...')
    for i in range(0,MAX_CHILDREN):
        children.append({'pid':0})

    infomsg('parent setting up signal handlers ...')
    q = sysv_ipc.MessageQueue(None, sysv_ipc.IPC_CREAT | sysv_ipc.IPC_EXCL)
    signal.signal(signal.SIGCHLD, handler)
    signal.signal(signal.SIGALRM, handler)
    signal.signal(signal.SIGUSR1, handler)

    #  
    #  Start children.
    #  

    infomsg('parent starting %d children ...', CHILDREN)
    for i in range(0,CHILDREN):
        start_child_sleep(CHILD_RUN_TIME(i))

    # 
    #  Main monitoring loop
    # 

    infomsg('parent entering monitoring loop ...')
    while True:
        now = int(time.time())

        #
        #  Deal with incoming messages.
        #

        while True:
            try:
                s, _ = q.receive(False)
                pid = int(s.decode())
            except sysv_ipc.BusyError:
                break
            for i in range(0,MAX_CHILDREN):
                if children[i]['pid'] == pid:
                    children[i]['pid'] = 0
                    children[i]['start'] = 0
                    break
     
    
        # 
        #  Exit if no running children.
        # 

        running_children_count = 0
        for i in range(0,MAX_CHILDREN):
            if  children[i]['pid'] != 0:
                running_children_count += 1
        if running_children_count == 0:
            break

        # 
        #  Kill any children that have reached their timeout time and not
        #  been killed already.
        # 

        killed_something = False
        for i in range(0,MAX_CHILDREN):
            if children[i]['pid'] != 0 and children[i]['start'] != 0 and \
                    now >= children[i]['start']+TIMEOUT:
                os.kill(children[i]['pid'], signal.SIGTERM)
                children[i]['start'] = 0
                killed_something = True

        # 
        #  Slight optimisation: if something did reach its timeout and got
        #  killed then skip to reassessing if this program can exit.
        # 

        if killed_something:
            continue

        # 
        #  Schedule timeout alarm of next-to-timeout child.
        # 

        next_timeout = 0
        for i in range(0,MAX_CHILDREN):
            if children[i]['pid'] != 0 and children[i]['start'] != 0:
                if next_timeout == 0:
                    next_timeout = children[i]['start']+TIMEOUT - now
                elif children[i]['start']+TIMEOUT - now < next_timeout:
                    next_timeout = children[i]['start']+TIMEOUT - now
        if next_timeout >= 1:
            signal.alarm(next_timeout)

        # 
        #  If there are dispatched-but-not-yet-delivered signals then
        #  handle them. If there are none then wait for one.
        # 

        if next_timeout >= 1:
             signal.pause()

        # 
        #  If SIGCHLD arrived before SIGALRM then the alarm is still
        #  pending. Cancel it.
        # 

        signal.alarm(0)

    #
    #  Clean up and exit.
    #

    infomsg('parent cleaning up and exiting ...')
    signal.signal(signal.SIGUSR1, signal.SIG_DFL)
    signal.signal(signal.SIGALRM, signal.SIG_DFL)
    signal.signal(signal.SIGCHLD, signal.SIG_DFL)
    return 0

def start_child_sleep(period):
    global children

    # 
    #  Find an empty slot to store info about the process we're
    #  about launch.
    # 

    for i in range(0,MAX_CHILDREN):
        if children[i]['pid'] == 0:
            break
    if i == MAX_CHILDREN:
        errormsg('start_child_sleep: unable to find a free slot')

    # 
    #  Launch a child process and note its pid and start time
    #  in the empty slot.
    # 

    buf = 'sleep %d' % (period)
    try:
        pid = os.fork()
    except:
        errormsg('fork failed')
    if pid > 0:
        children[i]['pid'] = pid
        children[i]['start'] = int(time.time())
        return pid

    # 
    #  Only the child gets here
    # 

    os.execlp('/bin/sh', 'sh', '-c', buf)
    errormsg('exec() failed')

def handler(sig, frame):
    global q

    if sig == signal.SIGCHLD:
        while True:
            #  Seems like waitpid() can either raise an exception or return 0
            try:
                pid = os.waitpid(-1, os.WNOHANG)[0]
            except:
                break
            if pid <= 0:
                break
            q.send(str(pid))
    elif sig == signal.SIGALRM:
        infomsg('parent received SIGALRM')
    elif sig == signal.SIGUSR1:
        finfomsg(sys.stderr, 'parent received SIGUSR1')
        for i in range(0,MAX_CHILDREN):
            if children[i]['pid'] != 0:
                finfomsg(sys.stderr, 'slot:%04d; pid:%05d, start=%ld', 
                         i, children[i]['pid'], children[i]['start'])
    else:
        errormsg('parent received unexpected signal %s', sig)

def doubletime():
    now = time.time()

    if not hasattr(doubletime, "start"):
         doubletime.start = now

    return now-doubletime.start

def infomsg(fmt, *args):
    real_fmessage(inspect.stack()[1].function, sys.stdout, fmt, *args)

def errormsg(fmt, *args):

    real_fmessage(inspect.stack()[1].function, sys.stdout, fmt, *args)
    sys.exit(1)

def finfomsg(fp, fmt, *args):

    real_fmessage(inspect.stack()[1].function, fp, fmt, *args)

def ferrormsg(fp, fmt, *args):

    real_fmessage(inspect.stack()[1].function, fp, fmt, *args)
    sys.exit(1)

def real_fmessage(func, fp, fmt, *args):

    fp.write('%.06lf: %s: ' % (doubletime(), func))
    fp.write(fmt % args)
    fp.write('\n')

main()

#!/usr/bin/python3

#
#  Modules
#

import inspect
import signal
import time
import os
import sys
import pysigset

#
#  Macros
#

MAX_CHILDREN   = 10000
CHILDREN       = 1000
TIMEOUT        = 300
A_LONG_TIME    = 3600
CHILD_RUN_TIME = lambda n: 1

#
#  Global variables
#

children = []

#
#  Functions
#

def main():

    # 
    #  Initialise.
    # 

    infomsg('parent initialising children status table ...')
    for i in range(0,MAX_CHILDREN):
        children.append({'pid':0})

    infomsg('parent setting up signal handlers ...')
    # 
    #  Define signal set for two purposes: 
    #      (1) for sigprocmask() call, 
    #      (2) for sigaction() we need list of *additional* signals to block
    #          while executing the handler (we specify all three signals, which
    #          is slightly more than *just* the additional signals, but it does
    #          no harm)
    # 

    sigset = pysigset.SIGSET()
    pysigset.sigaddset(sigset, signal.SIGCHLD)
    pysigset.sigaddset(sigset, signal.SIGALRM)
    pysigset.sigaddset(sigset, signal.SIGUSR1)
    #  cause delivery of SIGCHLD, etc to be delayed until we call sigsuspend()
    old_sigset = pysigset.SIGSET()
    pysigset.sigprocmask(signal.SIG_BLOCK, sigset, old_sigset)
    #  later we need list of signals blocked before that sigprocmask() call,
    #  but *excluding* SIGCHLD, etc.
    suspend_sigset = old_sigset
    pysigset.sigdelset(suspend_sigset, signal.SIGCHLD)
    pysigset.sigdelset(suspend_sigset, signal.SIGALRM)
    pysigset.sigdelset(suspend_sigset, signal.SIGUSR1)
    #  establish signals handlers
    signal.signal(signal.SIGCHLD, handler)
    signal.signal(signal.SIGALRM, handler)
    signal.signal(signal.SIGUSR1, handler)

    #  
    #  Start children.
    #  

    infomsg('parent starting %d children ...', CHILDREN)
    for i in range(0,CHILDREN):
        start_child_sleep(CHILD_RUN_TIME(i))

    # 
    #  Main monitoring loop
    # 

    infomsg('parent entering monitoring loop ...')
    while True:
        now = int(time.time())

        # 
        #  Exit if no running children.
        # 

        running_children_count = 0
        for i in range(0,MAX_CHILDREN):
            if  children[i]['pid'] != 0:
                running_children_count += 1
        if running_children_count == 0:
            break

        # 
        #  Kill any children that have reached their timeout time and not
        #  been killed already.
        # 

        killed_something = False
        for i in range(0,MAX_CHILDREN):
            if children[i]['pid'] != 0 and children[i]['start'] != 0 and \
                    now >= children[i]['start']+TIMEOUT:
                os.kill(children[i]['pid'], signal.SIGTERM)
                children[i]['start'] = 0
                killed_something = True

        # 
        #  Slight optimisation: if something did reach its timeout and got
        #  killed then skip to reassessing if this program can exit.
        # 

        if killed_something:
            continue

        # 
        #  Schedule timeout alarm of next-to-timeout child.
        # 

        next_timeout = 0
        for i in range(0,MAX_CHILDREN):
            if children[i]['pid'] != 0 and children[i]['start'] != 0:
                if next_timeout == 0:
                    next_timeout = children[i]['start']+TIMEOUT - now
                elif children[i]['start']+TIMEOUT - now < next_timeout:
                    next_timeout = children[i]['start']+TIMEOUT - now
        if next_timeout >= 1:
            signal.alarm(next_timeout)

        # 
        #  If there are dispatched-but-not-yet-delivered signals then
        #  handle them. If there are none then wait for one.
        # 

        if next_timeout >= 1:
             pysigset.sigsuspend(suspend_sigset)

        # 
        #  If SIGCHLD arrived before SIGALRM then the alarm is still
        #  pending. Cancel it.
        # 

        signal.alarm(0)

    #
    #  Clean up and exit.
    #

    infomsg('parent cleaning up and exiting ...')
    signal.signal(signal.SIGUSR1, signal.SIG_DFL)
    signal.signal(signal.SIGALRM, signal.SIG_DFL)
    signal.signal(signal.SIGCHLD, signal.SIG_DFL)
    pysigset.sigprocmask(signal.SIG_SETMASK, old_sigset, None)
    return 0

def start_child_sleep(period):
    global children

    # 
    #  Find an empty slot to store info about the process we're
    #  about launch.
    # 

    for i in range(0,MAX_CHILDREN):
        if children[i]['pid'] == 0:
            break
    if i == MAX_CHILDREN:
        errormsg('start_child_sleep: unable to find a free slot')

    # 
    #  Launch a child process and note its pid and start time
    #  in the empty slot.
    # 

    buf = 'sleep %d' % (period)
    try:
        pid = os.fork()
    except:
        errormsg('fork failed')
    if pid > 0:
        children[i]['pid'] = pid
        children[i]['start'] = int(time.time())
        return pid

    # 
    #  Only the child gets here
    # 

    os.execlp('/bin/sh', 'sh', '-c', buf)
    errormsg('exec() failed')

def handler(sig, frame):
    global children

    if sig == signal.SIGCHLD:
        while True:
            #  Seems like waitpid() can either raise an exception or return 0
            try:
                pid = os.waitpid(-1, os.WNOHANG)[0]
            except:
                break
            if pid <= 0:
                break
            for i in range(0,MAX_CHILDREN):
                if children[i]['pid'] == pid:
                    children[i]['pid'] = 0
                    children[i]['start'] = 0
                    break
    elif sig == signal.SIGALRM:
        infomsg('parent received SIGALRM')
    elif sig == signal.SIGUSR1:
        finfomsg(sys.stderr, 'parent received SIGUSR1')
        for i in range(0,MAX_CHILDREN):
            if children[i]['pid'] != 0:
                finfomsg(sys.stderr, 'slot:%04d; pid:%05d, start=%ld', 
                         i, children[i]['pid'], children[i]['start'])
    else:
        errormsg('parent received unexpected signal %s', sig)

def doubletime():
    now = time.time()

    if not hasattr(doubletime, "start"):
         doubletime.start = now

    return now-doubletime.start

def infomsg(fmt, *args):
    real_fmessage(inspect.stack()[1].function, sys.stdout, fmt, *args)

def errormsg(fmt, *args):

    real_fmessage(inspect.stack()[1].function, sys.stdout, fmt, *args)
    sys.exit(1)

def finfomsg(fp, fmt, *args):

    real_fmessage(inspect.stack()[1].function, fp, fmt, *args)

def ferrormsg(fp, fmt, *args):

    real_fmessage(inspect.stack()[1].function, fp, fmt, *args)
    sys.exit(1)

def real_fmessage(func, fp, fmt, *args):

    fp.write('%.06lf: %s: ' % (doubletime(), func))
    fp.write(fmt % args)
    fp.write('\n')

main()