rktimes.c

Go to the documentation of this file.

/*
 * rktimes.c
 *
 * Copyright (c) 2003 The University of Utah and the Flux Group.
 * All rights reserved.
 *
 * This file is licensed under the terms of the GNU Public License.  
 * See the file "license.terms" for restrictions on redistribution 
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 */

/**
 * @file rktimes.c
 *
 * Main file for a sampling time(1)-like command.  Unlike time(1) though, it
 * will not wait until the end of a run to report the CPU usage, it
 * continuously reports the usage in a form fit for consumption by gnuplot.
 * In addition, it can act as a server for a GKrellm client so the data can be
 * viewed instantaneously in a nice GUI.
 */

#include "config.h"

#include <errno.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <fcntl.h>

#include <sys/time.h>
#include <sys/types.h>
#include <sys/times.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <sys/resource.h>

#include <netinet/in.h>

#include <assert_pp.h>
#include <time_util.h>

#include "gkemu.h"
#include "childProcess.h"

#include <rk/rk.h>
#include <rk/rk_error.h>

#include "rk_util.h"

/**
 * Number of times per second to record CPU usage samples.
 */
#define SAMPLES_PER_SECOND 1

/**
 * Maximum number of gkrellm clients.
 */
#define MAX_CLIENTS 8

/**
 * Size of the buffer used to format gkrellm output.
 */
#define CLIENT_BUFFER_MAX 4096

#if !defined(__XSTRING)
/**
 * Convert a macro argument to a string.
 *
 * @param x The macro to expand to a string.
 */
#define __XSTRING(x) __STRING(x)
#endif

/**
 * A version of perror(3) that prints out the file and line number.
 *
 * @param x The prefix string for the error string.
 */
#define my_perror(x) perror(x ", file " __FILE__ ", line " __XSTRING(__LINE__))

enum {
    RKTB_DONE,
    RKTB_CREATED_RESOURCE_SET,
};

/*
 * Flags for the rktimes_data.rkt_Flags field.
 *
 * RKTF_DONE - Stop monitoring the resource set/child process.
 * RKTF_CREATED_RESOURCE_SET - rktimes created the resource set for the child.
 */
enum {
    RKTF_DONE = (1L << RKTB_DONE),
    RKTF_CREATED_RESOURCE_SET = (1L << RKTB_CREATED_RESOURCE_SET),
};

enum {
    RKTB_CLIENT_INITIALIZED,
};

/*
 * Flags for the rktimes_data.rkt_ClientFlags fields.
 *
 * RKTF_CLIENT_INITIALIZED - Indicates that the client has been sent an
 * "initial update".
 */
enum {
    RKTF_CLIENT_INITIALIZED = (1L << RKTB_CLIENT_INITIALIZED),
};

/*
 * Global data for the tool.
 *
 * rkt_Flags - Holds the RKTF_ flags.
 * rkt_UtilityName - The name of the utility that is being monitored.
 * rkt_StartTime - The starting time for the child process.
 * rkt_OutputBase - The base name for output files.
 * rkt_Name - The requested name of the resource set.
 * rkt_ChildPeriod - The child's CPU reservation period or zero if a reserve
 * should not be created.
 * rkt_ChildCompute - The child's CPU reservation compute time.
 * rkt_ResourceSet - The child's resource set.
 * rkt_ChildPID - The pid_t of the child process.  This will be set to -1 when
 *   the child dies.
 * rkt_ServerSocket - The server socket listening for gkrellm clients.
 * rkt_ClientBuffer - Work buffer for sending data to gkrellm clients.
 * rkt_ClientSockets - A list of socket descriptors that correspond to gkrellm
 *   clients listening for updates.  Elements set to -1 are empty.
 */
static struct {
    unsigned long rkt_Flags;
    const char *rkt_UtilityName;
    struct timeval rkt_StartTime;
    const char *rkt_OutputBase;
    const char *rkt_Name;
    unsigned int rkt_ChildPeriod;
    unsigned int rkt_ChildCompute;
    rk_resource_set_t rkt_ResourceSet;
    pid_t rkt_ChildPID;
    
    int rkt_ServerSocket;
    char rkt_ClientBuffer[CLIENT_BUFFER_MAX];
    int rkt_ClientSockets[MAX_CLIENTS];
    unsigned long rkt_ClientFlags[MAX_CLIENTS];
} rktimes_data;

/**
 * Write a byte array to a client's socket.  If they happen to fall behind or
 * some other error is encountered, the socket is closed immediately and erased
 * from the rktimes_data.rkt_ClientSockets array.
 *
 * @param index The client index in rktimes_data.rkt_ClientSockets.
 * @param buffer The buffer to write to the socket.
 * @param len The length of the buffer.
 */
