/*
 * swrun_kinfo.c:
 *     hrSWRunTable data access:
 *     kvm_getprocs() interface - FreeBSD, NetBSD, OpenBSD
 *
 * NB: later FreeBSD and OpenBSD use different kinfo_proc structures
 */
#include <net-snmp/net-snmp-config.h>

#include <stdio.h>
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
#endif
#ifdef HAVE_STRING_H
#include <string.h>
#else
#include <strings.h>
#endif

#ifdef HAVE_KVM_H
#include <kvm.h>
#endif
#ifdef HAVE_SYS_PARAM_H
#include <sys/param.h>
#endif
#ifdef HAVE_SYS_SYSCTL_H
#include <sys/sysctl.h>
#endif
#ifdef HAVE_SYS_PROC_H
#include <sys/proc.h>
#endif
#ifdef HAVE_SYS_USER_H
#include <sys/user.h>
#endif
#ifdef HAVE_UVM_UVM_EXTERNAL_H
#include <uvm/uvm_external.h>
#endif

#include <net-snmp/net-snmp-includes.h>
#include <net-snmp/agent/net-snmp-agent-includes.h>
#include <net-snmp/library/container.h>
#include <net-snmp/library/snmp_debug.h>
#include <net-snmp/data_access/swrun.h>
#include "swrun_private.h"

extern kvm_t *kd;


#if defined(freebsd5) && __FreeBSD_version >= 500014
    /*
     * later FreeBSD kinfo_proc field names
     */
#define SWRUN_TABLE	kinfo_proc
#define SWRUN_K_STAT	ki_stat
#define SWRUN_K_PID	ki_pid
#define SWRUN_K_PPID	ki_ppid
#define SWRUN_K_TID	ki_tid
#define SWRUN_K_COMM	ki_comm
#define SWRUN_K_FLAG	ki_flag
#define SWRUN_K_CLASS	ki_pri.pri_class

#elif HAVE_KVM_GETPROC2 || defined(openbsd5)
    /*
     * newer NetBSD, OpenBSD kinfo_proc2 field names
     */
#if defined(openbsd5)
#define SWRUN_TABLE	kinfo_proc
#else
#define SWRUN_TABLE	kinfo_proc2
#endif
#define SWRUN_K_STAT	p_stat
#define SWRUN_K_PID	p_pid
#define SWRUN_K_COMM	p_comm
#define SWRUN_K_FLAG	p_flag
/*      SWRUN_K_CLASS	not defined     */

#elif defined(dragonfly)
    /*
     * DragonFly is different ...
     */
#define SWRUN_TABLE	kinfo_proc
#define SWRUN_K_STAT	kp_stat
#define SWRUN_K_PID 	kp_pid
#define SWRUN_K_COMM	kp_comm
#define SWRUN_K_FLAG	kp_flags
/*      SWRUN_K_CLASS	not defined     */

#else
    /*
     * early FreeBSD, NetBSD, OpenBSD kinfo_proc field names
     */
#define SWRUN_TABLE	kinfo_proc
#define SWRUN_K_STAT	kp_proc.p_stat
#define SWRUN_K_PID	kp_proc.p_pid
#define SWRUN_K_COMM	kp_proc.p_comm
#define SWRUN_K_FLAG	kp_proc.p_flag
/*      SWRUN_K_CLASS	not defined     */
#endif

/*
 *  Define dummy values if not already provided by the system
 */

#ifdef dragonfly

/*
 * DragonFly is special. p_stat is an enum!
 */

#define SRUN	200
#define SSLEEP	202
#define SWAIT	203
#define SLOCK	205
#define SDEAD	208
#define SONPROC	209


#else

