/*
* top - a top users display for Unix
*
* SYNOPSIS:  any hp9000 running hpux version 10.10 (ALPHA VERSION)
*
* DESCRIPTION:
* This is the machine-dependent module for HPUX 10 that uses pstat.
* This makes top work on (at least) the following systems:
*      hp9000s800
* This may make top work on the following, but we aren't sure:
*      hp9000s700
*      hp9000s300
*
* CFLAGS: -DHAVE_GETOPT
*
* LIBS:
*
* AUTHOR: Rich Holland <[email protected]>
* AUTHOR: adapted from Kevin Schmidt <[email protected]>
*/

#include <sys/types.h>
#include <sys/signal.h>
#include <sys/param.h>

#include <stdio.h>
#include <errno.h>
#include <nlist.h>
#include <math.h>
#include <sys/dir.h>
#include <sys/dk.h>
#include <sys/vm.h>
#include <sys/file.h>
#include <sys/time.h>
#include <sys/pstat.h>

# define P_RSSIZE(p) (p)->pst_rssize
# define P_TSIZE(p) (p)->pst_tsize
# define P_DSIZE(p) (p)->pst_dsize
# define P_SSIZE(p) (p)->pst_ssize

#include "top.h"
#include "machine.h"
#include "utils.h"

#define VMUNIX  "/stand/vmunix"
#define KMEM    "/dev/kmem"
#define MEM     "/dev/mem"
#ifdef DOSWAP
#define SWAP    "/dev/dmem"
#endif

/* get_process_info passes back a handle.  This is what it looks like: */

struct handle
{
   struct pst_status **next_proc;      /* points to next valid pst pointer */
   int remaining;              /* number of pointers remaining */
};

/* declarations for load_avg */
#include "loadavg.h"

/* define what weighted cpu is.  */
#define weighted_cpu(pct, pp) ((pp->pst_time) == 0 ? 0.0 : \
                        ((pct) / (1.0 - exp((pp->pst_time) * logcpu))))

/* what we consider to be process size: */
#define PROCSIZE(pp) (P_TSIZE(pp) + P_DSIZE(pp) + P_SSIZE(pp))

/* definitions for indices in the nlist array */
#define X_AVENRUN       0
#define X_CCPU          1
#define X_NPROC         2
#define X_PROC          3
#define X_TOTAL         4
#define X_CP_TIME       5
#define X_MPID          6

/*
* Steinar Haug from University of Trondheim, NORWAY pointed out that
* the HP 9000 system 800 doesn't have _hz defined in the kernel.  He
* provided a patch to work around this.  We've improved on this patch
* here and set the constant X_HZ only when _hz is available in the
* kernel.  Code in this module that uses X_HZ is surrounded with
* appropriate ifdefs.
*/

#ifndef hp9000s300
#define X_HZ            7
#endif


static struct nlist nlst[] = {
   { "_avenrun" },             /* 0 */
   { "_cexp" },                /* 1 */
   { "_nproc" },               /* 2 */
   { "_proc" },                /* 3 */
   { "_total" },               /* 4 */
   { "_cp_time" },             /* 5 */
   { "_mpid" },                /* 6 */
#ifdef X_HZ
   { "_hz" },                  /* 7 */
#endif
   { 0 }
};

/*
*  These definitions control the format of the per-process area
*/

static char header[] =
 "  PID X        PRI NICE  SIZE   RES STATE   TIME   WCPU    CPU COMMAND";
/* 0123456   -- field to fill in starts at header+6 */
#define UNAME_START 6

#define Proc_format \
       "%5d %-8.8s %3d %4d %5s %5s %-5s %6s %5.2f%% %5.2f%% %s"

/* process state names for the "STATE" column of the display */

char *state_abbrev[] =
{
   "", "sleep", "run", "stop", "zomb", "trans", "start"
};


static int kmem;

/* values that we stash away in _init and use in later routines */

static double logcpu;

/* these are retrieved from the kernel in _init */