static void rktClientWrite(unsigned int index, const char *buffer, size_t len)
{
    int fd;

    require(rktimes_data.rkt_ServerSocket != -1);
    require(index < MAX_CLIENTS);
    require(buffer != NULL);

    if( (fd = rktimes_data.rkt_ClientSockets[index]) >= 0 )
    {
        int rc;

        rc = write(fd, buffer, len);
        if( rc != len )
        {
            require((rc != -1) || (errno == EPIPE) || (errno == EWOULDBLOCK));

            /* No mercy! */
            close(fd);
            rktimes_data.rkt_ClientSockets[index] = -1;
            rktimes_data.rkt_ClientFlags[index] = 0;
        }
    }
}

/**
 * A signal handler that passes the received signal on to the child process.
 *
 * @param sig The actual signal number received.
 */
static void sigpass(int sig)
{
    require((sig == SIGINT) || (sig == SIGTERM));
    require(rktimes_data.rkt_ChildPID != 0);

    if( kill(rktimes_data.rkt_ChildPID, sig) == -1 )
    {
        my_perror("kill");
    }
}

/** Maximum number of processes to query in the resource set. */
#define MAX_PROC_LIST 128

/**
 * The SIGALRM signal handler.  This function will be called SAMPLES_PER_SECOND
 * times a second to read the CPU usage of the resource set's processes.  The
 * data is then output to a file and echoed to any gkrellm clients.
 *
 * @param sig The actual signal number received.
 *
 * @sa gkemu.h
 * @sa childProcess.h
 */
static void sigalrm(int sig)
{
    static unsigned long long total_compute, total_nice, total_deadline;
    static unsigned long long total_usage;
    static pid_t procs[MAX_PROC_LIST];

    unsigned long long inc_usage = 0, total_run, total_idle;
    struct cpu_reserve_attr cra;
    struct timeval curr, run;
    int lpc, len, count;
    rk_reserve_t cr;

    require(sig == SIGALRM);

    /* Get the current time and compute the process' total running time. */
    gettimeofday(&curr, NULL);
    timersub(&curr, &rktimes_data.rkt_StartTime, &run);
    total_run = (run.tv_sec * 1000000) + run.tv_usec;

    /* Get the list of processes in the resource set. */
    if( (count = rk_resource_set_get_proclist(rktimes_data.rkt_ResourceSet,
                                              procs,
                                              MAX_PROC_LIST)) == -1 )
    {
        my_perror("rk_resource_set_get_proclist");
        
        rktimes_data.rkt_Flags |= RKTF_DONE;
    }

    /* Walk through each process in the resource set and update its usage. */
    for( lpc = 0; lpc < count; lpc++ )
    {
        struct cpChildProcess *cp;
        
        if( (cp = cpFindChildProcess(procs[lpc])) == NULL )
        {
            /* The child is new, create an object for it. */
            if( (cp = cpCreateChildProcess(procs[lpc])) != NULL )
            {
                cpOpenOutput(cp,
                             rktimes_data.rkt_OutputBase,
                             &rktimes_data.rkt_StartTime);
            }
        }
        if( cp != NULL )
        {
            inc_usage += cpSampleUsage(cp, &run);
        }
    }

    /* Add the usage since the last time this handler was called. */
    total_usage += inc_usage;

    /* Get the current CPU reservation status. */
    if( (cr = rk_resource_set_get_cpu_rsv(rktimes_data.rkt_ResourceSet)) !=
        NULL_RESERVE)
    {
        if( rk_cpu_reserve_get_attr(cr, &cra) != RK_ERROR )
        {
            unsigned long long rsv_period, rsv_compute, rsv_nice, rsv_deadline;
            double multiplier;

            /* Turn the raw reservation data into a form fit for gkrellm. */
            rsv_period = (cra.period.tv_sec * 1000000) +
                (cra.period.tv_nsec / 1000);
            multiplier = (1000000.0 / rsv_period) /
                (double)SAMPLES_PER_SECOND;
            rsv_compute = ((cra.compute_time.tv_sec * 1000000) +
                           (cra.compute_time.tv_nsec / 1000)) * multiplier;
            if( inc_usage > rsv_compute )
            {
                rsv_nice = 0;
            }
            else
            {
                rsv_nice = rsv_compute - inc_usage;
                rsv_compute = inc_usage;
            }
            rsv_deadline = ((cra.deadline.tv_sec * 1000000) +
                            (cra.deadline.tv_nsec / 1000)) * multiplier;

            total_deadline += rsv_deadline - (rsv_compute + rsv_nice);
            total_compute += rsv_compute;
            total_nice += rsv_nice;
        }
        else
        {
            my_perror("rk_cpu_reserve_get_attr");
        }
    }
    
    total_idle = total_run - total_usage;

    /* Generate the new update text. */
    len = gkFormatUpdate(rktimes_data.rkt_ClientBuffer, CLIENT_BUFFER_MAX,
                         GKA_CPUUser, total_usage,
                         GKA_CPUIdle, total_idle,
                         GKA_CPUReserveUser, total_compute,
                         GKA_CPUReserveNice, total_nice,
                         GKA_CPUReserveIdle, total_deadline,
                         GKA_Processes, count,
                         GKA_ProcessesRunning, 0,
                         GKA_UpTime, &run,
                         GKA_TAG_DONE);

    /* Broadcast the update to the clients. */
    for( lpc = 0; lpc < MAX_CLIENTS; lpc++ )
    {
        if( rktimes_data.rkt_ClientSockets[lpc] != -1 )
        {
            if( !(rktimes_data.rkt_ClientFlags[lpc] &
                  RKTF_CLIENT_INITIALIZED) )
            {
                rktClientWrite(lpc,
                               gkInitialUpdateOpen,
                               strlen(gkInitialUpdateOpen));
            }
            rktClientWrite(lpc, rktimes_data.rkt_ClientBuffer, len);
            if( !(rktimes_data.rkt_ClientFlags[lpc] &
                  RKTF_CLIENT_INITIALIZED) )
            {
                rktClientWrite(lpc,
                               gkInitialUpdateClose,
                               strlen(gkInitialUpdateClose));
                rktimes_data.rkt_ClientFlags[lpc] |= RKTF_CLIENT_INITIALIZED;
            }
        }
    }
}

