gkemu.c

Go to the documentation of this file.

/*
 * gkemu.c
 *
 * Copyright (c) 2003, 2004 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 gkemu.c
 *
 * Implementation of the functions in gkemu.h.
 */

#include "config.h"

#include <time.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>

#include <sys/time.h>

#include <assert_pp.h>

#include "gkemu.h"

const char *gkInitialUpdateOpen = "<initial_update>\n";
const char *gkInitialUpdateClose = "</initial_update>\n";

int gkFormatPreamble(char *buf, size_t buf_len, gka_tag_t tag, ...)
{
    struct {
        char *hostnametag, *hostname;
        char *sysnametag, *sysname;
    } preamble_args = {
        "", "",
        "", "",
    };

    time_t current_time;
    struct tm *tm;
    va_list args;
    int retval;

    require(buf != NULL);
    require(buf_len > 0);

    /* Gather the arguments from the tag list. */
    va_start(args, tag);
    while( tag != GKA_TAG_DONE )
    {
        switch( tag )
        {
        case GKA_HostName:
            preamble_args.hostname = va_arg(args, char *);
            if( preamble_args.hostname != NULL )
                preamble_args.hostnametag = "<hostname>\n";
            break;
        case GKA_SystemName:
            preamble_args.sysname = va_arg(args, char *);
            if( preamble_args.sysname != NULL )
                preamble_args.sysnametag = "<sysname>\n";
            break;
        default:
            ensure(0);
            break;
        }
        tag = va_arg(args, gka_tag_t);
    }
    va_end(args);

    /* Get the current time. */
    time(&current_time);
    tm = localtime(&current_time);
    /* Fill the buffer. */
    snprintf(buf,
             buf_len,
             "<gkrellmd_setup>\n"
             "<decimal_point>\n"
             ".\n"
             "\n"
             "<cpu_setup>\n"
             "n_cpus 2\n"
             "%s"
             "%s\n"
             "%s"
             "%s\n"
             "<time>\n"
             "%d %d %d %d %d %d %d %d %d\n"
             "<monitors>\n"
             "cpu\n"
             "proc\n"
             "uptime\n"
             "</gkrellmd_setup>\n",
             preamble_args.hostnametag,
             preamble_args.hostname,
             preamble_args.sysnametag,
             preamble_args.sysname,
             tm->tm_sec, tm->tm_min, tm->tm_hour, tm->tm_mday, tm->tm_mon,
             tm->tm_year, tm->tm_wday, tm->tm_yday, tm->tm_isdst);
    retval = strlen(buf);
    return( retval );
}

int gkFormatUpdate(char *buf, size_t buf_len, gka_tag_t tag, ...)
{
    static struct tm last_tm;
    
    struct {
        unsigned long long cpu_user, cpu_idle;
        unsigned long long rsv_user, rsv_nice, rsv_idle;
        unsigned long processes, processes_running;
        unsigned long uptime;
    } update_args = {
        0, 0,
        0, 0, 0,
        0, 0,
    };
    time_t current_time;
    struct tm *tm;
    va_list args;
    int retval;

    require(buf != NULL);
    require(buf_len > 0);
    
    va_start(args, tag);
    while( tag != GKA_TAG_DONE )
    {
        switch( tag )
        {
        case GKA_CPUUser:
            update_args.cpu_user = va_arg(args, unsigned long long);
            break;
        case GKA_CPUIdle:
            update_args.cpu_idle = va_arg(args, unsigned long long);
            break;
        case GKA_CPUReserveUser:
            update_args.rsv_user = va_arg(args, unsigned long long);
            break;
        case GKA_CPUReserveNice:
            update_args.rsv_nice = va_arg(args, unsigned long long);
            break;
        case GKA_CPUReserveIdle:
            update_args.rsv_idle = va_arg(args, unsigned long long);
            break;
        case GKA_Processes:
            update_args.processes = va_arg(args, unsigned int);
            break;
        case GKA_ProcessesRunning:
            update_args.processes_running = va_arg(args, unsigned int);
            break;
        case GKA_UpTime:
            {
                struct timeval *tv = va_arg(args, struct timeval *);

                /* GKrellm expects uptime in minutes. */
                update_args.uptime = tv->tv_sec / 60;
            }
            break;
        default:
            ensure(0);
            break;
        }
        tag = va_arg(args, gka_tag_t);
    }
    va_end(args);
    
    time(&current_time);
    tm = localtime(&current_time);
    snprintf(buf,
             buf_len,
             "<cpu>\n"
             "0 %qd 0 0 %qd\n"
             "1 %qd %qd 0 %qd\n"
             "<proc>\n"
             "%ld %ld 0 0.0 1\n"
             "<uptime>\n"
             "%ld\n",
             update_args.cpu_user, update_args.cpu_idle,
             update_args.rsv_user, update_args.rsv_nice, update_args.rsv_idle,
             update_args.processes, update_args.processes_running,
             update_args.uptime);
    retval = strlen(buf);
    if( last_tm.tm_min != tm->tm_min )
    {
        snprintf(&buf[retval],
                 buf_len - retval,
                 "<time>\n"
                 "%d %d %d %d %d %d %d %d %d\n",
                 tm->tm_sec, tm->tm_min, tm->tm_hour, tm->tm_mday, tm->tm_mon,
                 tm->tm_year, tm->tm_wday, tm->tm_yday, tm->tm_isdst);
    }
    else
    {
        snprintf(&buf[retval],
                 buf_len - retval,
                 "<.%d>\n",
                 tm->tm_sec);
    }
    retval = strlen(buf);
    last_tm = *tm;
    return( retval );
}

---