oneechanhax/phunix
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
phunix/external/bsd/top/dist/machine/m_svr5.c
David van Moolenbroek b89261ba01 Rename top(1) to mtop(1), import NetBSD top(1) 
Due to differences in (mainly) measuring and accumulating CPU times,
the two top programs end up serving different purposes: the NetBSD
top is a system administration tool, while the MINIX3 top (now mtop)
is a performance debugging tool.  Therefore, we keep both.

The newly imported BSD top has a few MINIX3-specific changes.  CPU
statistics separate system time from kernel time, rather than kernel
time from time spent on handling interrupts.  Memory statistics show
numbers that are currently relevant for MINIX3.  Swap statistics are
disabled entirely.  All of these changes effectively bring it closer
to how mtop already worked as well.

Change-Id: I9611917cb03e164ddf012c5def6da0e7fede826d
2016-01-13 20:32:53 +01:00

1449 lines
36 KiB
C
Raw Permalink Blame History

/*
* Copyright (c) 1984 through 2008, William LeFebvre
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
*
* * Neither the name of William LeFebvre nor the names of other
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
* top - a top users display for Unix
*
* SYNOPSIS: For Intel based System V Release 5 (Unixware7)
*
* DESCRIPTION:
* System V release 5 for i[3456]86
* Works for:
* i586-sco-sysv5uw7 i386 SCO UNIX_SVR5 (UnixWare 7)
*
* LIBS: -lelf -lmas
*
* CFLAGS: -DHAVE_GETOPT -DORDER
*
* AUTHORS: Mike Hopkirk <hops@sco.com>
* David Cutter <dpc@grail.com>
* Andrew Herbert <andrew@werple.apana.org.au>
* Robert Boucher <boucher@sofkin.ca>
*/
/* build config
* SHOW_NICE - process nice fields don't seem to be being updated so changed
* default to display # of threads in use instead.
* define this to display nice fields (values always 0)
* #define SHOW_NICE 1
*/
#define _KMEMUSER
#define prpsinfo psinfo
#include <sys/procfs.h>
#define pr_state pr_lwp.pr_state
#define pr_nice pr_lwp.pr_nice
#define pr_pri pr_lwp.pr_pri
#define pr_onpro pr_lwp.pr_onpro
#define ZOMBIE(p) ((p)->pr_nlwp == 0)
#define SIZE_K(p) pagetok((p)->pr_size)
#define RSS_K(p) pagetok((p)->pr_rssize)
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include <dirent.h>
#include <nlist.h>
#include <string.h>
#include <sys/types.h>
#include <sys/param.h>
#include <sys/proc.h>
#include <sys/sysmacros.h>
#include <vm/anon.h>
#include <sys/priocntl.h>
#include <sys/tspriocntl.h>
#include <sys/var.h>
#include "top.h"
#include "machine.h"
#include "utils.h"
#define UNIX "/stand/unix"
#define KMEM "/dev/kmem"
#define PROCFS "/proc"
#define CPUSTATES 5
#ifndef PRIO_MAX
#define PRIO_MAX 20
#endif
#ifndef PRIO_MIN
#define PRIO_MIN -20
#endif
#ifndef FSCALE
#define FSHIFT 8 /* bits to right of fixed binary point */
#define FSCALE (1<<FSHIFT)
#endif
#define loaddouble(x) ((double)x/FSCALE)
#define pagetok(size) ((size) * pagesz) >> LOG1024
/* definitions for the index in the nlist array */
#define X_AVENRUN 0
#define X_V 1
#define X_MPID 2
static struct nlist nlst[] =
{
{"avenrun"}, /* 0 */
{"v"}, /* 1 */
{"nextpid"}, /* 2 */
{NULL}
};
static unsigned long avenrun_offset;
static unsigned long mpid_offset;
static unsigned int pagesz;
static void reallocproc(int n);
static int maxprocs;
/* get_process_info passes back a handle. This is what it looks like: */
struct handle
{
struct prpsinfo **next_proc;/* points to next valid proc pointer */
int remaining; /* number of pointers remaining */
};
/*
* These definitions control the format of the per-process area
*/
static char header[] =
#ifdef SHOW_NICE
" PID X PRI NICE SIZE RES STATE TIME CPU COMMAND";
#else
" PID X PRI THR SIZE RES STATE TIME CPU COMMAND";
#endif
/* 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 %8.4f%% %.16s"
char *state_abbrev[] =
{"oncpu", "run", "sleep", "stop", "idle", "zombie"};
#define sZOMB 5
int process_states[8];
char *procstatenames[] =
{
" on cpu, ", " running, ", " sleeping, ", " stopped, ",
" idling ", " zombie, ",
NULL
};
int cpu_states[CPUSTATES];
char *cpustatenames[] =
{"idle", "user", "kernel", "wait", NULL};
/* these are for detailing the memory statistics */
long memory_stats[5];
char *memorynames[] =
{"K phys, ", "K used, ", "K free, ", "K swapUsed, ", "K swapFree", NULL};
/* these are names given to allowed sorting orders -- first is default */
char *ordernames[] =
{"state", "cpu", "size", "res", "time", "pid", "uid", "rpid", "ruid", NULL};
/* forward definitions for comparison functions */
int proc_compare();
int compare_cpu();
int compare_size();
int compare_res();
int compare_time();
int compare_pid();
int compare_uid();
int compare_rpid();
int compare_ruid();
int (*proc_compares[])() = {
proc_compare,
compare_cpu,
compare_size,
compare_res,
compare_time,
compare_pid,
compare_uid,
compare_rpid,
compare_ruid,
NULL };
static int kmem = -1;
static int nproc;
static int bytes;
static struct prpsinfo *pbase;
static struct prpsinfo **pref;
static DIR *procdir;
/* useful externals */
extern int errno;
extern char *sys_errlist[];
extern char *myname;
extern long percentages ();
extern int check_nlist ();
extern int getkval ();
extern void perror ();
extern void getptable ();
extern void quit ();
extern int nlist ();
/* fwd dcls */
static int kmet_init(void );
static int get_cpustates(int *new);
int
machine_init (struct statics *statics)
{
static struct var v;
int i;
/* fill in the statics information */
statics->procstate_names = procstatenames;
statics->cpustate_names = cpustatenames;
statics->memory_names = memorynames;
statics->order_names = ordernames;
/* get the list of symbols we want to access in the kernel */
if (nlist (UNIX, nlst))
{
(void) fprintf (stderr, "Unable to nlist %s\n", UNIX);
return (-1);
}
/* make sure they were all found */
if (check_nlist (nlst) > 0)
return (-1);
/* open kernel memory */
if ((kmem = open (KMEM, O_RDONLY)) == -1)
{
perror (KMEM);
return (-1);
}
v.v_proc=200; /* arbitrary default */
/* get the symbol values out of kmem */
/* NPROC Tuning parameter for max number of processes */
(void) getkval (nlst[X_V].n_value, &v, sizeof (struct var), nlst[X_V].n_name);
nproc = v.v_proc;
maxprocs = nproc;
/* stash away certain offsets for later use */
mpid_offset = nlst[X_MPID].n_value;
avenrun_offset = nlst[X_AVENRUN].n_value;
/* allocate space for proc structure array and array of pointers */
bytes = nproc * sizeof (struct prpsinfo);
pbase = (struct prpsinfo *) malloc (bytes);
pref = (struct prpsinfo **) malloc (nproc * sizeof (struct prpsinfo *));
pagesz = sysconf(_SC_PAGESIZE);
/* Just in case ... */
if (pbase == (struct prpsinfo *) NULL || pref == (struct prpsinfo **) NULL)
{
(void) fprintf (stderr, "%s: can't allocate sufficient memory\n", myname);
return (-1);
}
if (!(procdir = opendir (PROCFS)))
{
(void) fprintf (stderr, "Unable to open %s\n", PROCFS);
return (-1);
}
if (chdir (PROCFS))
{ /* handy for later on when we're reading it */
(void) fprintf (stderr, "Unable to chdir to %s\n", PROCFS);
return (-1);
}
kmet_init();
/* all done! */
return (0);
}
char *
format_header (char *uname_field)
{
register char *ptr;
ptr = header + UNAME_START;
while (*uname_field != '\0')
*ptr++ = *uname_field++;
return (header);
}
void
get_system_info (struct system_info *si)
{
long avenrun[3];
long mem;
static time_t cp_old[CPUSTATES];
static time_t cp_diff[CPUSTATES]; /* for cpu state percentages */
register int i;
static long swap_total;
static long swap_free;
int new_states[CPUSTATES];
get_cpustates(new_states);
/* convert cp_time counts to percentages */
(void) percentages (CPUSTATES, cpu_states, new_states, cp_old, cp_diff);
si->last_pid = -1;
/* get mpid -- process id of last process
* svr5 is nextpid - next pid to be assigned (already incremented)
*/
(void) getkval (mpid_offset, &(si->last_pid), sizeof (si->last_pid),
"nextpid");
(si->last_pid)--; /* so we shld decrement for display */
/* get load average array */
(void) getkval (avenrun_offset, (int *) avenrun, sizeof (avenrun), "avenrun");
/* convert load averages to doubles */
for (i = 0; i < 3; i++)
si->load_avg[i] = loaddouble(avenrun[i]);
mem = sysconf(_SC_TOTAL_MEMORY); /* physical mem */
memory_stats[0] = pagetok (mem);
mem = kmet_get_freemem(); /* free mem */
memory_stats[2] = pagetok (mem);
/* mem = sysconf(_SC_GENERAL_MEMORY); */
memory_stats[1] = memory_stats[0] - memory_stats[2]; /* active */
get_swapinfo(&swap_total, &swap_free);
memory_stats[3] = pagetok(swap_total - swap_free);
memory_stats[4] = pagetok(swap_free);
/* set arrays and strings */
si->cpustates = cpu_states;
si->memory = memory_stats;
}
static struct handle handle;
caddr_t
get_process_info (
struct system_info *si,
struct process_select *sel,
int idx)
{
register int i;
register int total_procs;
register int active_procs;
register struct prpsinfo **prefp;
register struct prpsinfo *pp;
/* these are copied out of sel for speed */
int show_idle;
int show_system;
int show_uid;
/* Get current number of processes */
/* read all the proc structures */
getptable (pbase);
/* 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;
nproc = kmet_get_nproc();
/* count up process states and get pointers to interesting procs */
total_procs = 0;
active_procs = 0;
(void) memset (process_states, 0, sizeof (process_states));
prefp = pref;
for (pp = pbase, i = 0; i < nproc; pp++, i++)
{
/*
* Place pointers to each valid proc structure in pref[].
* Process slots that are actually in use have a non-zero
* status field. Processes with PR_ISSYS set are system
* processes---these get ignored unless show_sysprocs is set.
*/
if ((pp->pr_state >= SONPROC && pp->pr_state <= SIDL) &&
(show_system || ((pp->pr_flag & PR_ISSYS) == 0)))
{
total_procs++;
process_states[pp->pr_state]++;
if ((!ZOMBIE(pp)) &&
(show_idle || (pp->pr_state == SRUN) || (pp->pr_state == SONPROC)) &&
(!show_uid || pp->pr_uid == (uid_t) sel->uid))
{
*prefp++ = pp;
active_procs++;
}
if (ZOMBIE(pp))
process_states[sZOMB]++; /* invented */
}
}
/* if requested, sort the "interesting" processes */
qsort ((char *) pref, active_procs, sizeof (struct prpsinfo *),
proc_compares[idx]);
/* remember active and total counts */
si->p_total = total_procs;
si->P_ACTIVE = active_procs;
/* pass back a handle */
handle.next_proc = pref;
handle.remaining = active_procs;
return ((caddr_t) & handle);
}
/*
* cpu percentage calculation is as fm ps.c
* seems to be ratio of (sys+user time used)/(elapsed time)
* i.e percent of cpu utilised when on cpu
*/
static double percent_cpu( struct prpsinfo *pp)
{
static time_t tim = 0L;
time_t starttime;
time_t ctime;
time_t etime;
/* if (tim == 0L) */
tim = time((time_t *) 0);
starttime = pp->pr_start.tv_sec;
if (pp->pr_start.tv_nsec > 500000000)
starttime++;
etime = (tim - starttime);
ctime = pp->pr_time.tv_sec;
if (pp->pr_time.tv_nsec > 500000000)
ctime++;
if (etime)
{
/* return (float)(ctime * 100) / (unsigned)etime; */
/* this was ocasionally giving vals >100 for some
* unknown reason so the below normalises it
*/
double pct;
pct = (float)(ctime * 100) / (unsigned)etime;
return (pct < 100.0) ? pct : 100.00;
}
return 0.00;
}
char fmt[MAX_COLS]; /* static area where result is built */
char *
format_next_process (
caddr_t handle,
char *(*get_userid) ())
{
register struct prpsinfo *pp;
struct handle *hp;
register long cputime;
register double pctcpu;
/* find and remember the next proc structure */
hp = (struct handle *) handle;
pp = *(hp->next_proc++);
hp->remaining--;
/* get the cpu usage and calculate the cpu percentages */
cputime = pp->pr_time.tv_sec;
pctcpu = percent_cpu(pp);
/* format this entry */
(void) sprintf (fmt,
Proc_format,
pp->pr_pid,
(*get_userid) (pp->pr_uid),
pp->pr_pri,
#ifdef SHOW_NICE
pp->pr_nice,
#else
(u_short)pp->pr_nlwp < 999 ? (u_short)pp->pr_nlwp : 999,
#endif
format_k(SIZE_K(pp)),
format_k(RSS_K(pp)),
(ZOMBIE(pp)) ? state_abbrev[sZOMB]
: state_abbrev[pp->pr_state],
format_time(cputime),
/* 100.0 * */ pctcpu,
printable(pp->pr_fname));
/* 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 (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_value == 0)
{
/* this one wasn't found */
(void) 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).
*
*/
int
getkval (
unsigned long offset,
int *ptr,
int size,
char *refstr)
{
if (lseek (kmem, (long) offset, 0) == -1)
{
if (*refstr == '!')
refstr++;
(void) fprintf (stderr, "%s: lseek to %s: %s\n",
myname, refstr, sys_errlist[errno]);
quit (22);
}
if (read (kmem, (char *) ptr, size) == -1)
if (*refstr == '!')
/* we lost the race with the kernel, process isn't in memory */
return (0);
else
{
(void) fprintf (stderr, "%s: reading %s: %s\n",
myname, refstr, sys_errlist[errno]);
quit (23);
}
return (1);
}
/* ----------------- comparison routines for qsort ---------------- */
/* First, the possible comparison keys. These are defined in such a way
that they can be merely listed in the source code to define the actual
desired ordering.
*/
#define ORDERKEY_PCTCPU if (dresult = percent_cpu (p2) - percent_cpu (p1),\
(result = dresult > 0.0 ? 1 : \
dresult < 0.0 ? -1 : 0) == 0)
#define ORDERKEY_CPTICKS if ((result = p2->pr_time.tv_sec - p1->pr_time.tv_sec) == 0)
#define ORDERKEY_STATE if ((result = (long) (sorted_state[p2->pr_state] - \
sorted_state[p1->pr_state])) == 0)
#define ORDERKEY_PRIO if ((result = p2->pr_pri - p1->pr_pri) == 0)
#define ORDERKEY_RSSIZE if ((result = p2->pr_rssize - p1->pr_rssize) == 0)
#define ORDERKEY_MEM if ((result = (p2->pr_size - p1->pr_size)) == 0)
#define ORDERKEY_PID if ((result = (p2->pr_pid - p1->pr_pid)) == 0)
#define ORDERKEY_UID if ((result = (p2->pr_uid - p1->pr_uid)) == 0)
#define ORDERKEY_RPID if ((result = (p1->pr_pid - p2->pr_pid)) == 0)
#define ORDERKEY_RUID if ((result = (p1->pr_uid - p2->pr_uid)) == 0)
/* states enum {SONPROC, SRUN, SSLEEP, SSTOP, SIDL} */
unsigned char sorted_state[] =
{
7, /* onproc */
6, /* run */
5, /* sleep */
4, /* stop */
3, /* idle */
2, /* zombie */
0, /* unused */
0 /* unused */
};
#if 0
/*
* proc_compare - original singleton 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.
*/
/* default comparison rtn */
int
original_proc_compare (
struct prpsinfo **pp1,
struct prpsinfo **pp2)
{
register struct prpsinfo *p1;
register struct prpsinfo *p2;
register long result;
double dresult;
/* remove one level of indirection */
p1 = *pp1;
p2 = *pp2;
/* compare percent cpu (pctcpu) */
dresult = percent_cpu(p2) - percent_cpu (p1);
result = dresult > 0.0 ? 1 :
dresult < 0.0 ? -1 : 0;
if (result)
{
/* use cpticks to break the tie */
if ((result = p2->pr_time.tv_sec - p1->pr_time.tv_sec) == 0)
{
/* use process state to break the tie */
if ((result = (long) (sorted_state[p2->pr_state] -
sorted_state[p1->pr_state])) == 0)
{
/* use priority to break the tie */
if ((result = p2->pr_pri - p1->pr_pri) == 0)
{
/* use resident set size (rssize) to break the tie */
if ((result = p2->pr_rssize - p1->pr_rssize) == 0)
{
/* use total memory to break the tie */
result = (p2->pr_size - p1->pr_size);
}
}
}
}
}
return (result);
}
#endif /* original comparison rtn */
/* compare_state - comparison function for sorting by state,pri,time,size */
int
proc_compare (
struct prpsinfo **pp1,
struct prpsinfo **pp2)
{
register struct prpsinfo *p1;
register struct prpsinfo *p2;
register long result;
double dresult;
/* remove one level of indirection */
p1 = *pp1;
p2 = *pp2;
ORDERKEY_STATE
ORDERKEY_PRIO
ORDERKEY_CPTICKS
ORDERKEY_RSSIZE
ORDERKEY_MEM
ORDERKEY_PCTCPU
;
return (result);
}
/* compare_cpu - the comparison function for sorting by cpu % (deflt) */
int
compare_cpu (
struct prpsinfo **pp1,
struct prpsinfo **pp2)
{
register struct prpsinfo *p1;
register struct prpsinfo *p2;
register long result;
double dresult;
/* remove one level of indirection */
p1 = *pp1;
p2 = *pp2;
ORDERKEY_PCTCPU
ORDERKEY_CPTICKS
ORDERKEY_STATE
ORDERKEY_PRIO
ORDERKEY_RSSIZE
ORDERKEY_MEM
;
return (result);
}
/* compare_size - the comparison function for sorting by total memory usage */
int
compare_size (
struct prpsinfo **pp1,
struct prpsinfo **pp2)
{
register struct prpsinfo *p1;
register struct prpsinfo *p2;
register long result;
double dresult;
/* remove one level of indirection */
p1 = *pp1;
p2 = *pp2;
ORDERKEY_MEM
ORDERKEY_RSSIZE
ORDERKEY_PCTCPU
ORDERKEY_CPTICKS
ORDERKEY_STATE
ORDERKEY_PRIO
;
return (result);
}
/* compare_res - the comparison function for sorting by resident set size */
int
compare_res (
struct prpsinfo **pp1,
struct prpsinfo **pp2)
{
register struct prpsinfo *p1;
register struct prpsinfo *p2;
register long result;
double dresult;
/* remove one level of indirection */
p1 = *pp1;
p2 = *pp2;
ORDERKEY_RSSIZE
ORDERKEY_MEM
ORDERKEY_PCTCPU
ORDERKEY_CPTICKS
ORDERKEY_STATE
ORDERKEY_PRIO
;
return (result);
}
/* compare_time - the comparison function for sorting by total cpu time */
int
compare_time (
struct prpsinfo **pp1,
struct prpsinfo **pp2)
{
register struct prpsinfo *p1;
register struct prpsinfo *p2;
register long result;
double dresult;
/* remove one level of indirection */
p1 = *pp1;
p2 = *pp2;
ORDERKEY_CPTICKS
ORDERKEY_PCTCPU
ORDERKEY_STATE
ORDERKEY_PRIO
ORDERKEY_MEM
ORDERKEY_RSSIZE
;
return (result);
}
/* compare_pid - the comparison function for sorting by pid */
int
compare_pid (
struct prpsinfo **pp1,
struct prpsinfo **pp2)
{
register struct prpsinfo *p1;
register struct prpsinfo *p2;
register long result;
double dresult;
/* remove one level of indirection */
p1 = *pp1;
p2 = *pp2;
ORDERKEY_PID
ORDERKEY_CPTICKS
ORDERKEY_PCTCPU
ORDERKEY_STATE
ORDERKEY_PRIO
ORDERKEY_MEM
ORDERKEY_RSSIZE
;
return (result);
}
/* compare_uid - the comparison function for sorting by user ID */
int
compare_uid (
struct prpsinfo **pp1,
struct prpsinfo **pp2)
{
register struct prpsinfo *p1;
register struct prpsinfo *p2;
register long result;
double dresult;
/* remove one level of indirection */
p1 = *pp1;
p2 = *pp2;
ORDERKEY_UID
ORDERKEY_CPTICKS
ORDERKEY_PCTCPU
ORDERKEY_STATE
ORDERKEY_PRIO
ORDERKEY_MEM
ORDERKEY_RSSIZE
;
return (result);
}
/* compare_rpid - the comparison function for sorting by pid ascending */
int
compare_rpid (
struct prpsinfo **pp1,
struct prpsinfo **pp2)
{
register struct prpsinfo *p1;
register struct prpsinfo *p2;
register long result;
double dresult;
/* remove one level of indirection */
p1 = *pp1;
p2 = *pp2;
ORDERKEY_RPID
ORDERKEY_CPTICKS
ORDERKEY_PCTCPU
ORDERKEY_STATE
ORDERKEY_PRIO
ORDERKEY_MEM
ORDERKEY_RSSIZE
;
return (result);
}
/* compare_uid - the comparison function for sorting by user ID ascending */
int
compare_ruid (
struct prpsinfo **pp1,
struct prpsinfo **pp2)
{
register struct prpsinfo *p1;
register struct prpsinfo *p2;
register long result;
double dresult;
/* remove one level of indirection */
p1 = *pp1;
p2 = *pp2;
ORDERKEY_RUID
ORDERKEY_CPTICKS
ORDERKEY_PCTCPU
ORDERKEY_STATE
ORDERKEY_PRIO
ORDERKEY_MEM
ORDERKEY_RSSIZE
;
return (result);
}
/* ---------------- helper rtns ---------------- */
/*
* get process table
*/
void
getptable (struct prpsinfo *baseptr)
{
struct prpsinfo *currproc; /* pointer to current proc structure */
int numprocs = 0;
struct dirent *direntp;
currproc = baseptr;
for (rewinddir (procdir); direntp = readdir (procdir);)
{
int fd;
char buf[30];
sprintf(buf,"%s/psinfo", direntp->d_name);
if ((fd = open (buf, O_RDONLY)) < 0)
continue;
if (read(fd, currproc, sizeof(psinfo_t)) != sizeof(psinfo_t))
{
(void) close (fd);
continue;
}
numprocs++;
currproc++;
(void) close (fd);
/* Atypical place for growth */
if (numprocs >= maxprocs)
{
reallocproc(2 * numprocs);
currproc = (struct prpsinfo *)
((char *)baseptr + sizeof(psinfo_t) * numprocs);
}
}
if (nproc != numprocs)
nproc = numprocs;
}
/* return the owner of the specified process, for use in commands.c as we're
running setuid root */
int
proc_owner (int pid)
{
register struct prpsinfo *p;
int i;
for (i = 0, p = pbase; i < nproc; i++, p++)
if (p->pr_pid == (pid_t)pid)
return ((int)(p->pr_uid));
return (-1);
}
int
setpriority (int dummy, int who, int niceval)
{
int scale;
int prio;
pcinfo_t pcinfo;
pcparms_t pcparms;
tsparms_t *tsparms;
strcpy (pcinfo.pc_clname, "TS");
if (priocntl (0, 0, PC_GETCID, (caddr_t) & pcinfo) == -1)
return (-1);
prio = niceval;
if (prio > PRIO_MAX)
prio = PRIO_MAX;
else if (prio < PRIO_MIN)
prio = PRIO_MIN;
tsparms = (tsparms_t *) pcparms.pc_clparms;
scale = ((tsinfo_t *) pcinfo.pc_clinfo)->ts_maxupri;
tsparms->ts_uprilim = tsparms->ts_upri = -(scale * prio) / 20;
pcparms.pc_cid = pcinfo.pc_cid;
if (priocntl (P_PID, who, PC_SETPARMS, (caddr_t) & pcparms) == -1)
return (-1);
return (0);
}
get_swapinfo(long *total, long *fr)
{
register int cnt, i;
register long t, f;
struct swaptable *swt;
struct swapent *ste;
static char path[256];
/* get total number of swap entries */
cnt = swapctl(SC_GETNSWP, 0);
/* allocate enough space to hold count + n swapents */
swt = (struct swaptable *)malloc(sizeof(int) +
cnt * sizeof(struct swapent));
if (swt == NULL)
{
*total = 0;
*fr = 0;
return;
}
swt->swt_n = cnt;
/* fill in ste_path pointers: we don't care about the paths, so we point
them all to the same buffer */
ste = &(swt->swt_ent[0]);
i = cnt;
while (--i >= 0)
{
ste++->ste_path = path;
}
/* grab all swap info */
swapctl(SC_LIST, swt);
/* walk thru the structs and sum up the fields */
t = f = 0;
ste = &(swt->swt_ent[0]);
i = cnt;
while (--i >= 0)
{
/* dont count slots being deleted */
if (!(ste->ste_flags & ST_INDEL) )
{
t += ste->ste_pages;
f += ste->ste_free;
}
ste++;
}
/* fill in the results */
*total = t;
*fr = f;
free(swt);
}
/*
* When we reach a proc limit, we need to realloc the stuff.
*/
static void reallocproc(int n)
{
int bytes;
struct oldproc *op, *endbase;
if (n < maxprocs)
return;
maxprocs = n;
/* allocate space for proc structure array and array of pointers */
bytes = maxprocs * sizeof(psinfo_t) ;
pbase = (struct prpsinfo *) realloc(pbase, bytes);
pref = (struct prpsinfo **) realloc(pref,
maxprocs * sizeof(struct prpsinfo *));
/* Just in case ... */
if (pbase == (struct prpsinfo *) NULL || pref == (struct prpsinfo **) NULL)
{
fprintf (stderr, "%s: can't allocate sufficient memory\n", myname);
quit(1);
}
}
/* ---------------------------------------------------------------- */
/* Access kernel Metrics
* SVR5 uses metreg inteface to Kernel statistics (metrics)
* see /usr/include/mas.h, /usr/include/metreg.h
*/
#include <sys/mman.h>
#include <sys/dl.h>
#include <mas.h>
#include <metreg.h>
static int md; /* metric descriptor handle */
static uint32 ncpu; /* number of processors in system */
/* fwd dcls */
static uint32 kmet_get_cpu( int type, char *desc);
static void kmet_verify(
uint32 md, metid_t id, units_t units, type_t mettype,
uint32 metsz, uint32 nobj, uint32 nlocs, resource_t res_id,
uint32 ressz ) ;
static int get_cpustates(int *new)
{
new[0] = (int)kmet_get_cpu( MPC_CPU_IDLE, "idle");
new[1] = (int)kmet_get_cpu( MPC_CPU_USR, "usr");
new[2] = (int)kmet_get_cpu( MPC_CPU_SYS, "sys");
new[3] = (int)kmet_get_cpu( MPC_CPU_WIO, "wio");
}
/* initialises kernel metrics access and gets #cpus */
static int kmet_init()
{
uint32 *ncpu_p;
/* open (and map in) the metric access file and assoc data structures */
if( ( md = mas_open( MAS_FILE, MAS_MMAP_ACCESS ) ) < 0 )
{
(void)fprintf(stderr,"mas_open failed\n");
mas_perror();
quit(10);
}
/* verify the NCPU metric is everything we expect */
kmet_verify(md, NCPU, CPUS, CONFIGURABLE, sizeof(short),
1, 1, MAS_SYSTEM, sizeof(uint32) );
/* get the number of cpu's on the system */
if( (ncpu_p = (uint32 *)mas_get_met( md, NCPU, 0 )) == NULL )
{
(void)fprintf(stderr,"mas_get_met of ncpu failed\n");
mas_perror();
quit(12);
}
ncpu = (uint32)(*(short *)ncpu_p);
/* check that MPC_CPU_IDLE is of the form we expect
* ( paranoically we should check the rest as well but ... )
*/
kmet_verify( md, MPC_CPU_IDLE, TIX, PROFILE, sizeof(uint32),
1, ncpu, NCPU, sizeof(short) );
kmet_verify( md, PROCUSE, PROCESSES, COUNT, sizeof(uint32),
1, 1, MAS_SYSTEM, sizeof(uint32) );
nproc = kmet_get_nproc();
return 0;
}
/* done with kernel metrics access */
static int
kmet_done()
{
if ( mas_close( md ) < 0 )
{
(void)fprintf(stderr,"mas_close failed\n");
mas_perror();
quit(14);
}
}
static uint32
kmet_get_cpu( int type, char *desc)
{
int i;
uint32 r=0, rtot=0 ;
for (i=0; i <ncpu; i++)
{
r=*(uint32 *)mas_get_met( md, (metid_t)type, 0 );
if ( !r)
{
(void)fprintf(stderr,"mas_get_met of %s failed\n", desc);
mas_perror();
quit(12);
}
rtot += r; /* sum them for multi cpus */
}
return rtot /* /ncpu */ ;
}
static int
kmet_get_freemem()
{
dl_t *fm_p, fm, fmc, denom;
time_t td1;
static time_t td0;
static dl_t fm_old;
td1 = time(NULL);
if ((fm_p = (dl_t *)mas_get_met( md, FREEMEM, 0 )) == NULL )
{
(void)fprintf(stderr,"mas_get_met of freemem failed\n");
mas_perror();
quit(12);
}
fm = *fm_p;
denom.dl_hop = 0;
denom.dl_lop = (long) (td1 - td0);
td0 = td1;
/* calculate the freemem difference divided by the time diff
* giving the freemem in that time sample
* (new - old) / (time_between_samples)
*/
fmc = lsub(fm, fm_old);
fm_old = fm;
fmc = ldivide(fmc, denom);
return fmc.dl_lop;
}
/*
* return # of processes currently executing on system
*/
static int
kmet_get_nproc()
{
uint32 *p;
if ((p = (uint32 *)mas_get_met( md, PROCUSE, 0 )) == NULL )
{
(void)fprintf(stderr,"mas_get_met of procuse failed\n");
mas_perror();
quit(11);
}
nproc = (int)*p;
}
/*
* Function: kmet_verify
* renamed from mas_usrtime example verify_met() fm Doug Souders
*
* Description: Verify the registration data associated with this metric
* match what are expected. Cautious consumer applications
* should do this sort of verification before using metrics.
*/
static void
kmet_verify(
uint32 md, /* metric descriptor */
metid_t id, /* metric id number */
units_t units, /* expected units of metric */
type_t mettype, /* expected type of metric */
uint32 metsz, /* expected object size of metric */
uint32 nobj, /* expected number of array elements */
uint32 nlocs, /* expected number of instances */
resource_t res_id, /* expected resource id number */
uint32 ressz /* expected resource object size */
)
{
char *name; /* the name of the metric */
units_t *units_p; /* the units of the metric */
type_t *mettype_p; /* type field of the metric */
uint32 *objsz_p; /* size of each element in met */
uint32 *nobj_p; /* num of elements >1 then array*/
uint32 *nlocs_p; /* total number of instances */
uint32 *status_p; /* status word (update|avail) */
resource_t *resource_p; /* the resource list of the met */
uint32 *resval_p; /* pointer to resource */
uint32 *ressz_p; /* size of the resource met */
if (!(name = mas_get_met_name( md, id )))
{
(void)fprintf(stderr,"mas_get_met_name failed\n");
mas_perror();
quit(11);
}
if (!(status_p = mas_get_met_status( md, id )))
{
(void)fprintf(stderr,"mas_get_met_status of %s failed\n",
name );
mas_perror();
quit(11);
}
if ( *status_p != MAS_AVAILABLE )
{
(void)fprintf(stderr,"unexpected status word for %s\n"
"- expected %u got %u\n",
name, MAS_AVAILABLE, *status_p );
quit(11);
}
if (!(units_p = mas_get_met_units( md, id )))
{
(void)fprintf(stderr,"mas_get_met_units of %s failed\n",
name );
mas_perror();
quit(11);
}
if (units != *units_p )
{
(void)fprintf(stderr,"unexpected units for %s\n"
"- expected %u got %u\n",
name, units, *units_p );
quit(11);
}
if (!(mettype_p = mas_get_met_type( md, id )))
{
(void)fprintf(stderr,"mas_get_met_type of %s failed\n",
name );
mas_perror();
quit(11);
}
if (mettype != *mettype_p )
{
(void)fprintf(stderr,"unexpected metric type for %s\n"
"- expected %u got %u\n",
name, mettype , *mettype_p );
quit(11);
}
if (!(objsz_p = mas_get_met_objsz( md, id )))
{
(void)fprintf(stderr,"mas_get_met_objsz of %s failed\n", name );
mas_perror();
quit(11);
}
if (*objsz_p != metsz )
{
(void)fprintf(stderr,"unexpected object size for %s\n"
"- expected %u got %u\n",
name, metsz, *objsz_p );
quit(11);
}
if (!(nobj_p = mas_get_met_nobj( md, id )))
{
(void)fprintf(stderr,"mas_get_met_nobj of %s failed\n", name );
mas_perror();
quit(11);
}
if (nobj != *nobj_p )
{
(void)fprintf(stderr,"unexpected number of objects for %s\n"
"- expected %u got %u\n",
name, nobj, *nobj_p );
quit(11);
}
/* get the number of instances that libmas thinks it knows about */
if (!(nlocs_p = mas_get_met_nlocs( md, id )))
{
(void)fprintf(stderr,"mas_get_met_nlocs of %s failed\n", name );
mas_perror();
quit(11);
}
if (nlocs != *nlocs_p )
{
(void)fprintf(stderr,"unexpected number of instances for %s"
" - expected %u got %u\n",
name, nlocs, *nlocs_p );
quit(11);
}
/* get the resource list for the metric */
if (!(resource_p = mas_get_met_resources( md, id )))
{
(void)fprintf(stderr,"mas_get_met_resources of %s failed\n", name );
mas_perror();
quit(11);
}
if (*resource_p != res_id )
{
(void)fprintf(stderr,"unexpected resource id for %s\n"
"- expected %u got %u\n",
name, res_id, *resource_p);
quit(11);
}
/* get the size of the resource */
if (!(ressz_p = mas_get_met_objsz( md, (metid_t)(*resource_p) )))
{
(void)fprintf(stderr,"mas_get_met_objsz of resource failed\n");
mas_perror();
quit(11);
}
if (*ressz_p != ressz )
{
(void)fprintf(stderr,"unexpected resource size for %s\n"
"- expected %u got %u\n",
name, ressz, *ressz_p );
quit(11);
}
/*
* get the address of the resource
*/
if (!(resval_p = (uint32 *)mas_get_met( md, *resource_p, 0 )))
{
(void)fprintf(stderr,"mas_get_met of resource failed\n");
mas_perror();
quit(11);
}
if (ressz == sizeof( short ) )
{
if( (uint32)(*(short *)resval_p) != nlocs )
{
(void)fprintf(stderr,"unexpected resource value for %s\n"
"- expected %u got %u\n",
name, nlocs, (uint32)(*(short *)resval_p) );
quit(11);
}
}
else
{ /* assume size of uint32 */
if (*resval_p != nlocs )
{
(void)fprintf(stderr,"unexpected resource value for %s\n"
"- expected %u got %u\n",
name, nlocs, *resval_p );
quit(11);
}
}
return;
}
Reference in New Issue View Git Blame Copy Permalink