/**
 * Handle a SIGCHLD signal.  This function will be called when the child exits.
 *
 * @param sig The actual signal number received.
 */
static void sigchld(int sig)
{
    require(sig == SIGCHLD);
    require(rktimes_data.rkt_ChildPID != 0);
    
    rktimes_data.rkt_Flags |= RKTF_DONE;
}

/**
 * Handle a SIGINT/SIGTERM signal when no utility is being monitored.
 *
 * @param sig The actual signal number received.
 */
static void sigexit(int sig)
{
    require((sig == SIGINT) || (sig == SIGTERM));
    
    rktimes_data.rkt_Flags |= RKTF_DONE;
}

/**
 * Handle a SIGIO signal.  This function will be called when the server socket
 * has a new connection waiting to be accept(2)'d.
 *
 * @param sig The actual signal number received.
 */
static void sigio(int sig)
{
    struct sockaddr saddr;
    socklen_t saddrlen;
    int fd;

    require(sig == SIGIO);
    require(rktimes_data.rkt_ServerSocket != -1);

    saddrlen = sizeof(saddr);
    /* Try to accept all of the clients waiting on the socket. */
    while( (fd = accept(rktimes_data.rkt_ServerSocket,
                        &saddr,
                        &saddrlen)) >= 0 )
    {
        int fl, lpc;

        /*
         * Set the client socket to be non-blocking, so we do not want to get
         * stuck waiting for someone.
         */
        fl = fcntl(fd, F_GETFL, 0);
        fcntl(fd, F_SETFL, fl | O_NONBLOCK);
        /* Search for an empty element in the list of client sockets. */
        for( lpc = 0;
             (lpc < MAX_CLIENTS) &&
                 (rktimes_data.rkt_ClientSockets[lpc] != -1);
             lpc++ );
        if( lpc < MAX_CLIENTS )
        {
            int len;

            rktimes_data.rkt_ClientSockets[lpc] = fd;

            /* Send the preamble. */
            len = gkFormatPreamble(
                rktimes_data.rkt_ClientBuffer,
                CLIENT_BUFFER_MAX,
                GKA_HostName, rktimes_data.rkt_Name,
                GKA_SystemName, rktimes_data.rkt_UtilityName,
                GKA_TAG_DONE);
            rktClientWrite(lpc, rktimes_data.rkt_ClientBuffer, len);
        }
        else
        {
            /* Too many clients... */
            close(fd);
        }
    }
}

/**
 * Create a resource set and CPU reserve for ourself.  Otherwise, we might not
 * get CPU time to do the recording.
 *
 * @param name The name for the resource set.
 * @return A resource set for this process.
 */