static unsigned long proc;
static          int  nproc;
static          long hz;
static load_avg  ccpu;
static          int  ncpu = 0;

/* these are offsets obtained via nlist and used in the get_ functions */
static unsigned long mpid_offset;
static unsigned long avenrun_offset;
static unsigned long total_offset;
static unsigned long cp_time_offset;

/* these are for calculating cpu state percentages */

static long cp_time[CPUSTATES];
static long cp_old[CPUSTATES];
static long cp_diff[CPUSTATES];

/* these are for detailing the process states */

int process_states[7];
char *procstatenames[] = {
   "", " sleeping, ", " running, ", " stopped, ", " zombie, ",
   " trans, ", " starting, ",
   NULL
};

/* these are for detailing the cpu states */

int cpu_states[9];
char *cpustatenames[] = {
   "usr", "nice", "sys", "idle", NULL, "", "", "intr", "ker",
   NULL
};

/* these are for detailing the memory statistics */

int memory_stats[8];
char *memorynames[] = {
   "Real: ", "K/", "K act/tot  ", "Virtual: ", "K/",
   "K act/tot  ", "Free: ", "K", NULL
};

/* these are for keeping track of the pst array */

static int bytes;
static int pref_len;
static struct pst_status *pbase;
static struct pst_status **pref;

/* these are for getting the memory statistics */

static int pageshift;           /* log base 2 of the pagesize */

/* define pagetok in terms of pageshift */

#define pagetok(size) ((size) << pageshift)

/* useful externals */
extern int errno;
extern char *sys_errlist[];

long lseek();
long time();

machine_init(statics)

struct statics *statics;

{
   register int i = 0;
   register int pagesize;

   if ((kmem = open(KMEM, O_RDONLY)) == -1) {
       perror(KMEM);
       return(-1);
   }
#ifdef hp9000s800
   /* 800 names don't have leading underscores */
   for (i = 0; nlst[i].n_name; nlst[i++].n_name++)
       continue;
#endif

   /* get the list of symbols we want to access in the kernel */
   (void) nlist(VMUNIX, nlst);
   if (nlst[0].n_type == 0)
   {
       fprintf(stderr, "top: nlist failed\n");
       return(-1);
   }

   /* make sure they were all found */
   if (check_nlist(nlst) > 0)
   {
       return(-1);
   }

   /* get the symbol values out of kmem */
   (void) getkval(nlst[X_PROC].n_value,   (int *)(&proc),      sizeof(proc),
           nlst[X_PROC].n_name);
   (void) getkval(nlst[X_NPROC].n_value,  &nproc,              sizeof(nproc),
           nlst[X_NPROC].n_name);
   (void) getkval(nlst[X_CCPU].n_value,   (int *)(&ccpu),      sizeof(ccpu),
           nlst[X_CCPU].n_name);
#ifdef X_HZ
   (void) getkval(nlst[X_HZ].n_value,     (int *)(&hz),        sizeof(hz),
           nlst[X_HZ].n_name);
#else
   hz = HZ;
#endif

   /* stash away certain offsets for later use */
   mpid_offset = nlst[X_MPID].n_value;
   avenrun_offset = nlst[X_AVENRUN].n_value;
   total_offset = nlst[X_TOTAL].n_value;
   cp_time_offset = nlst[X_CP_TIME].n_value;

   /* this is used in calculating WCPU -- calculate it ahead of time */
   logcpu = log(loaddouble(ccpu));

   /* allocate space for pst structure array and array of pointers */
   bytes = nproc * sizeof(struct pst_status);
   pbase = (struct pst_status *)malloc(bytes);
   pref  = (struct pst_status **)malloc(nproc * sizeof(struct pst_status *));

   /* Just in case ... */
   if (pbase == (struct pst_status *)NULL || pref == (struct pst_status **)NULL)
   {
       fprintf(stderr, "top: can't allocate sufficient memory\n");
       return(-1);
   }

