childProcess.c

Go to the documentation of this file.

/*
 * childProcess.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 childProcess.c
 *
 * Implementation file for the child process accounting functions.
 */

#include "config.h"

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include <assert_pp.h>

#include <sys/time.h>

#include "childProcess.h"

/**
 * The file name format for the process' statistics in '/proc'.
 */
#if defined(linux)
static char *PROC_STAT_FORMAT = "/proc/%d/stat";
#elif defined(__FreeBSD__)
static char *PROC_STAT_FORMAT = "/proc/%d/status";
#endif

/**
 * Global data for child processes.
 */
static struct cpChildProcessData child_process_data;

int cpInitChildProcessData(void)
{
    int retval = 1;

    require(!(child_process_data.cpd_Flags & CPDF_INITIALIZED));

    lnNewList(&child_process_data.cpd_Children);
    child_process_data.cpd_Flags |= CPDF_INITIALIZED;
    return( retval );
}

void cpKillChildProcessData(void)
{
    if( child_process_data.cpd_Flags & CPDF_INITIALIZED )
    {
        struct cpChildProcess *cp;
        
        while( (cp = (struct cpChildProcess *)
                lnRemHead(&child_process_data.cpd_Children)) != NULL )
        {
            cp->cp_Link.ln_Succ = NULL;
            cpDeleteChildProcess(cp);
        }
        child_process_data.cpd_Flags &= ~CPDF_INITIALIZED;
    }
}

struct cpChildProcess *cpFindChildProcess(pid_t child_pid)
{
    struct cpChildProcess *curr, *retval = NULL;

    require(child_process_data.cpd_Flags & CPDF_INITIALIZED);
    require(child_pid >= 0);

    curr = (struct cpChildProcess *)child_process_data.cpd_Children.lh_Head;
    while( (curr->cp_Link.ln_Succ != NULL) && (retval == NULL) )
    {
        if( curr->cp_PID == child_pid )
        {
            retval = curr;
        }
        curr = (struct cpChildProcess *)curr->cp_Link.ln_Succ;
    }
    return( retval );
}

struct cpChildProcess *cpCreateChildProcess(pid_t child_pid)
{
    struct cpChildProcess *retval;

    require(child_process_data.cpd_Flags & CPDF_INITIALIZED);
    require(child_pid >= 0);
    require(cpFindChildProcess(child_pid) == NULL);

    /* Allocate the structure and the /proc file name in one chunk. */
    if( (retval = calloc(1,
                         sizeof(struct cpChildProcess) +
                         strlen(PROC_STAT_FORMAT) +
                         16 + /* extra space for the PID */
                         1)) != NULL )
    {
        retval->cp_PID = child_pid;
        snprintf((char *)(retval + 1),
                 strlen(PROC_STAT_FORMAT) + 16 + 1,
                 PROC_STAT_FORMAT,
                 child_pid);
        retval->cp_ProcFileName = (const char *)(retval + 1);

        lnAddTail(&child_process_data.cpd_Children, &retval->cp_Link);

        ensure(cpFindChildProcess(child_pid) == retval);
    }
    return( retval );
}

void cpDeleteChildProcess(struct cpChildProcess *cp)
{
    require(child_process_data.cpd_Flags & CPDF_INITIALIZED);
    
    if( cp != NULL )
    {
        {
            if( cp->cp_Link.ln_Succ != NULL )
            {
                lnRemove(&cp->cp_Link);
            }
            if( cp->cp_Output != NULL )
            {
                fclose(cp->cp_Output);
                cp->cp_Output = NULL;
            }

            ensure(cpFindChildProcess(cp->cp_PID) == NULL);
        }
        free(cp);
    }
}

int cpOpenOutput(struct cpChildProcess *cp,
                 const char *base_name,
                 struct timeval *start_time)
{
    static char filename[1024];
    
    int retval = 0;

    require(child_process_data.cpd_Flags & CPDF_INITIALIZED);
    require(cp != NULL);
    require(cpFindChildProcess(cp->cp_PID) != NULL);
    require(base_name != NULL);
    require(strlen(base_name) > 0);
    require(start_time != NULL);
    require(start_time->tv_sec > 0);
    require(start_time->tv_usec > 0);
    
    snprintf(filename, sizeof(filename), "%s-%d.out", base_name, cp->cp_PID);
    if( (cp->cp_Output = fopen(filename, "w")) != NULL )
    {
        fprintf(cp->cp_Output,
                "# start: %ld.%06ld\n",
                start_time->tv_sec,
                start_time->tv_usec);
        fprintf(cp->cp_Output, "0 0\n");
        retval = 1;
    }
    return( retval );
}