static rk_resource_set_t rktCreateSelfResourceSet(char *name)
{
    rk_resource_set_t rs, retval = NULL_RESOURCE_SET;

    require(name != NULL);
    require(strlen(name) > 0);
    require(strlen(name) < RK_NAME_LEN);
    
    if( (rs = rk_resource_set_create(name)) != NULL_RESOURCE_SET )
    {
        struct cpu_reserve_attr cra;
        rk_reserve_t cr;
        
        memset(&cra, 0, sizeof(cra));
        /* XXX Come up with some better numbers for the reserve. */
        cra.compute_time.tv_sec = 0;
        cra.compute_time.tv_nsec = 5000000;
        cra.period.tv_sec = 0;
        cra.period.tv_nsec = 1000000000;
        cra.deadline = cra.period;
        cra.blocking_time = cra.start_time = (struct timespec){ 0, 0 };
        cra.reserve_type.sch_mode = RSV_SOFT;
        cra.reserve_type.enf_mode = RSV_SOFT;
        cra.reserve_type.rep_mode = RSV_SOFT;
        cra.processor = RK_ANY_CPU;
        if( rk_cpu_reserve_create(rs, &cr, &cra) != RK_ERROR )
        {
            /*
             * Note that we do not attach the process here since any children
             * we fork(2) off would inherit the resource set.
             */
            retval = rs;
        }
        else
        {
            my_perror("rk_cpu_reserve_create");
            rk_resource_set_destroy(rs);
        }
    }
    else
    {
        my_perror("rk_resource_set_create");
    }
    return( retval );
}

/**
 * Get a resource set for the child process.  If a resource set already exists
 * with the requested name, that will be used.  Otherwise, a new one will be
 * created.  If no name is requested, a new set will be created with the
 * default name.
 *
 * @param rs An existing resource set that should be used.
 * @param requested_name The requested resource set name or NULL if the default
 * should be used.
 * @param default_name The default resource set name to use if requested_name
 * is NULL.
 * @param child_period The child's period in microseconds or zero if no CPU
 * reserve should be created.
 * @param child_compute The child's compute time in microseconds.
 * @return The resource set to use for the child process or NULL_RESOURCE_SET
 * if a set could not be created.
 */
static rk_resource_set_t rktGetChildResourceSet(rk_resource_set_t rs,
                                                const char *requested_name,
                                                const char *default_name,
                                                unsigned int child_period,
                                                unsigned int child_compute)
{
    rk_resource_set_t retval = rs;
    
    require((requested_name == NULL) ||
            ((strlen(requested_name) > 0) &&
             (strlen(requested_name) <= RK_NAME_LEN)));
    require(default_name != NULL);
    require(strlen(default_name) > 0);
    require(strlen(default_name) <= RK_NAME_LEN);
    require(((child_period == 0) && (child_compute == 0)) ||
            (child_compute < child_period));
    
    /* If no resource set was passed in, try to create one. */
    if( retval == NULL_RESOURCE_SET )
    {
        const char *actual_name;
        
        if( requested_name != NULL )
        {
            actual_name = requested_name;
        }
        else
        {
            actual_name = default_name;
        }
        if( (retval = rk_resource_set_create((char *)actual_name)) !=
            NULL_RESOURCE_SET )
        {
            rktimes_data.rkt_Flags |= RKTF_CREATED_RESOURCE_SET;
        }
        else
        {
            my_perror("rk_resource_set_create");
        }
    }
    /* Attach the CPU reserve or try to repair a suspicious resource set. */
    if( retval != NULL_RESOURCE_SET )
    {
        rk_reserve_t cr = NULL_RESERVE;
        
        if( (cr = rk_resource_set_get_cpu_rsv(retval)) != NULL_RESERVE )
        {
            /*
             * Hmm, they already have a reserve, make sure there are some
             * processes attached.
             */
            if( rk_resource_set_get_num_procs(retval) > 0 )
            {
                /* Okie, seems fine. */
            }
            else
            {
                /* Suspicious, delete the reserve and make room for our own. */
                if( rk_cpu_reserve_delete(retval) == 0 )
                {
                    cr = NULL_RESERVE;
                    /* Assume control of the resource set. */
                    rktimes_data.rkt_Flags |= RKTF_CREATED_RESOURCE_SET;
                }
                else
                {
                    my_perror("rk_cpu_reserve_delete");
                }
            }
        }
        
        if( (cr == NULL_RESERVE) && (child_period > 0) )
        {
            struct cpu_reserve_attr cra;
            
            cra.compute_time.tv_sec = 0;
            cra.compute_time.tv_nsec = child_compute * 1000;
            cra.period.tv_sec = 0;
            cra.period.tv_nsec = child_period * 1000;
            cra.deadline = cra.period;
            cra.blocking_time = cra.start_time = (struct timespec){ 0, 0 };
            cra.reserve_type.sch_mode = RSV_SOFT;
            cra.reserve_type.enf_mode = RSV_SOFT;
            cra.reserve_type.rep_mode = RSV_SOFT;
            cra.processor = RK_ANY_CPU;
            if( rk_cpu_reserve_create(retval, &cr, &cra) < 0 )
            {
                my_perror("rk_cpu_reserve_create");
            }
        }
    }
    return( retval );
}