#ifndef SRUN
#define SRUN	200	/* Defined by FreeBSD/OpenBSD, missing in  NetBSD */
#endif
#ifndef SACTIVE
#define SACTIVE	201	/* Defined by  NetBSD, missing in FreeBSD/OpenBSD */
#endif
#ifndef SSLEEP
#define SSLEEP	202	/* Defined by FreeBSD/OpenBSD, missing in  NetBSD */
#endif
#ifndef SWAIT
#define SWAIT	203	/* Defined by FreeBSD, missing in  NetBSD/OpenBSD */
#endif
#ifndef SSTOP
#define SSTOP	204	/* Defined by FreeBSD/NetBSD/OpenBSD */
#endif
#ifndef SLOCK
#define SLOCK	205	/* Defined by FreeBSD, missing in NetBSD/OpenBSD */
#endif
#ifndef SIDL
#define SIDL	206	/* Defined by FreeBSD/NetBSD/OpenBSD */
#endif
#ifndef SZOMB
#define SZOMB	207	/* Defined by FreeBSD/NetBSD/OpenBSD */
#endif
#ifndef SDEAD
#define SDEAD	208	/* Defined by OpenBSD, missing in FreeBSD/NetBSD */
#endif
#ifndef SONPROC
#define SONPROC	209	/* Defined by OpenBSD, missing in FreeBSD/NetBSD */
#endif

#endif

/* ---------------------------------------------------------------------
 */
void
netsnmp_arch_swrun_init(void)
{
#if NETSNMP_CAN_USE_SYSCTL && defined(CTL_KERN) && defined(KERN_MAXPROC)
    extern int _swrun_max;
    size_t max_size = sizeof(_swrun_max);
    int maxproc_mib[] = { CTL_KERN, KERN_MAXPROC };
    sysctl(maxproc_mib, 2, &_swrun_max, &max_size, NULL, 0);
#endif
    
    return;
}

/* ---------------------------------------------------------------------
 */
