V9/cmd/w.c
static char *sccsid = "@(#)w.c 4.4 (Berkeley) 6/5/81";
/*
* w - print system status (who and what)
*
* This program is similar to the systat command on Tenex/Tops 10/20
* It needs read permission on /dev/mem, /dev/kmem, and /dev/drum.
*/
#include <sys/param.h>
#include <nlist.h>
#include <stdio.h>
#include <ctype.h>
#include <utmp.h>
#include <time.h>
#include <sys/stat.h>
#include <sys/dir.h>
#include <sys/user.h>
#include <sys/proc.h>
#include <machine/pte.h>
#include <sys/vm.h>
#define NMAX sizeof(utmp.ut_name)
#define LMAX sizeof(utmp.ut_line)
#define ARGWIDTH 24 /* # chars left on 80 col crt for args */
struct pr {
short w_pid; /* proc.p_pid */
char w_flag; /* proc.p_flag */
short w_size; /* proc.p_size */
float w_pctcpu; /* proc.p_pctcpu */
long w_ptime; /* proc.p_time */
long w_rss; /* proc.p_rssize */
long w_seekaddr; /* where to find args */
long w_lastpg; /* disk address of stack */
int w_igintr; /* INTR+3*QUIT, 0=die, 1=ign, 2=catch */
time_t w_time; /* CPU time used by this process */
time_t w_ctime; /* CPU time used by children */
ino_t w_tty; /* tty inode of process */
char w_comm[15]; /* user.u_comm, null terminated */
char w_args[ARGWIDTH+1]; /* args if interesting process */
} *pr;
struct find {
struct find *f_parent; /* parent pointer */
ino_t f_tty; /* tty for this process */
struct pr *f_pr; /* pointer to pr */
} *f;
int nproc;
struct nlist nl[] = {
{ "_proc" },
#define X_PROC 0
{ "_swapdev" },
#define X_SWAPDEV 1
{ "_Usrptmap" },
#define X_USRPTMA 2
{ "_usrpt" },
#define X_USRPT 3
{ "_nswap" },
#define X_NSWAP 4
{ "_avenrun" },
#define X_AVENRUN 5
{ "_bootime" },
#define X_BOOTIME 6
{ "_ecmx" },
#define X_ECMX 7
{ "_nproc" },
#define X_NPROC 8
{ 0 },
};
FILE *ps;
FILE *ut;
FILE *bootfd;
int kmem;
int mem;
int swap; /* /dev/kmem, mem, and swap */
int nswap;
int ecmx;
ino_t tty;
char doing[520]; /* process attached to terminal */
float avenrun[3];
struct proc *aproc;
#define DIV60(t) ((t+30)/60) /* x/60 rounded */
#define TTYEQ (tty == pr[i].w_tty)
#define IGINT (1+3*1) /* ignoring both SIGINT & SIGQUIT */
char *getargs();
char *fread();
char *ctime();
char *strrchr();
FILE *popen();
struct tm *localtime();
int debug; /* true if -d flag: debugging output */
int header = 1; /* true if -h flag: don't print heading */
int lflag = 1; /* true if -l flag: long style output */
int login; /* true if invoked as login shell */
int idle; /* number of minutes user is idle */
int nusers; /* number of users logged in now */
char * sel_user; /* login of particular user selected */
char firstchar; /* first char of name of prog invoked as */
time_t jobtime; /* total cpu time visible */
double percentcpu; /* percentage of cpu */
int pagesused; /* total number of pages */
int pagesresident; /* pages in memory */
time_t now; /* the current time of day */
struct tm *nowt; /* current time as time struct */
time_t bootime, uptime; /* time of last reboot & elapsed time since */
int np; /* number of processes currently active */
struct utmp utmp;
struct proc mproc;
struct user up;
char fill[512];
main(argc, argv)
char **argv;
{
int days, hrs, mins;
register int i, j;
char *cp;
register int curpid, empty;
char obuf[BUFSIZ];
setbuf(stdout, obuf);
login = (argv[0][0] == '-');
cp = strrchr(argv[0], '/');
firstchar = login ? argv[0][1] : (cp==0) ? argv[0][0] : cp[1];
cp = argv[0]; /* for Usage */
while (argc > 1) {
if (argv[1][0] == '-') {
for (i=1; argv[1][i]; i++) {
switch(argv[1][i]) {
case 'd':
debug++;
break;
case 'h':
header = 0;
break;
case 'l':
lflag++;
break;
case 's':
lflag = 0;
break;
case 'u':
case 'w':
firstchar = argv[1][i];
break;
default:
printf("Bad flag %s\n", argv[1]);
exit(1);
}
}
} else {
if (!isalnum(argv[1][0]) || argc > 2) {
printf("Usage: %s [ -hlsuw ] [ user ]\n", cp);
exit(1);
} else
sel_user = argv[1];
}
argc--; argv++;
}
if ((kmem = open("/dev/kmem", 0)) < 0) {
fprintf(stderr, "No kmem\n");
exit(1);
}
nlist("/unix", nl);
if (nl[0].n_type==0) {
fprintf(stderr, "No namelist\n");
exit(1);
}
if (firstchar != 'u')
readpr();
ut = fopen("/etc/utmp","r");
if (header) {
/* Print time of day */
time(&now);
nowt = localtime(&now);
prtat(nowt);
/*
* Print how long system has been up.
* (Found by looking for "bootime" in kernel)
*/
lseek(kmem, (long)nl[X_BOOTIME].n_value, 0);
read(kmem, &bootime, sizeof (bootime));
uptime = now - bootime;
days = uptime / (60*60*24);
uptime %= (60*60*24);
hrs = uptime / (60*60);
uptime %= (60*60);
mins = DIV60(uptime);
printf(" up");
if (days > 0)
printf(" %d day%s,", days, days>1?"s":"");
if (hrs > 0 && mins > 0) {
printf(" %2d:%02d,", hrs, mins);
} else {
if (hrs > 0)
printf(" %d hr%s,", hrs, hrs>1?"s":"");
if (mins > 0)
printf(" %d min%s,", mins, mins>1?"s":"");
}
/* Print number of users logged in to system */
while (fread(&utmp, sizeof(utmp), 1, ut)) {
if (utmp.ut_name[0] != '\0' &&
strncmp(utmp.ut_line, "pt/", sizeof("pt/") - 1))
nusers++;
}
rewind(ut);
printf(" %d users", nusers);
/*
* Print 1, 5, and 15 minute load averages.
* (Found by looking in kernel for avenrun).
*/
printf(", load average:");
lseek(kmem, (long)nl[X_AVENRUN].n_value, 0);
read(kmem, avenrun, sizeof(avenrun));
for (i = 0; i < (sizeof(avenrun)/sizeof(avenrun[0])); i++) {
if (i > 0)
printf(",");
printf(" %.2f", avenrun[i]);
}
printf("\n");
if (firstchar == 'u')
exit(0);
/* Headers for rest of output */
if (lflag)
printf("User tty login@ idle JCPU %%CPU %%MEM %%IN what\n");
else
printf("User tty idle what\n");
if (debug)
printf("ecmx = %d CLSIZE = %d\n", ecmx, CLSIZE);
fflush(stdout);
}
for (;;) { /* for each entry in utmp */
if (fread(&utmp, sizeof(utmp), 1, ut) == NULL) {
fclose(ut);
exit(0);
}
if (utmp.ut_name[0] == '\0')
continue; /* that tty is free */
if (sel_user && strncmp(utmp.ut_name, sel_user, NMAX) != 0)
continue; /* we wanted only somebody else */
if (strncmp(utmp.ut_line, "pt/", sizeof("pt/") - 1) == 0)
continue; /* ignore pt/pt?? entries */
gettty();
jobtime = 0;
percentcpu = 0;
pagesused = 0;
pagesresident = 0;
strcpy(doing, "-"); /* default act: normally never prints */
empty = 1;
curpid = -1;
idle = findidle();
for (i=0; i<np; i++) { /* for each process on this tty */
if (!(TTYEQ))
continue;
jobtime += pr[i].w_time + pr[i].w_ctime;
pagesused += pr[i].w_size;
pagesresident += pr[i].w_rss;
if ((pr[i].w_flag&SLOAD) && pr[i].w_ptime != 0)
percentcpu +=
100.0 * pr[i].w_pctcpu
/* / (1.0 - exp(pr[i].w_ptime * (-1.0/20.0))) */;
if (debug) {
printf("\t\t%d\t%s", pr[i].w_pid, pr[i].w_args);
printf(" %f %d %d %x %d", pr[i].w_pctcpu * 100.0,
pr[i].w_size, pr[i].w_rss, pr[i].w_flag,
pr[i].w_ptime);
printf("\n");
}
if (empty && pr[i].w_igintr!=IGINT) {
empty = 0;
curpid = -1;
}
if(pr[i].w_pid>curpid && (pr[i].w_igintr!=IGINT || empty)){
curpid = pr[i].w_pid;
strcpy(doing, lflag ? pr[i].w_args : pr[i].w_comm);
#ifdef notdef
if (doing[0]==0 || doing[0]=='-' && doing[1]<=' ' || doing[0] == '?') {
strcat(doing, " (");
strcat(doing, pr[i].w_comm);
strcat(doing, ")");
}
#endif
}
}
putline();
}
}
/* figure out the major/minor device # pair for this tty */
gettty()
{
char ttybuf[sizeof "/dev/" + sizeof utmp.ut_line];
struct stat statbuf;
strcpy(ttybuf, "/dev/");
strncat(ttybuf, utmp.ut_line, sizeof utmp.ut_line);
stat(ttybuf, &statbuf);
tty = statbuf.st_ino;
}
/*
* putline: print out the accumulated line of info about one user.
*/
putline()
{
register int tm;
/* print login name of the user */
printf("%-*.*s ", NMAX, NMAX, utmp.ut_name);
/* print tty user is on */
if (lflag)
/* long form: all (up to) LMAX chars */
printf("%-*.*s", LMAX, LMAX, utmp.ut_line);
else {
/* short form: 2 chars, skipping 'tty' if there */
if (utmp.ut_line[0]=='t' && utmp.ut_line[1]=='t' && utmp.ut_line[2]=='y')
printf("%-2.2s", &utmp.ut_line[3]);
else
printf("%-2.2s", utmp.ut_line);
}
if (lflag)
/* print when the user logged in */
prtat(localtime(&utmp.ut_time));
/* print idle time */
prttime(idle," ");
if (lflag) {
/* print CPU time for all processes & children */
prttime(DIV60(jobtime)," ");
/* print cpu time for interesting process */
printf("%5.1f%5.1f%5.1f",
percentcpu,
(ecmx ? 100.0*pagesresident/(float)ecmx/(float)CLSIZE : 0),
(pagesused ? 100.0*pagesresident/pagesused : 0));
}
/* what user is doing, either command tail or args */
printf(" %-.32s\n",doing);
fflush(stdout);
}
/* find & return number of minutes current tty has been idle */
findidle()
{
struct stat stbuf;
long lastaction, diff;
char ttyname[sizeof "/dev/" + sizeof utmp.ut_line];
strcpy(ttyname, "/dev/");
strncat(ttyname, utmp.ut_line, LMAX);
stat(ttyname, &stbuf);
time(&now);
lastaction = stbuf.st_atime;
diff = now - lastaction;
diff = DIV60(diff);
if (diff < 0) diff = 0;
return(diff);
}
/*
* prttime prints a time in hours and minutes.
* The character string tail is printed at the end, obvious
* strings to pass are "", " ", or "am".
*/
prttime(tim, tail)
time_t tim;
char *tail;
{
register int didhrs = 0;
if (tim >= 60) {
printf("%3d:", tim/60);
didhrs++;
} else {
printf(" ");
}
tim %= 60;
if (tim > 0 || didhrs) {
printf(didhrs&&tim<10 ? "%02d" : "%2d", tim);
} else {
printf(" ");
}
printf("%s", tail);
}
/* prtat prints a 12 hour time given a pointer to a time of day */
prtat(p)
struct tm *p;
{
register int t, pm;
t = p -> tm_hour;
pm = (t > 11);
if (t > 11)
t -= 12;
if (t == 0)
t = 12;
prttime(t*60 + p->tm_min, pm ? "pm" : "am");
}
/*
* readpr finds and reads in the array pr, containing the interesting
* parts of the proc and user tables for each live process.
*/
readpr()
{
int pn, mf, addr, c;
int szpt, pfnum, i;
int usize;
ino_t findtty();
struct pte *Usrptma, *usrpt, *pte, apte;
struct dblock db;
Usrptma = (struct pte *) nl[X_USRPTMA].n_value;
usrpt = (struct pte *) nl[X_USRPT].n_value;
if((mem = open("/dev/mem", 0)) < 0) {
fprintf(stderr, "No mem\n");
exit(1);
}
if ((swap = open("/dev/drum", 0)) < 0) {
fprintf(stderr, "No drum\n");
exit(1);
}
/*
* read mem to find swap dev.
*/
lseek(kmem, (long)nl[X_SWAPDEV].n_value, 0);
read(kmem, &nl[X_SWAPDEV].n_value, sizeof(nl[X_SWAPDEV].n_value));
/*
* Find base of swap
*/
lseek(kmem, (long)nl[X_NSWAP].n_value, 0);
read(kmem, &nswap, sizeof(nswap));
lseek(kmem, (long)nl[X_ECMX].n_value, 0);
if (read(kmem, &ecmx, sizeof (ecmx)) != sizeof (ecmx)) {
fprintf(stderr, "Can't read ecmx\n");
exit(1);
}
/*
* Locate proc table
*/
lseek(kmem, (long)nl[X_NPROC].n_value, 0);
read(kmem, &nproc, sizeof(nproc));
pr = (struct pr *)calloc(nproc, sizeof (struct pr));
f = (struct find *)calloc(nproc, sizeof(struct find));
np = 0;
lseek(kmem, (long)nl[X_PROC].n_value, 0);
read(kmem, &aproc, sizeof(aproc));
for (pn=0; pn<nproc; pn++) {
lseek(kmem, (int)(aproc + pn), 0);
read(kmem, &mproc, sizeof mproc);
/* decide if it's an interesting process */
if (mproc.p_stat==0 || mproc.p_pgrp==0)
continue;
f[pn].f_parent = &f[((unsigned)mproc.p_pptr
- (unsigned)aproc) / sizeof(mproc)];
if (mproc.p_flag&SDETACH)
continue;
/* find & read in the user structure */
if ((mproc.p_flag & SLOAD) == 0) {
/* not in memory - get from swap device */
addr = mproc.p_swaddr<<9;
lseek(swap, (long)addr, 0);
if (read(swap, &up, sizeof(up)) != sizeof(up)) {
continue;
}
} else {
int p0br, cc;
#define INTPPG (NBPG / sizeof (int))
struct pte pagetbl[NBPG / sizeof (struct pte)];
/* loaded, get each page from memory separately */
szpt = mproc.p_szpt;
p0br = (int)mproc.p_p0br;
pte = &Usrptma[btokmx(mproc.p_p0br) + szpt-1];
lseek(kmem, (long)pte, 0);
if (read(kmem, &apte, sizeof(apte)) != sizeof(apte))
continue;
lseek(mem, ctob(apte.pg_pfnum), 0);
if (read(mem,pagetbl,sizeof(pagetbl)) != sizeof(pagetbl))
cont:
continue;
usize = sizeof(up);
for(cc=0; cc<UPAGES; cc++) { /* get u area */
int upage = pagetbl[NPTEPG-UPAGES+cc].pg_pfnum;
int size = usize > NBPG ? NBPG : usize;
usize -= size;
lseek(mem,ctob(upage),0);
if (read(mem,((int *)&up)+INTPPG*cc,size) != size)
goto cont;
}
szpt = up.u_pcb.pcb_szpt;
pr[np].w_seekaddr = ctob(apte.pg_pfnum);
}
vstodb(0, CLSIZE, &up.u_smap, &db, 1);
pr[np].w_lastpg = ctob(db.db_base);
if (up.u_ttyino == 0)
continue;
/* save the interesting parts */
f[pn].f_pr = &pr[np];
pr[np].w_pid = mproc.p_pid;
pr[np].w_flag = mproc.p_flag;
if (mproc.p_stat != SIDL && mproc.p_stat != SZOMB)
pr[np].w_size = mproc.p_dsize + mproc.p_ssize;
pr[np].w_pctcpu = mproc.p_pctcpu;
pr[np].w_ptime = mproc.p_time;
if (mproc.p_stat != SIDL && mproc.p_stat != SZOMB)
pr[np].w_rss = mproc.p_rssize;
pr[np].w_igintr = (((int)up.u_signal[2]==1) + 2*((int)up.u_signal[2]>1) + 3*((int)up.u_signal[3]==1)) + 6*((int)up.u_signal[3]>1);
pr[np].w_time = up.u_vm.vm_utime + up.u_vm.vm_stime;
pr[np].w_ctime = up.u_cvm.vm_utime + up.u_cvm.vm_stime;
pr[np].w_tty = up.u_ttyino;
strncpy(pr[np].w_comm, up.u_comm, sizeof(up.u_comm));
/*
* Get args if there's a chance we'll print it.
* Cant just save pointer: getargs returns static place.
* Cant use strcpyn: that crock blank pads.
*/
pr[np].w_args[0] = 0;
strncat(pr[np].w_args,getargs(&pr[np]),ARGWIDTH);
if (pr[np].w_args[0]==0 || pr[np].w_args[0]=='-' && pr[np].w_args[1]<=' ' || pr[np].w_args[0] == '?') {
strcat(pr[np].w_args, " (");
strcat(pr[np].w_args, pr[np].w_comm);
strcat(pr[np].w_args, ")");
}
np++;
}
/* fix tty names for /dev/pt/pt?? */
for (pn = 0; pn < nproc; ++pn)
if (f[pn].f_pr)
f[pn].f_pr->w_tty = findtty(&f[pn]);
}
/*
* getargs: given a pointer to a proc structure, this looks at the swap area
* and tries to reconstruct the arguments. This is straight out of ps.
*/
char *
getargs(p)
struct pr *p;
{
int c, addr, nbad;
static int abuf[CLSIZE*NBPG/sizeof(int)];
struct pte pagetbl[NPTEPG];
register int *ip;
register char *cp, *cp1;
if ((p->w_flag & SLOAD) == 0) {
lseek(swap, p->w_lastpg, 0);
if (read(swap, abuf, sizeof(abuf)) != sizeof(abuf))
return(p->w_comm);
} else {
c = p->w_seekaddr;
lseek(mem,c,0);
if (read(mem,pagetbl,NBPG) != NBPG)
return(p->w_comm);
if (pagetbl[NPTEPG-CLSIZE-UPAGES].pg_fod==0 && pagetbl[NPTEPG-CLSIZE-UPAGES].pg_pfnum) {
lseek(mem,ctob(pagetbl[NPTEPG-CLSIZE-UPAGES].pg_pfnum),0);
if (read(mem,abuf,sizeof(abuf)) != sizeof(abuf))
return(p->w_comm);
} else {
lseek(swap, p->w_lastpg, 0);
if (read(swap, abuf, sizeof(abuf)) != sizeof(abuf))
return(p->w_comm);
}
}
abuf[sizeof(abuf)/sizeof(abuf[0])-1] = 0;
for (ip = &abuf[sizeof(abuf)/sizeof(abuf[0])-2]; ip > abuf;) {
/* Look from top for -1 or 0 as terminator flag. */
if (*--ip == -1 || *ip == 0) {
cp = (char *)(ip+1);
if (*cp==0)
cp++;
nbad = 0; /* up to 5 funny chars as ?'s */
for (cp1 = cp; cp1 < (char *)&abuf[sizeof(abuf)/sizeof(abuf[0])]; cp1++) {
c = *cp1&0177;
if (c==0) /* nulls between args => spaces */
*cp1 = ' ';
else if (c < ' ' || c > 0176) {
if (++nbad >= 5) {
*cp1++ = ' ';
break;
}
*cp1 = '?';
} else if (c=='=') { /* Oops - found an
* environment var, back
* over & erase it. */
*cp1 = 0;
while (cp1>cp && *--cp1!=' ')
*cp1 = 0;
break;
}
}
while (*--cp1==' ') /* strip trailing spaces */
*cp1 = 0;
return(cp);
}
}
return (p->w_comm);
}
/*
* Given a base/size pair in virtual swap area,
* return a physical base/size pair which is the
* (largest) initial, physically contiguous block.
*/
vstodb(vsbase, vssize, dmp, dbp, rev)
register int vsbase;
int vssize;
struct dmap *dmp;
register struct dblock *dbp;
{
register int blk = DMMIN;
register swblk_t *ip = dmp->dm_map;
if (vsbase < 0 || vsbase + vssize > dmp->dm_size)
panic("vstodb");
while (vsbase >= blk) {
vsbase -= blk;
if (blk < DMMAX)
blk *= 2;
ip++;
}
if (*ip <= 0 || *ip + blk > nswap)
panic("vstodb *ip");
dbp->db_size = min(vssize, blk - vsbase);
dbp->db_base = *ip + (rev ? blk - (vsbase + dbp->db_size) : vsbase);
}
panic(cp)
char *cp;
{
/* printf("%s\n", cp); */
}
min(a, b)
{
return (a < b ? a : b);
}
ino_t
findtty(fp)
struct find *fp;
{
if (fp->f_tty)
return(fp->f_tty);
if (isttyinode(fp->f_pr->w_tty))
return(fp->f_tty = fp->f_pr->w_tty);
return(fp->f_tty = findtty(fp->f_parent));
}
static char *dirlist[] = {
"/dev/",
"/dev/dk/",
0
};
#define BITSPERBYTE 8
#define BITMAP 1024
char inodes[BITMAP];
isttyinode(i)
ino_t i;
{
register char **dpp, *dp;
int fd;
struct direct db;
static init = 0;
if (init == 0) {
for (dpp = dirlist; dp = *dpp++;) {
if ((fd = open(dp, 0)) < 0)
continue;
while (read(fd, (char *) &db, sizeof(db)) == sizeof(db))
inodes[db.d_ino / BITSPERBYTE] |= (1 <<
(db.d_ino % BITSPERBYTE));
close(fd);
}
++init;
}
return(inodes[i / BITSPERBYTE] & (1 << (i % BITSPERBYTE)));
}