/**
 * Print out the usage statement to a file handle.
 *
 * @param file The destination file handle for the usage output.
 * @param prog_name The program name.
 */
static void rktUsage(FILE *file, char *prog_name)
{
    require(file != NULL);
    require(prog_name != NULL);
    require(strlen(prog_name) > 0);
    
    fprintf(file,
            "Usage: %s [options] -- <command> [argument ...]\n",
            prog_name);
    fprintf(file,
            "\n"
            "Create a resource set and periodically record the CPU\n"
            "usage of the attached process and its children.\n"
            "\n"
            "Options:\n"
            "\t-h\t\tThis help message.\n"
            "\t-V\t\tShow the version number.\n"
            
            "\t-o <file>\tBase name for the output files. (Default: rktimes)\n"
            
            "\t-n <name>\tName of the RK resource set.  If a resource set\n"
            "\t\t\twith that name already exists, that will be used.\n"
            "\t\t\tOtherwise, a new one with that name will be created.\n"
            "\t\t\t(Default: rktimes)\n"
            
            "\t-p <port>\tServer port for GKrellmd emulation.\n"

            "\t-P <time>\tThe period for the CPU reservation.\n"
            "\t\t\tThe -C option must also be given.\n"

            "\t-C <time>\tThe compute time for the CPU reservation.\n"
            "\t\t\tThe -P option must also be given.\n"

            "\n"
            
            "Package: " PACKAGE_STRING "\n"
            "Contact: " PACKAGE_BUGREPORT "\n");
}

/**
 * Process the command line options.
 *
 * @param argc_inout Pointer to main's argc variable.  On return, the variable
 * will contain the number of arguments remaining after option processing.
 * @param argv_inout Pointer to main's argv variable.  On return, the variable
 * will contain the remaining argument values.
 * @return Zero if the options were processed correctly, > 0 if there was an
 * error and the usage should be printed, or < 0 if the program should exit
 * immediately.
 */
