2.11BSD/src/ucb/w.c
/*
* w.c (2.11BSD) 2.0 1996/11/17
*
* w - print system status (who and what)
*
* Rewritten using sysctl, no nlist used - 1/19/94 - sms.
*
* This program is similar to the systat command on Tenex/Tops 10/20
* It needs read permission on /dev/mem and /dev/swap.
*/
#include <sys/param.h>
#include <sys/sysctl.h>
#include <stdio.h>
#include <ctype.h>
#include <utmp.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/user.h>
#include <sys/proc.h>
#include <sys/ioctl.h>
#include <sys/tty.h>
#define NMAX sizeof(utmp.ut_name)
#define LMAX sizeof(utmp.ut_line)
#define ARGWIDTH 33 /* # chars left on 80 col crt for args */
#define ARGLIST 1024 /* amount of stack to examine for argument list */
struct smproc {
long w_addr; /* address in file for args */
short w_pid; /* proc.p_pid */
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 */
dev_t w_tty; /* tty device of process */
char w_comm[15]; /* user.u_comm, null terminated */
char w_args[ARGWIDTH+1]; /* args if interesting process */
} *pr;
FILE *ut;
int swmem;
int swap; /* /dev/mem, mem, and swap */
int file;
dev_t tty;
char doing[520]; /* process attached to terminal */
time_t proctime; /* cpu time of process in doing */
double avenrun[3];
extern int errno, optind;
#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 */
long round();
char *getargs();
char *getptr();
char *program;
int header = 1; /* true if -h flag: don't print heading */
int lflag = 1; /* true if -l flag: long style output */
time_t idle; /* number of minutes user is idle */
int nusers; /* number of users logged in now */
char * sel_user; /* login of particular user selected */
int wcmd = 1; /* running as the w command */
time_t jobtime; /* total cpu time visible */
time_t now; /* the current time of day */
struct tm *nowt; /* current time as time struct */
struct timeval boottime; /* time since last reboot */
time_t uptime; /* elapsed time since */
int np; /* number of processes currently active */
struct utmp utmp;
struct user up;
struct addrmap {
long b1, e1; long f1;
long b2, e2; long f2;
};
struct addrmap datmap;
main(argc, argv)
char **argv;
{
int days, hrs, mins;
register int i;
char *cp;
register int curpid, empty;
size_t size;
int mib[2];
program = argv[0];
if ((cp = rindex(program, '/')) || *(cp = program) == '-')
cp++;
if (*cp == 'u')
wcmd = 0;
while ((i = getopt(argc, argv, "hlswu")) != EOF)
{
switch (i)
{
case 'h':
header = 0;
break;
case 'l':
lflag++;
break;
case 's':
lflag = 0;
break;
case 'u':
wcmd = 0;
break;
case 'w':
wcmd = 1;
break;
default:
fprintf(stderr, "Usage: %s [-hlswu] [user]\n",
program);
exit(1);
}
}
argc -= optind;
argv += optind;
if (*argv)
sel_user = *argv;
if (wcmd)
readpr();
ut = fopen(_PATH_UTMP, "r");
if (header) {
/* Print time of day */
time(&now);
nowt = localtime(&now);
prtat(nowt);
mib[0] = CTL_KERN;
mib[1] = KERN_BOOTTIME;
size = sizeof (boottime);
if (sysctl(mib, 2, &boottime, &size, NULL, 0) != -1 &&
boottime.tv_sec != 0) {
uptime = now - boottime.tv_sec;
days = uptime / (60L*60L*24L);
uptime %= (60L*60L*24L);
hrs = uptime / (60L*60L);
uptime %= (60L*60L);
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')
nusers++;
}
rewind(ut);
printf(" %d user%c", nusers, nusers > 1 ? 's' : '\0');
if (getloadavg(avenrun, sizeof(avenrun) / sizeof(avenrun[0])) == -1)
printf(", no load average information available\n");
else {
printf(", load averages:");
for (i = 0; i < (sizeof(avenrun)/sizeof(avenrun[0])); i++) {
if (i > 0)
printf(",");
printf(" %.2f", avenrun[i]);
}
}
printf("\n");
if (wcmd == 0)
exit(0);
/* Headers for rest of output */
if (lflag)
printf("%-*.*s %-*.*s login@ idle JCPU PCPU what\n",
NMAX, NMAX, "User", LMAX, LMAX, "tty");
else
printf("%-*.*s tty idle what\n",
NMAX, NMAX, "User");
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 */
gettty();
jobtime = 0;
proctime = 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;
proctime += pr[i].w_time;
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);
if (doing[0]==0 || doing[0]=='-' && doing[1]<=' ' || doing[0] == '?') {
strcat(doing, " (");
strcat(doing, pr[i].w_comm);
strcat(doing, ")");
}
}
}
putline();
}
}
/* figure out the major/minor device # pair for this tty */
gettty()
{
char ttybuf[20];
struct stat statbuf;
ttybuf[0] = 0;
strcpy(ttybuf, "/dev/");
strcat(ttybuf, utmp.ut_line);
stat(ttybuf, &statbuf);
tty = statbuf.st_rdev;
}
/*
* putline: print out the accumulated line of info about one user.
*/
putline()
{
/* 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 */
prttime(DIV60(proctime)," ");
}
/* 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[20];
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("%3ld:", tim/60);
didhrs++;
} else {
printf(" ");
}
tim %= 60;
if (tim > 0 || didhrs) {
printf(didhrs&&tim<10 ? "%02ld" : "%2ld", tim);
} else {
printf(" ");
}
printf("%s", tail);
}
/* prtat prints a 12 hour time given a pointer to a time of day */
prtat(p)
register struct tm *p;
{
register int pm;
time_t t;
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()
{
struct kinfo_proc *kp;
register struct proc *p;
register struct smproc *smp;
struct kinfo_proc *kpt;
int pn, nproc;
long addr, daddr, saddr;
long txtsiz, datsiz, stksiz;
int septxt;
int mib[4], st;
size_t size;
if((swmem = open("/dev/mem", 0)) < 0) {
perror("/dev/mem");
exit(1);
}
if ((swap = open("/dev/swap", 0)) < 0) {
perror("/dev/swap");
exit(1);
}
mib[0] = CTL_KERN;
mib[1] = KERN_PROC;
mib[2] = KERN_PROC_ALL;
size = 0;
st = sysctl(mib, 4, NULL, &size, NULL, 0);
if (st == -1) {
fprintf(stderr, "sysctl: %s \n", strerror(errno));
exit(1);
}
if (size % sizeof (struct kinfo_proc) != 0) {
fprintf(stderr, "proc size mismatch (%d total, %d chunks)\n",
size, sizeof(struct kinfo_proc));
exit(1);
}
kpt = (struct kinfo_proc *)malloc(size);
if (kpt == (struct kinfo_proc *)NULL) {
fprintf(stderr, "Not %d bytes of memory for proc table\n",
size);
exit(1);
}
if (sysctl(mib, 4, kpt, &size, NULL, 0) == -1) {
fprintf(stderr, "sysctl fetch of proc table failed: %s\n",
strerror(errno));
exit(1);
}
nproc = size / sizeof (struct kinfo_proc);
pr = (struct smproc *) malloc(nproc * sizeof(struct smproc));
if (pr == (struct smproc *)NULL) {
fprintf(stderr,"Not enough memory for proc table\n");
exit(1);
}
/*
* Now step thru the kinfo_proc structures and save interesting
* process's info in the 'smproc' structure.
*/
smp = pr;
kp = kpt;
for (pn = 0; pn < nproc; kp++, pn++) {
p = &kp->kp_proc;
/* decide if it's an interesting process */
if (p->p_stat==0 || p->p_stat==SZOMB || p->p_pgrp==0)
continue;
/* find & read in the user structure */
if (p->p_flag & SLOAD) {
addr = ctob((long)p->p_addr);
daddr = ctob((long)p->p_daddr);
saddr = ctob((long)p->p_saddr);
file = swmem;
} else {
addr = (off_t)p->p_addr<<9;
daddr = (off_t)p->p_daddr<<9;
saddr = (off_t)p->p_saddr<<9;
file = swap;
}
lseek(file, addr, 0);
if (read(file, (char *)&up, sizeof(up)) != sizeof(up))
continue;
if (up.u_ttyp == NULL)
continue;
/* set up address maps for user pcs */
txtsiz = ctob(up.u_tsize);
datsiz = ctob(up.u_dsize);
stksiz = ctob(up.u_ssize);
septxt = up.u_sep;
datmap.b1 = (septxt ? 0 : round(txtsiz,TXTRNDSIZ));
datmap.e1 = datmap.b1+datsiz;
datmap.f1 = daddr;
datmap.b2 = stackbas(stksiz);
datmap.e2 = stacktop(stksiz);
datmap.f2 = saddr;
/* save the interesting parts */
smp->w_addr = saddr + ctob((long)p->p_ssize) - ARGLIST;
smp->w_pid = p->p_pid;
smp->w_igintr = (int)(((up.u_signal[2]==1) + 2*(up.u_signal[2]>1) + 3*(up.u_signal[3]==1)) + 6*(up.u_signal[3]>1));
smp->w_time = up.u_ru.ru_utime + up.u_ru.ru_stime;
smp->w_ctime = up.u_cru.ru_utime + up.u_cru.ru_stime;
smp->w_tty = up.u_ttyd;
up.u_comm[14] = 0; /* Bug: This bombs next field. */
strcpy(smp->w_comm, up.u_comm);
/*
* Get args if there's a chance we'll print it.
* Cant just save pointer: getargs returns static place.
* Cant use strncpy: that crock blank pads.
*/
smp->w_args[0] = 0;
strncat(smp->w_args,getargs(smp),ARGWIDTH);
if (smp->w_args[0]==0 || smp->w_args[0]=='-' && smp->w_args[1]<=' ' || smp->w_args[0] == '?') {
strcat(smp->w_args, " (");
strcat(smp->w_args, smp->w_comm);
strcat(smp->w_args, ")");
}
smp++;
}
np = smp - pr;
free(kpt);
}
/*
* 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 smproc *p;
{
int c, nbad;
static char abuf[ARGLIST];
register int *ip;
register char *cp, *cp1;
char **ap;
long addr;
addr = p->w_addr;
/* look for sh special */
lseek(file, addr+ARGLIST-sizeof(char **), 0);
if (read(file, (char *)&ap, sizeof(char *)) != sizeof(char *))
return(NULL);
if (ap) {
char *b = (char *) abuf;
char *bp = b;
while((cp=getptr(ap++)) && cp && (bp<b+ARGWIDTH) ) {
nbad = 0;
while((c=getbyte(cp++)) && (bp<b+ARGWIDTH)) {
if (c<' ' || c>'~') {
if (nbad++>3)
break;
continue;
}
*bp++ = c;
}
*bp++ = ' ';
}
*bp++ = 0;
return(b);
}
lseek(file, addr, 0);
if (read(file, abuf, sizeof(abuf)) != sizeof(abuf))
return((char *)1);
for (ip = (int *) &abuf[ARGLIST]-2; ip > (int *) 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[ARGLIST]; 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);
}
char *
getptr(adr)
char **adr;
{
char *ptr;
register char *p, *pa;
register i;
ptr = 0;
pa = (char *)adr;
p = (char *)&ptr;
for (i=0; i<sizeof(ptr); i++)
*p++ = getbyte(pa++);
return(ptr);
}
getbyte(adr)
char *adr;
{
register struct addrmap *amap = &datmap;
char b;
long saddr;
if(!within(adr, amap->b1, amap->e1)) {
if(within(adr, amap->b2, amap->e2)) {
saddr = (unsigned)adr + amap->f2 - amap->b2;
} else
return(0);
} else
saddr = (unsigned)adr + amap->f1 - amap->b1;
if(lseek(file, saddr, 0)==-1
|| read(file, &b, 1)<1) {
return(0);
}
return((unsigned)b);
}
within(adr,lbd,ubd)
char *adr;
long lbd, ubd;
{
return((unsigned)adr>=lbd && (unsigned)adr<ubd);
}
long
round(a, b)
long a, b;
{
long w = ((a+b-1)/b)*b;
return(w);
}