   /* get the page size with "getpagesize" and calculate pageshift from it */
   pagesize = getpagesize();
   pageshift = 0;
   while (pagesize > 1)
   {
       pageshift++;
       pagesize >>= 1;
   }

   /* we only need the amount of log(2)1024 for our conversion */
   pageshift -= LOG1024;

   /* fill in the statics information */
   statics->procstate_names = procstatenames;
   statics->cpustate_names = cpustatenames;
   statics->memory_names = memorynames;

   /* all done! */
   return(0);
}

char *format_header(uname_field)

register char *uname_field;

{
   register char *ptr;

   ptr = header + UNAME_START;
   while (*uname_field != '\0')
   {
       *ptr++ = *uname_field++;
   }

   return(header);
}

get_system_info(si)

struct system_info *si;

{
   load_avg avenrun[3];
   long total;

   /* get the cp_time array */
   (void) getkval(cp_time_offset, (int *)cp_time, sizeof(cp_time),
                  "_cp_time");

   /* get load average array */
   (void) getkval(avenrun_offset, (int *)avenrun, sizeof(avenrun),
                  "_avenrun");

   /* get mpid -- process id of last process */
   (void) getkval(mpid_offset, &(si->last_pid), sizeof(si->last_pid),
                  "_mpid");

   /* convert load averages to doubles */
   {
       register int i;
       register double *infoloadp;
       register load_avg *sysloadp;

       infoloadp = si->load_avg;
       sysloadp = avenrun;
       for (i = 0; i < 3; i++)
       {
           *infoloadp++ = loaddouble(*sysloadp++);
       }
   }

   /* convert cp_time counts to percentages */
   total = percentages(CPUSTATES, cpu_states, cp_time, cp_old, cp_diff);

   /* sum memory statistics */
   {
       struct vmtotal total;

       /* get total -- systemwide main memory usage structure */
       (void) getkval(total_offset, (int *)(&total), sizeof(total),
                      "_total");
       /* convert memory stats to Kbytes */
       memory_stats[0] = -1;
       memory_stats[1] = pagetok(total.t_arm);
       memory_stats[2] = pagetok(total.t_rm);
       memory_stats[3] = -1;
       memory_stats[4] = pagetok(total.t_avm);
       memory_stats[5] = pagetok(total.t_vm);
       memory_stats[6] = -1;
       memory_stats[7] = pagetok(total.t_free);
   }

   /* set arrays and strings */
   si->cpustates = cpu_states;
   si->memory = memory_stats;
}

static struct handle handle;

caddr_t get_process_info(si, sel, compare)

struct system_info *si;
struct process_select *sel;
int (*compare)();

{
   register int i;
   register int total_procs;
   register int active_procs;
   register struct pst_status **prefp;
   register struct pst_status *pp;

   /* these are copied out of sel for speed */
   int show_idle;
   int show_system;
   int show_uid;
   int show_command;

   /* read all the pst structures in one fell swoop */
   if ((total_procs = pstat_getproc(pbase, sizeof(struct pst_status),
                                    nproc, 0)) < 0)
   {
       perror("pstat_getproc");
       return(NULL);
   }

   /* get a pointer to the states summary array */
   si->procstates = process_states;

   /* set up flags which define what we are going to select */
   show_idle = sel->idle;
   show_system = sel->system;
   show_uid = sel->uid != -1;
   show_command = sel->command != NULL;

   /* count up process states and get pointers to interesting procs */
   active_procs = 0;
   memset((char *)process_states, 0, sizeof(process_states));
   prefp = pref;
   for (pp = pbase, i = 0; i < total_procs; pp++, i++)
   {
       /*
        *  Place pointers to each valid pst structure in pref[].
        *  Process slots that are actually in use have a non-zero
        *  status field.  Processes with SSYS set are system
        *  processes---these get ignored unless show_sysprocs is set.
        */
       if (pp->pst_stat != 0 &&
           (show_system || ((pp->pst_flag & PS_SYS) == 0)))
       {
           process_states[pp->pst_stat]++;

           /*
            * idle processes can be selectively ignored:  a process is
            * considered idle when cpticks is zero AND it is not in the run
            * state.  Zombies are always ignored.  We also skip over
            * processes that have been excluded via a uid selection
            */
           if ((pp->pst_stat != PS_ZOMBIE) &&
               (show_idle || (pp->pst_cpticks != 0) || (pp->pst_stat == PS_RUN)) &&
               (!show_uid || pp->pst_uid == (uid_t)sel->uid))
           {
               *prefp++ = pp;
               active_procs++;
           }
       }
   }

   /* if requested, sort the "interesting" processes */
   if (compare != NULL)
   {
       qsort((char *)pref, active_procs, sizeof(struct pst_status *), compare);
   }

   /* remember active and total counts */
   si->p_total = total_procs;
   si->p_active = pref_len = active_procs;

   /* pass back a handle */
   handle.next_proc = pref;
   handle.remaining = active_procs;
   return((caddr_t)&handle);
}