static int rktProcessOptions(int *argc_inout, char **argv_inout[])
{
    unsigned long long us_time;
    int ch, retval = 0;
    char *prog_name;
    char **argv;
    int argc;

    require(argc_inout != NULL);
    require(argv_inout != NULL);

    argc = *argc_inout;
    argv = *argv_inout;
    prog_name = argv[0];
    while( ((ch = getopt(argc, argv, "hVo:n:p:P:C:")) != -1) && (retval == 0) )
    {
        switch( ch )
        {
        case 'o':
            /* Output file base name. */
            if( strlen(optarg) == 0 )
            {
                fprintf(stderr,
                        "%s: -o value is empty\n",
                        prog_name);
            }
            else
            {
                rktimes_data.rkt_OutputBase = optarg;
            }
            break;
        case 'n':
            /* Resource set name. */
            if( strlen(optarg) == 0 )
            {
                fprintf(stderr,
                        "%s: -n value is empty\n",
                        prog_name);
            }
            else if( strlen(optarg) > RK_NAME_LEN )
            {
                fprintf(stderr,
                        "%s: -n value too long (only %d characters allowed)\n",
                        prog_name,
                        RK_NAME_LEN);
                retval = 1;
            }
            else
            {
                rktimes_data.rkt_Name = optarg;
            }
            break;
        case 'P':
            /* Period for the CPU reservation. */
            if( string_to_microsec(&us_time, optarg) )
            {
                rktimes_data.rkt_ChildPeriod = us_time;
            }
            else
            {
                fprintf(stderr,
                        "%s: -P option requires a time value\n",
                        prog_name);
            }
            break;
        case 'C':
            /* Compute time for the CPU reservation. */
            if( string_to_microsec(&us_time, optarg) )
            {
                rktimes_data.rkt_ChildCompute = us_time;
            }
            else
            {
                fprintf(stderr,
                        "%s: -C option requires a time value\n",
                        prog_name);
            }
            break;
        case 'p':
            /* Server port number for GKrellm emulation. */
            {
                int port;
                
                if( (sscanf(optarg, "%d", &port) == 1) &&
                    (port > 0) && (port < 65536) )
                {
                    int fd;
                    
                    if( (fd = socket(PF_INET, SOCK_STREAM, 0)) >= 0 )
                    {
                        struct sockaddr_in sin;
                        int on = 1;
                        
                        (void)setsockopt(fd,
                                         SOL_SOCKET,
                                         SO_REUSEADDR,
                                         (char *)&on,
                                         sizeof(on));
#if defined(BSD44)
                        sin.sin_len = sizeof(sin);
#endif
                        sin.sin_family = AF_INET;
                        sin.sin_port = htons(port);
                        sin.sin_addr.s_addr = INADDR_ANY;
                        if( bind(fd,
                                 (struct sockaddr *)&sin,
                                 sizeof(sin)) == 0 )
                        {
                            if( listen(fd, 5) == 0 )
                            {
                                int fl;

                                fl = fcntl(fd, F_GETFL, 0);
                                fl |= O_NONBLOCK |
#if defined(O_ASYNC)
                                    O_ASYNC
#elif defined(FASYNC)
                                    FASYNC
#endif
                                    ;
                                fcntl(fd, F_SETFL, fl);
                                fcntl(fd, F_SETOWN, getpid());
                                /*
                                 * Note: SIGIO is ignored by default, so we
                                 * do not have to worry about handling it yet.
                                 */
                            }
                            else
                            {
                                my_perror("listen");
                                retval = -1;
                            }
                        }
                        else
                        {
                            my_perror("bind");
                            retval = -1;
                        }
                    }
                    else
                    {
                        my_perror("socket");
                        retval = -1;
                    }
                    if( retval == 0 )
                    {
                        rktimes_data.rkt_ServerSocket = fd;
                    }
                    else
                    {
                        close(fd);
                    }
                }
                else
                {
                    fprintf(stderr,
                            "%s: Invalid -p value: %s\n",
                            prog_name,
                            optarg);
                    retval = 1;
                }
            }
            break;
        case 'V':
            fprintf(stderr, "%s\n", PACKAGE_VERSION);
            retval = -1;
            break;
        case 'h':
        case '?':
        default:
            retval = 1;
            break;
        }
    }
    if( (rktimes_data.rkt_ChildCompute == 0) &&
        (rktimes_data.rkt_ChildPeriod == 0) )
    {
    }
    else if( rktimes_data.rkt_ChildCompute == 0 )
    {
        fprintf(stderr,
                "%s: Compute time _must_ be specified with period\n",
                prog_name);
        retval = 1;
    }
    else if( rktimes_data.rkt_ChildPeriod == 0 )
    {
        fprintf(stderr,
                "%s: Period time _must_ be specified with compute time\n",
                prog_name);
        retval = 1;
    }
    else if( rktimes_data.rkt_ChildCompute >= rktimes_data.rkt_ChildPeriod )
    {
        fprintf(stderr,
                "%s: Compute time _must_ be less than period\n",
                prog_name);
        retval = 1;
    }
    *argc_inout -= optind;
    *argv_inout += optind;
    /* Optionally skip the '--' that is used to terminate the option list. */
    if( (*argc_inout > 0) && (strcmp(*argv_inout[0], "--") == 0) )
    {
        *argc_inout -= 1;
        *argv_inout += 1;
    }
    if( (retval == 0) && (*argc_inout == 0) )
    {
        /* No arguments were given, make sure there is a name and */
        if( rktimes_data.rkt_Name == NULL )
        {
            fprintf(stderr, "%s: Missing utility to monitor\n", prog_name);
            retval = 1;
        }
        /* ... it is a valid resource set. */
        else if( (rktimes_data.rkt_ResourceSet =
                  rk_resource_set_get_by_name(rktimes_data.rkt_Name)) ==
                 NULL_RESOURCE_SET )
        {
            fprintf(stderr,
                    "%s: No such resource set: %s\n",
                    prog_name,
                    rktimes_data.rkt_Name);
            retval = 1;
        }
    }
    return( retval );
}

/**
 * The parent portion of the fork(2) between rktimes and the monitored utility.
 * This function will attach itself to a resource set to ensure that it has
 * some CPU time to work and then wait for gkrellm connections or the child's
 * death.
 *
 * @param rs The resource set for the rktimes process.
 * @return The return code for main().
 *
 * @sa rktChildPart
 */