int
netsnmp_arch_swrun_container_load( netsnmp_container *container, u_int flags)
{
    struct SWRUN_TABLE  *proc_table;
    int                  nprocs, i, rc;
    char                 buf[BUFSIZ+1], **argv;
    netsnmp_swrun_entry *entry;

    if ( 0 == kd ) {
        DEBUGMSGTL(("swrun:load:arch"," Can't query kvm info\n"));
        return 1;     /* No handle for retrieving process table */
    }
#if defined(openbsd5)
    proc_table = kvm_getprocs(kd, KERN_PROC_KTHREAD, 0, sizeof(struct kinfo_proc), &nprocs );
#elif defined(HAVE_KVM_GETPROC2)
    proc_table = kvm_getproc2(kd, KERN_PROC_ALL, 0, sizeof(struct kinfo_proc2), &nprocs );
#else
    proc_table = kvm_getprocs(kd, KERN_PROC_ALL, 0, &nprocs );
#endif
    for ( i=0 ; i<nprocs; i++ ) {
        if ( 0 == proc_table[i].SWRUN_K_STAT )
            continue;
        if ( -1 == proc_table[i].SWRUN_K_PID )
            continue;
#ifdef SWRUN_K_TID
	if ( 0 == proc_table[i].SWRUN_K_PPID )
	    proc_table[i].SWRUN_K_PID = proc_table[i].SWRUN_K_TID;
#endif
        entry = netsnmp_swrun_entry_create(proc_table[i].SWRUN_K_PID);
        if (NULL == entry)
            continue;   /* error already logged by function */
        rc = CONTAINER_INSERT(container, entry);

        /*
         * There are two possible sources for the command being run:
         *   - SWRUN_K_COMM  (from the proc_table entry directly)
         *   - running kvm_getargv on the process entry.
         *
         * We'll use argv[0] (if set) for hrSWRunPath,
         *   since that might potentially contain the
         *   absolute path to the running binary.
         * We'll use SWRUN_K_COMM for hrSWRunName,
         *   and as an alternative for hrSWRunPath
         */
#if HAVE_KVM_GETPROC2
        argv = kvm_getargv2( kd, &(proc_table[i]), 0);
#else
        argv = kvm_getargv(  kd, &(proc_table[i]), BUFSIZ);
#endif

        entry->hrSWRunName_len = sprintf(entry->hrSWRunName, "%.*s",
                                         (int)sizeof(entry->hrSWRunName) - 1,
                                         proc_table[i].SWRUN_K_COMM);

        if (argv && *argv) {
            entry->hrSWRunPath_len = sprintf(entry->hrSWRunPath, "%.*s",
                                             (int)sizeof(entry->hrSWRunPath)-1,
                                             argv[0]);
        } else {
            memcpy( entry->hrSWRunPath, entry->hrSWRunName,
                                        entry->hrSWRunName_len );
            entry->hrSWRunPath_len = entry->hrSWRunName_len;
        }

        /*
         * Stitch together the rest of argv[] to build hrSWRunParameters
         *
         * Note:
         *   We add a separating space before each argv[] parameter,
         *   *including* the first one.  So we need to skip this
         *   leading space (buf[0]) when setting hrSWRunParameters.
         * This is also why we cleared the first *two* characters
         *   in the buffer initially. If there were no command-line
         *   arguments, then buf[1] would still be a null string.
         */
        buf[0] = '\0';
        buf[1] = '\0';
        if (argv)
            argv++;    /* Skip argv[0] */
        while ( argv && *argv ) {
            strlcat(buf, " ", sizeof(buf));
            strlcat(buf, *argv, sizeof(buf));
            argv++;
        }
        if (strlen(buf) >= BUFSIZ-10)
            snmp_log(LOG_ERR, "params %lu/%d %s\n", strlen(buf), BUFSIZ, buf);
        entry->hrSWRunParameters_len =
            sprintf(entry->hrSWRunParameters, "%.*s",
                    (int)sizeof(entry->hrSWRunParameters) - 1, buf+1);

        entry->hrSWRunType = (P_SYSTEM & proc_table[i].SWRUN_K_FLAG) 
#ifdef SWRUN_K_CLASS
                             ? ((PRI_ITHD == proc_table[i].SWRUN_K_CLASS)
                                ? 3  /* device driver    */
                                : 2  /* operating system */
                               )
                             : 4  /*  application     */
#else
                             ? 2  /* operating system */
                             : 4  /*  application     */
#endif
                             ;

#ifdef netbsd5
        switch (proc_table[i].SWRUN_K_STAT) {
	case LSONPROC:
        case LSRUN:   entry->hrSWRunStatus = HRSWRUNSTATUS_RUNNING;
                      break;
        case LSSLEEP: entry->hrSWRunStatus = HRSWRUNSTATUS_RUNNABLE;
                      break;
        case LSIDL:
	case LSSUSPENDED:
        case LSSTOP:  entry->hrSWRunStatus = HRSWRUNSTATUS_NOTRUNNABLE;
                      break;
	case LSDEAD:
        case LSZOMB:  entry->hrSWRunStatus = HRSWRUNSTATUS_INVALID;
		      break;
        default:   
		      entry->hrSWRunStatus = HRSWRUNSTATUS_INVALID;
		      snmp_log(LOG_ERR, "Bad process status %c (0x%x)\n", proc_table[i].SWRUN_K_STAT, proc_table[i].SWRUN_K_STAT);
                      break;
        }
#else
        switch (proc_table[i].SWRUN_K_STAT & 0xFF) {
        case SONPROC:
        case SRUN:    entry->hrSWRunStatus = HRSWRUNSTATUS_RUNNING;
                      break;
        case SSLEEP:
	case SACTIVE:
        case SWAIT:   entry->hrSWRunStatus = HRSWRUNSTATUS_RUNNABLE;
                      break;
        case SIDL:
        case SSTOP:
        case SLOCK:   entry->hrSWRunStatus = HRSWRUNSTATUS_NOTRUNNABLE;
                      break;

        case SDEAD:
        case SZOMB:   entry->hrSWRunStatus = HRSWRUNSTATUS_INVALID;   /* i.e. "not loaded" */
                      break;

        default:      entry->hrSWRunStatus = HRSWRUNSTATUS_INVALID;   /* Actually invalid  */
		      snmp_log(LOG_ERR, "Bad process status %c (0x%x)\n", proc_table[i].SWRUN_K_STAT, proc_table[i].SWRUN_K_STAT);
                      break;
        }
#endif
        
#if defined(freebsd5) && __FreeBSD_version >= 500014
         entry->hrSWRunPerfCPU  = (proc_table[i].ki_rusage.ru_utime.tv_sec*1000000 + proc_table[i].ki_rusage.ru_utime.tv_usec) / 10000;
	 entry->hrSWRunPerfCPU += (proc_table[i].ki_rusage.ru_stime.tv_sec*1000000 + proc_table[i].ki_rusage.ru_stime.tv_usec) / 10000;
	 entry->hrSWRunPerfCPU += (proc_table[i].ki_rusage_ch.ru_utime.tv_sec*1000000 + proc_table[i].ki_rusage_ch.ru_utime.tv_usec) / 10000;
	 entry->hrSWRunPerfCPU += (proc_table[i].ki_rusage_ch.ru_stime.tv_sec*1000000 + proc_table[i].ki_rusage_ch.ru_stime.tv_usec) / 10000;
	 entry->hrSWRunPerfMem  = proc_table[i].ki_rssize * (getpagesize()/1024);  /* in kB */
#elif defined(HAVE_KVM_GETPROC2) || defined(openbsd5)
        /*
         * newer NetBSD, OpenBSD
         */
	entry->hrSWRunPerfCPU = proc_table[i].p_rtime_sec*100;
	entry->hrSWRunPerfCPU += proc_table[i].p_rtime_usec / 10000;

        entry->hrSWRunPerfMem  = proc_table[i].p_vm_rssize;
        entry->hrSWRunPerfMem *= (getpagesize() / 1024);
#elif defined(dragonfly) && __DragonFly_version >= 190000
	entry->hrSWRunPerfCPU  = proc_table[i].kp_lwp.kl_uticks;
	entry->hrSWRunPerfCPU += proc_table[i].kp_lwp.kl_sticks;
	entry->hrSWRunPerfCPU += proc_table[i].kp_lwp.kl_iticks;
	entry->hrSWRunPerfCPU = entry->hrSWRunPerfCPU / 10000;

	entry->hrSWRunPerfMem  = proc_table[i].kp_vm_map_size / 1024;
#elif defined(dragonfly)
	entry->hrSWRunPerfCPU  = proc_table[i].kp_eproc.e_uticks;
	entry->hrSWRunPerfCPU += proc_table[i].kp_eproc.e_sticks;
	entry->hrSWRunPerfCPU += proc_table[i].kp_eproc.e_iticks;

	entry->hrSWRunPerfMem  = proc_table[i].kp_vm_map_size / 1024;

#else
        /*
         * early FreeBSD, NetBSD, OpenBSD
         */
        entry->hrSWRunPerfCPU  = proc_table[i].kp_proc.p_uticks;
        entry->hrSWRunPerfCPU += proc_table[i].kp_proc.p_sticks;
        entry->hrSWRunPerfCPU += proc_table[i].kp_proc.p_iticks;
        entry->hrSWRunPerfMem  = proc_table[i].kp_eproc.e_vm.vm_rssize;
        entry->hrSWRunPerfMem *= (getpagesize() / 1024);
#endif
    }
    /*
     * 'proc_table' is owned by the kvm library,
     *   so shouldn't be freed here.
     */

    DEBUGMSGTL(("swrun:load:arch","loaded %d entries\n",
                (int)CONTAINER_SIZE(container)));

    return 0;
}