#if defined(linux)
static unsigned long long cpSampleUsageInternal(struct cpChildProcess *cp)
{
    static char unused_string[1024];
    
    unsigned long long retval = 0;
    FILE *file;

    require(child_process_data.cpd_Flags & CPDF_INITIALIZED);
    require(cp != NULL);

    /* XXX Do we have to open this everytime?  Or can we just rewind()? */
    if( (file = fopen(cp->cp_ProcFileName, "r")) != NULL )
    {
        struct timeval utime, stime, accum, usage;
        unsigned long unused_ulong;
        long unused_long;
        char unused_char;
        int unused_int;

        memset(&utime, 0, sizeof(utime));
        memset(&stime, 0, sizeof(stime));
        fscanf(file,
               "%d %s %c %d %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %ld %ld %ld %ld %ld %ld %lu %lu %ld %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %d %d %ld %ld %ld %ld",
               &unused_int,
               unused_string,
               &unused_char,
               &unused_int,
               &unused_int,
               &unused_int,
               &unused_int,
               &unused_int,
               &unused_ulong,
               &unused_ulong,
               &unused_ulong,
               &unused_ulong,
               &unused_ulong,
               &unused_ulong,
               &unused_ulong,
               &unused_long,
               &unused_long,
               &unused_long,
               &unused_long,
               &unused_long,
               &unused_long,
               &unused_ulong,
               &unused_ulong,
               &unused_long,
               &unused_ulong,
               &unused_ulong,
               &unused_ulong,
               &unused_ulong,
               &unused_ulong,
               &unused_ulong,
               &unused_ulong,
               &unused_ulong,
               &unused_ulong,
               &unused_ulong,
               &unused_ulong,
               &unused_ulong,
               &unused_ulong,
               &unused_int,
               &unused_int,
               &utime.tv_sec,
               &utime.tv_usec,
               &stime.tv_sec,
               &stime.tv_usec);
        timeradd(&utime, &stime, &accum);
        timersub(&accum, &cp->cp_LastUsage, &usage);
        cp->cp_LastUsage = accum;
        fprintf(cp->cp_Output,
                "%ld.%06ld",
                usage.tv_sec,
                usage.tv_usec);
        retval += (usage.tv_sec * 1000000) + usage.tv_usec;
        fclose(file);
    }
    else
    {
        /* Cannot open the file, but we still need to output some usage. */
        fprintf(cp->cp_Output, "0.0");
    }
    return( retval );
}
#endif

#if defined(__FreeBSD__)
static unsigned long long cpSampleUsageInternal(struct cpChildProcess *cp)
{
    static char unused_string[1024];
    
    int retval = 0;
    FILE *file;
    
    require(cp != NULL);
    
    if( (file = fopen(cp->cp_ProcFileName, "r")) != NULL )
    {
        struct timeval utime, stime, accum, usage;
        int unused_int;
        
        memset(&utime, 0, sizeof(struct timeval));
        memset(&stime, 0, sizeof(struct timeval));
        memset(&accum, 0, sizeof(struct timeval));
        fscanf(file,
               "%s %d %d %d %d %d,%d %s %d,%d %ld,%ld %ld,%ld",
               unused_string,
               &unused_int,
               &unused_int,
               &unused_int,
               &unused_int,
               &unused_int,
               &unused_int,
               unused_string,
               &unused_int,
               &unused_int,
               &utime.tv_sec,
               &utime.tv_usec,
               &stime.tv_sec,
               &stime.tv_usec);
        timeradd(&utime, &stime, &accum);
        timersub(&accum, &cp->cp_LastUsage, &usage);
        cp->cp_LastUsage = accum;
        fprintf(cp->cp_Output,
                "%ld.%06ld",
                usage.tv_sec, usage.tv_usec);
        fclose(file);
    }
    return( retval );
}
#endif

unsigned long long cpSampleUsage(struct cpChildProcess *cp,
                                 struct timeval *run_time)
{
    unsigned long long retval = 0;

    require(child_process_data.cpd_Flags & CPDF_INITIALIZED);
    require(cp != NULL);
    require(cpFindChildProcess(cp->cp_PID) != NULL);
    require(run_time != NULL);
    pp_block({
        static struct timeval last_run_time;

        require(timercmp(&last_run_time, run_time, <=));
        last_run_time = *run_time;
    });

    if( cp->cp_Output != NULL )
    {
        fprintf(cp->cp_Output,
                "%ld.%06ld ",
                run_time->tv_sec,
                run_time->tv_usec);
        retval += cpSampleUsageInternal(cp);
        fprintf(cp->cp_Output, "\n");
    }
    return( retval );
}

---