static int rktParentPart(rk_resource_set_t rs)
{
    int retval = EXIT_FAILURE;
    struct itimerval itv;
    struct sigaction sa;
    sigset_t sigmask;

    require(rs != NULL_RESOURCE_SET);
    
    /* Attach ourselves here to avoid inheritance problem. */
    if( rk_resource_set_attach_process(rs, getpid()) < 0 )
    {
        my_perror("rk_resource_set_attach_process");
    }

    /*
     * We use signals as a primitive event system.  So any that we use, and are
     * not passed on to the child, need to be blocked before setting up the
     * handlers.  Once everything has been setup, we will use sigsuspend(2) to
     * atomically unblock and wait for the signals to arrive.
     */
    sigemptyset(&sigmask);
    sigaddset(&sigmask, SIGALRM);
    sigaddset(&sigmask, SIGCHLD);
    sigaddset(&sigmask, SIGIO);
    sigaddset(&sigmask, SIGINT);
    sigaddset(&sigmask, SIGTERM);
    if( sigprocmask(SIG_BLOCK, &sigmask, NULL) < 0 )
    {
        my_perror("sigprocmask");
        
        ensure(0);
    }

    /* Setup the signal handlers. */
    sa.sa_mask = sigmask;
    sa.sa_flags = 0;
#if defined(SA_RESTART)
    sa.sa_flags |= SA_RESTART;
#endif

    signal(SIGPIPE, SIG_IGN);

    sa.sa_handler = sigalrm;
    sigaction(SIGALRM, &sa, NULL);

    if( rktimes_data.rkt_ServerSocket != -1 )
    {
        sa.sa_handler = sigio;
        sigaction(SIGIO, &sa, NULL);
    }
    
    if( rktimes_data.rkt_ChildPID == 0 )
    {
        /*
         * No utility is being monitored, just a resource set.  Therefore we
         * need to exit when these signals are received since there is no
         * child to pass them to.
         */
        sa.sa_handler = sigexit;
        sigaction(SIGINT, &sa, NULL);
        sigaction(SIGTERM, &sa, NULL);
    }
    else
    {
        /* Catch SIGCHLD so we exit with the child. */
        sa.sa_handler = sigchld;
        sigaction(SIGCHLD, &sa, NULL);

        /*
         * Pass SIGINT/SIGTERM onto the child so they can handle them as they
         * choose.  If they exit, we will get the SIGCHLD and exit shortly
         * thereafter.
         */
        sa.sa_handler = sigpass;
        sigaction(SIGINT, &sa, NULL);
        sigaction(SIGTERM, &sa, NULL);
    }
    
    itv.it_interval.tv_sec = 0;
    itv.it_interval.tv_usec = 1000000 / SAMPLES_PER_SECOND;
    itv.it_value.tv_sec = 0;
    itv.it_value.tv_usec = 1000000 / SAMPLES_PER_SECOND;
    /* XXX Use rk periodic stuff here. */
    if( setitimer(ITIMER_REAL, &itv, NULL) == 0 )
    {
        sigset_t empty_sigmask;
        int status;

        sigemptyset(&empty_sigmask);
        
        /* Keep handling signals until the child has died. */
        while( !(rktimes_data.rkt_Flags & RKTF_DONE) )
        {
            sigsuspend(&empty_sigmask);
        }

        /* Cleanup the child's status. */
        if( rktimes_data.rkt_ChildPID == 0 )
        {
            /*
             * No child was being monitored, ergo, there is nothing to wait for
             */
        }
        else if( wait(&status) >= 0 )
        {
            if( WIFEXITED(status) )
            {
                retval = WEXITSTATUS(status);
            }
            else if( WIFSIGNALED(status) )
            {
                retval = EXIT_SUCCESS;
            }
            else
            {
                retval = EXIT_FAILURE;
            }
        }
        else
        {
            my_perror("wait");
            retval = EXIT_FAILURE;
        }

        /* Clear the timer. */
        memset(&itv, 0, sizeof(itv));
        if( setitimer(ITIMER_REAL, &itv, NULL) < 0 )
        {
            my_perror("setitimer");

            ensure(0);
        }
    }
    else
    {
        my_perror("setitimer");
        retval = EXIT_FAILURE;
    }

    /* We will be dying soon, ignore any signals and */
    signal(SIGALRM, SIG_IGN);
    signal(SIGCHLD, SIG_IGN);
    signal(SIGINT, SIG_IGN);
    signal(SIGTERM, SIG_IGN);
    signal(SIGIO, SIG_IGN);

    /* ... restore the old signal mask. */
    if( sigprocmask(SIG_UNBLOCK, &sigmask, NULL) < 0 )
    {
        my_perror("sigprocmask");

        ensure(0);
    }
    
    return( retval );
}

/**
 * The child portion of the fork(2) between rktimes and the monitored utility.
 * This function will attach the child to the given resource set and execvp(3)
 * the utility to monitor with the given arguments.
 *
 * @param rs The child's resource set.
 * @param argv The utility to startup and its arguments.
 * @return A failure exit code, otherwise this function will not return because
 * of the execvp(3).
 *
 * @sa rktParentPart
 */