char fmt[MAX_COLS];             /* static area where result is built */

char *format_next_process(handle, get_userid)

caddr_t handle;
char *(*get_userid)();

{
   register struct pst_status *pp;
   register long cputime;
   register double pct;
   int where;
   struct handle *hp;
   struct timeval time;
   struct timezone timezone;

   /* sanity check */
   if (handle == (caddr_t)NULL)
   {
       return("");
   }

   /* find and remember the next proc structure */
   hp = (struct handle *)handle;
   pp = *(hp->next_proc++);
   hp->remaining--;


   /* set ucomm for system processes */
   if (pp->pst_ucomm[0] == '\0')
   {
       /* is this ever going to happen? */
       if (pp->pst_pid == 0)
       {
           (void) strcpy(pp->pst_ucomm, "Swapper");
       }
       else if (pp->pst_pid == 2)
       {
           (void) strcpy(pp->pst_ucomm, "Pager");
       }
   }

   cputime = pp->pst_cptickstotal / hz;

   /* calculate the base for cpu percentages */
   pct = pctdouble(pp->pst_pctcpu);

   /* get time used for calculation in weighted_cpu */
   gettimeofday(&time, &timezone);

   /* format this entry */
   sprintf(fmt,
           Proc_format,
           pp->pst_pid,
           (*get_userid)(pp->pst_uid),
           pp->pst_pri,
           pp->pst_nice,
           format_k(pagetok(PROCSIZE(pp))),
           format_k(pagetok(P_RSSIZE(pp))),
           state_abbrev[pp->pst_stat],
           format_time(cputime),
           100.0 * weighted_cpu(pct, pp),
           100.0 * pct,
           printable(pp->pst_ucomm));

   /* return the result */
   return(fmt);
}

/*
* check_nlist(nlst) - checks the nlist to see if any symbols were not
*              found.  For every symbol that was not found, a one-line
*              message is printed to stderr.  The routine returns the
*              number of symbols NOT found.
*/

int check_nlist(nlst)

register struct nlist *nlst;

{
   register int i;

   /* check to see if we got ALL the symbols we requested */
   /* this will write one line to stderr for every symbol not found */

   i = 0;
   while (nlst->n_name != NULL)
   {
       if (nlst->n_type == 0)
       {
           /* this one wasn't found */
           fprintf(stderr, "kernel: no symbol named `%s'\n", nlst->n_name);
           i = 1;
       }
       nlst++;
   }

   return(i);
}


/*
*  getkval(offset, ptr, size, refstr) - get a value out of the kernel.
*      "offset" is the byte offset into the kernel for the desired value,
*      "ptr" points to a buffer into which the value is retrieved,
*      "size" is the size of the buffer (and the object to retrieve),
*      "refstr" is a reference string used when printing error meessages,
*          if "refstr" starts with a '!', then a failure on read will not
*          be fatal (this may seem like a silly way to do things, but I
*          really didn't want the overhead of another argument).
*
*/

getkval(offset, ptr, size, refstr)

unsigned long offset;
int *ptr;
int size;
char *refstr;

