m_dcosx.c

unix系统下top命令的源代码

/*
 * top - a top users display for Unix
 *
 * SYNOPSIS:  For Pyramid DC/OSX
 *
 * DESCRIPTION:
 *      DC/OSX for MISserver
 *      DC/OSX for Nile
 *
 * LIBS:  -lelf -lext
 *
 * AUTHORS:  Phillip Wu         <[e-mail]>
 */

#include "top.h"
#include "machine.h"
#include "utils.h"
#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/tuneable.h>
#include <sys/statis.h>
#include <sys/proc.h>
#include <sys/procfs.h>
#include <sys/sysinfo.h>
#include <sys/immu.h>
#include <sys/sysmacros.h>
#include <sys/vmmeter.h>
#include <vm/anon.h>
#include <sys/priocntl.h>
#include <sys/rtpriocntl.h>
#include <sys/tspriocntl.h>
#include <sys/procset.h>
#include <sys/var.h>

#define UNIX "/stand/unix"
#define KMEM "/dev/kmem"
#define PROCFS "/proc"
#define MAXCPU 24
#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 percent_cpu(x) ((double)(x)->pr_cpu / FSCALE)
#define weighted_cpu(pct, pp) ( ((pp)->pr_time.tv_sec) == 0 ? 0.0 : \
        ((pp)->pr_cpu) / ((pp)->pr_time.tv_sec) )
#define pagetok(size) ctob(size) >> LOG1024

/* definitions for the index in the nlist array */
#define X_AVENRUN	0
#define X_MPID		1
#define X_V		2
#define X_NPROC		3
#define X_PHYSMEM	4

static struct nlist nlst[] =
{
  {"avenrun"},			/* 0 */
  {"mpid"},			/* 1 */
  {"v"},			/* 2 */
  {"nproc"},			/* 3 */
  {"physmem"},			/* 4 */
  {NULL}
};

static unsigned long avenrun_offset;
static unsigned long mpid_offset;
static unsigned long nproc_offset;
static unsigned long physmem_offset;

/* 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[] =
"  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 %3d.0%% %5.2f%% %.16s"

char *state_abbrev[] =
{"", "sleep", "run", "zombie", "stop", "start", "cpu", "swap"};

int process_states[8];
char *procstatenames[] =
{
  "", " sleeping, ", " running, ", " zombie, ", " stopped, ",
  " starting, ", " on cpu, ", " swapped, ",
  NULL
};

int cpu_states[CPUSTATES];
char *cpustatenames[] =
{"idle", "user", "kernel", "wait", "swap", NULL};

/* these are for detailing the memory statistics */

int memory_stats[5];
char *memorynames[] =
{"K real, ", "K active, ", "K free, ", "K swap, ", "K free swap", NULL};

static int kmem = -1;
static int nproc;
static int bytes;
static struct prpsinfo *pbase;
static struct prpsinfo **pref;
static DIR *xprocdir;

/* useful externals */
extern int errno;
extern char *sys_errlist[];
extern char *myname;
extern int check_nlist ();
extern int getkval ();
extern void perror ();
extern void getptable ();
extern void quit ();
extern int nlist ();

int
machine_init (struct statics *statics)
  {
    static struct var v;

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

    /* 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);
      }

    /* 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;

    /* stash away certain offsets for later use */
    mpid_offset = nlst[X_MPID].n_value;
    nproc_offset = nlst[X_NPROC].n_value;
    avenrun_offset = nlst[X_AVENRUN].n_value;
    physmem_offset = nlst[X_PHYSMEM].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 *));

    /* 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 (!(xprocdir = 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);
      }

    /* 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);
}

static int get_sysinfo_firsttime=0;
static int physmem;
static size_t   sysinfo_size, vmtotal_size, minfo_size;
static int ncpu;
void
get_system_info (struct system_info *si)
{
  long avenrun[3];
  static struct sysinfo sysinfo[MAXCPU];
  static struct vmtotal vmtotal;
  static struct minfo minfo;
  static time_t cp_time[CPUSTATES];
  static time_t cp_old[CPUSTATES];
  static time_t cp_diff[CPUSTATES];	/* for cpu state percentages */
  register int i, j, k, cpu;

  /* Get number of cpus and size of system information data structure
     but only first time */
  if( ! get_sysinfo_firsttime )
  {
     get_sysinfo_firsttime=1;
     if (statis("ncpu", STATIS_GET, &ncpu, sizeof(ncpu))== -1)
     {
      perror("failed to get sysinfo");
      exit(1);
     }
     if (statis("sysinfo", STATIS_SIZ, &sysinfo_size, sizeof(sysinfo_size))==-1)
     {
      perror("failed to get sysinfo");
      exit(1);
     }
     if (statis("vm total", STATIS_SIZ, &vmtotal_size, sizeof(vmtotal_size))==-1)
     {
      perror("failed to get vm total");
      exit(1);
     }
     if (statis("minfo", STATIS_SIZ, &minfo_size, sizeof(minfo_size))==-1)
     {
      perror("failed to get minfo");
      exit(1);
     }
     sysinfo_size *= ncpu;
    (void) getkval (physmem_offset, (int *)(&physmem), sizeof(int), "physmem");
    physmem=physmem<<2;
    memory_stats[0] = (physmem/1024)*1000;
   }
 
  /* Get system information  data structure from the kernel - one per cpu */
  if( statis("sysinfo", STATIS_GET,  sysinfo, sysinfo_size) != sysinfo_size )
  {
    perror("failed to get sysinfo");
    exit(1);
  }

  for( j = 0; j < CPUSTATES; j++)
  {
    cp_time[j] = 0;
    for( cpu = 1; cpu < ncpu; cpu++)
      cp_time[j] += sysinfo[cpu].cpu[j];
    cp_time[j] /= ncpu;
   }

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

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

  /* 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]);

  /* get vmmeter and minfo */
  if( statis("vm total", STATIS_GET,  &vmtotal, vmtotal_size) != vmtotal_size )
  {
    perror("failed to get vm total");
    exit(1);
  }
  if( statis("minfo", STATIS_GET,  &minfo, minfo_size) != minfo_size )
  {
    perror("failed to get minfo");
    exit(1);
  }
  /* convert memory stats to Kbytes */
  memory_stats[1] = pagetok (vmtotal.t_arm);
  memory_stats[2] = pagetok (vmtotal.t_free);
  memory_stats[3] = pagetok (minfo.swap);
  memory_stats[4] = pagetok (minfo.freeswap);

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

static struct handle handle;

caddr_t