static int rktChildPart(rk_resource_set_t rs, char *argv[])
{
    int retval = EXIT_SUCCESS;
    sigset_t sigmask;

    require(rs != NULL_RESOURCE_SET);
    require(argv != NULL);
    
    /*
     * Make sure any children created by the monitored utility are also
     * attached to the resource set.
     */
    rk_inherit_mode(1);
    if( rk_resource_set_attach_process(rs, getpid()) == 0 )
    {
    }
    else
    {
        my_perror("rk_resource_set_attach_process");
        retval = EXIT_FAILURE;
    }

    /* Reset the signal mask for the child. */
    sigfillset(&sigmask);
    if( sigprocmask(SIG_UNBLOCK, &sigmask, NULL) < 0 )
    {
        my_perror("sigprocmask");
        
        ensure(0);
    }

    if( retval == EXIT_SUCCESS )
    {
        execvp(argv[0], argv);

        /* FALLTHROUGH, normal operation will not reach this point. */
        perror(argv[0]);
        switch( errno )
        {
        case ENOENT:
        case EPERM:
            retval = 127;
            break;
        default:
            retval = EXIT_FAILURE;
            break;
        }
    }
    return( retval );
}

int main(int argc, char *argv[])
{
    int lpc, retval = EXIT_FAILURE;

    /* Default values. */
    rktimes_data.rkt_OutputBase = "rktimes";
    rktimes_data.rkt_ServerSocket = -1;
    for( lpc = 0; lpc < MAX_CLIENTS; lpc++ )
    {
        rktimes_data.rkt_ClientSockets[lpc] = -1;
    }

    /* Initialize the internal bits first. */
    if( cpInitChildProcessData() )
    {
        char *prog_name = argv[0];
        int rc;

        rc = rktProcessOptions(&argc, &argv);
        if( (rc == 0) && ((argc > 0) || (rktimes_data.rkt_Name != NULL)) )
        {
            char self_rs_name[RK_NAME_LEN + 1];
            rk_resource_set_t rs;

            if( argc > 0 )
            {
                rktimes_data.rkt_UtilityName = argv[0];
            }
            else
            {
                rktimes_data.rkt_UtilityName = "<none>";
            }
            snprintf(self_rs_name, RK_NAME_LEN + 1, "rktimes.%d", getpid());

            /*
             * Block signals so we do not die without cleaning up the resource
             * set(s).
             */
            {
                sigset_t sigmask;
                
                sigaddset(&sigmask, SIGINT);
                sigaddset(&sigmask, SIGTERM);
                if( sigprocmask(SIG_BLOCK, &sigmask, NULL) < 0 )
                {
                    my_perror("sigprocmask");
                    
                    ensure(0);
                }
            }
            
            rs = rktCreateSelfResourceSet(self_rs_name);
            rktimes_data.rkt_ResourceSet =
                rktGetChildResourceSet(rktimes_data.rkt_ResourceSet,
                                       rktimes_data.rkt_Name,
                                       "rktimes",
                                       rktimes_data.rkt_ChildPeriod,
                                       rktimes_data.rkt_ChildCompute);
            if( (rs != NULL_RESOURCE_SET) &&
                (rktimes_data.rkt_ResourceSet != NULL_RESOURCE_SET) )
            {
                gettimeofday(&rktimes_data.rkt_StartTime, NULL);
                if( argc == 0 )
                {
                    retval = rktParentPart(rs);
                }
                else if( (rktimes_data.rkt_ChildPID = fork()) > 0 )
                {
                    retval = rktParentPart(rs);
                }
                else if( rktimes_data.rkt_ChildPID == 0 )
                {
                    return( rktChildPart(rktimes_data.rkt_ResourceSet, argv) );
                }
                else
                {
                    my_perror("fork");
                    retval = EXIT_FAILURE;
                }
            }
            if( rktimes_data.rkt_Flags & RKTF_CREATED_RESOURCE_SET )
            {
                rk_resource_set_destroy(rktimes_data.rkt_ResourceSet);
                rktimes_data.rkt_ResourceSet = NULL_RESOURCE_SET;
            }
            rk_resource_set_destroy(rs);
        }
        else if( rc >= 0 )
        {
            rktUsage(stderr, prog_name);
        }
        if( rktimes_data.rkt_ServerSocket != -1 )
        {
            close(rktimes_data.rkt_ServerSocket);
            rktimes_data.rkt_ServerSocket = -1;
        }
        cpKillChildProcessData();
    }
    
    return( retval );
}

---