{
   if (lseek(kmem, (long)offset, L_SET) == -1) {
       if (*refstr == '!')
           refstr++;
       (void) fprintf(stderr, "%s: lseek to %s: %s\n", KMEM,
                      refstr, strerror(errno));
       quit(23);
   }
   if (read(kmem, (char *) ptr, size) == -1) {
       if (*refstr == '!')
           return(0);
       else {
           (void) fprintf(stderr, "%s: reading %s: %s\n", KMEM,
                          refstr, strerror(errno));
           quit(23);
       }
   }
   return(1);
}

/* comparison routine for qsort */

/*
*  proc_compare - comparison function for "qsort"
*      Compares the resource consumption of two processes using five
*      distinct keys.  The keys (in descending order of importance) are:
*      percent cpu, cpu ticks, state, resident set size, total virtual
*      memory usage.  The process states are ordered as follows (from least
*      to most important):  WAIT, zombie, sleep, stop, start, run.  The
*      array declaration below maps a process state index into a number
*      that reflects this ordering.
*/

static unsigned char sorted_state[] =
{
   0,  /* not used             */
   3,  /* sleep                */
   6,  /* run                  */
   4,  /* stop                 */
   2,  /* zombie               */
   5,  /* start                */
   1,  /* other                */
};

proc_compare(pp1, pp2)

struct pst_status **pp1;
struct pst_status **pp2;

{
   register struct pst_status *p1;
   register struct pst_status *p2;
   register int result;
   register pctcpu lresult;

   /* remove one level of indirection */
   p1 = *pp1;
   p2 = *pp2;

   /* compare percent cpu (pctcpu) */
   if ((lresult = p2->pst_pctcpu - p1->pst_pctcpu) == 0)
   {
       /* use cpticks to break the tie */
       if ((result = p2->pst_cpticks - p1->pst_cpticks) == 0)
       {
           /* use process state to break the tie */
           if ((result = sorted_state[p2->pst_stat] -
                         sorted_state[p1->pst_stat])  == 0)
           {
               /* use priority to break the tie */
               if ((result = p2->pst_pri - p1->pst_pri) == 0)
               {
                   /* use resident set size (rssize) to break the tie */
                   if ((result = P_RSSIZE(p2) - P_RSSIZE(p1)) == 0)
                   {
                       /* use total memory to break the tie */
                       result = PROCSIZE(p2) - PROCSIZE(p1);
                   }
               }
           }
       }
   }
   else
   {
       result = lresult < 0 ? -1 : 1;
   }

   return(result);
}


void (*signal(sig, func))()
   int sig;
   void (*func)();
{
   struct sigvec osv, sv;

   /*
    * XXX: we should block the signal we are playing with,
    *      in case we get interrupted in here.
    */
   if (sigvector(sig, NULL, &osv) == -1)
       return BADSIG;
   sv = osv;
   sv.sv_handler = func;
#ifdef SV_BSDSIG
   sv.sv_flags |= SV_BSDSIG;
#endif
   if (sigvector(sig, &sv, NULL) == -1)
       return BADSIG;
   return osv.sv_handler;
}

int getpagesize() { return 1 << PGSHIFT; }

int setpriority(a, b, c) { errno = ENOSYS; return -1; }

/*
* proc_owner(pid) - returns the uid that owns process "pid", or -1 if
*              the process does not exist.
*              It is EXTREMLY IMPORTANT that this function work correctly.
*              If top runs setuid root (as in SVR4), then this function
*              is the only thing that stands in the way of a serious
*              security problem.  It validates requests for the "kill"
*              and "renice" commands.
*/

int proc_owner(pid)

int pid;

{
   register int cnt;
   register struct pst_status **prefp;
   register struct pst_status *pp;

   prefp = pref;
   cnt = pref_len;
   while (--cnt >= 0)
   {
       if ((pp = *prefp++)->pst_pid == (pid_t)pid)
       {
           return((int)pp->pst_uid);
       }
   }
   return(-1);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.