+static char *sccsid = "@(#)ps.c 4.7 (Berkeley) 10/20/80";
/*
- * ps - process status
- * This is the augmented UCB ps for UCB/VM Unix (9/79)
- * examine and print certain things about processes
- * usage: ps [acgklrt#uvwx] [corefile] [swapfile] [system]
+ * ps; VAX 4BSD version
*/
#include <stdio.h>
-#include <a.out.h>
+#include <ctype.h>
+#include <nlist.h>
#include <pwd.h>
#include <sys/param.h>
-#include <sys/proc.h>
#include <sys/tty.h>
#include <sys/dir.h>
#include <sys/user.h>
+#include <sys/proc.h>
#include <sys/pte.h>
#include <sys/vm.h>
#include <sys/text.h>
-#include <psout.h>
+#include <sys/stat.h>
+#include <math.h>
struct nlist nl[] = {
{ "_proc" },
#define X_PROC 0
- { "_swapdev" },
-#define X_SWAPDEV 1
- { "_swplo" },
-#define X_SWPLO 2
- { "_Usrptma" },
-#define X_USRPTMA 3
+ { "_Usrptmap" },
+#define X_USRPTMA 1
{ "_usrpt" },
-#define X_USRPT 4
+#define X_USRPT 2
{ "_text" },
-#define X_TEXT 5
+#define X_TEXT 3
{ "_nswap" },
-#define X_NSWAP 6
+#define X_NSWAP 4
+ { "_maxslp" },
+#define X_MAXSLP 5
+ { "_ccpu" },
+#define X_CCPU 6
+ { "_ecmx" },
+#define X_ECMX 7
{ 0 },
};
-struct proc mproc;
-struct text text[NTEXT];
+struct savcom {
+ union {
+ struct lsav *lp;
+ float u_pctcpu;
+ struct vsav *vp;
+ int s_ssiz;
+ } sun;
+ struct asav *ap;
+} savcom[NPROC];
+
+struct asav {
+ char *a_cmdp;
+ int a_flag;
+ short a_stat, a_uid, a_pid, a_nice, a_pri, a_slptime, a_time;
+ size_t a_size, a_rss, a_tsiz, a_txtrss;
+ short a_xccount;
+ char a_tty[DIRSIZ+1];
+ dev_t a_ttyd;
+ time_t a_cpu;
+};
+
+char *lhdr;
+struct lsav {
+ short l_ppid;
+ char l_cpu;
+ int l_addr;
+ caddr_t l_wchan;
+};
+
+char *uhdr;
+char *shdr;
-#define INTPPG (NBPG/sizeof(int)) /* ints per page */
+char *vhdr;
+struct vsav {
+ u_int v_majflt;
+ size_t v_swrss, v_txtswrss;
+ float v_pctcpu;
+};
+
+struct proc proc[8]; /* 8 = a few, for less syscalls */
+struct proc *mproc;
+struct text *text;
+
+int paduser1; /* avoid hardware mem clobbering botch */
union {
- struct user yy;
- int xx[INTPPG][UPAGES];
- } zz;
+ struct user user;
+ char upages[UPAGES][NBPG];
+} user;
+#define u user.user
+int paduser2; /* avoid hardware mem clobbering botch */
+
#define clear(x) ((int)x & 0x7fffffff)
-#define u zz.yy
-int chkpid = 0;
-int aflg; /* -a: all processes, not just mine */
-int cflg; /* -c: complete listing of args, not just comm. */
-int gflg; /* -g: complete listing including group headers, etc */
-int kflg; /* -k: read from core file instead of real memory */
-int lflg; /* -l: long listing form */
-int rflg; /* -r: raw output in style <psout.h> */
-int sflg; /* -s: stack depth */
-int uflg; /* -u: user name */
-int vflg; /* -v: virtual memory statistics */
-int wflg; /* -w[w]: wide terminal */
-int xflg; /* -x: ALL processes, even those without ttys */
-int login; /* -: this is a login shell */
+
+int chkpid;
+int aflg, cflg, eflg, gflg, kflg, lflg, sflg, uflg, vflg, xflg;
char *tptr;
-char *gettty();
+char *gettty(), *getcmd(), *getname(), *savestr(), *alloc(), *state();
+double pcpu(), pmem();
int pscomp();
-struct pte pagetbl[NPTEPG];
-int kmem;
-int mem;
-int swap;
-daddr_t swplo;
-int nswap;
-int Usrptma;
-int usrpt;
-
-int ndev;
-struct devl {
- char dname[DIRSIZ];
- dev_t dev;
-} devl[256];
-
-struct psout outargs[NPROC]; /* info for first npr processes */
-int npr; /* number of processes found so far */
-int argwidth; /* number of chars of args to print */
-
-char *coref;
+int nswap, maxslp;
+double ccpu;
+int ecmx;
+struct pte *Usrptma, *usrpt;
+
+struct ttys {
+ char name[DIRSIZ+1];
+ dev_t ttyd;
+ struct ttys *next;
+ struct ttys *cand;
+} *allttys, *cand[16];
+
+struct savcom savcom[NPROC];
+int npr;
+
+int cmdstart;
+int twidth;
+char *kmemf, *memf, *swapf, *nlistf;
+int kmem, mem, swap;
+int rawcpu, sumcpu;
+
+int pcbpf;
+int argaddr;
+extern char _sobuf[];
main(argc, argv)
-char **argv;
+ char **argv;
{
- int i;
- char *ap;
- int uid, puid;
- char obuf[BUFSIZ];
- register struct nlist *nlp;
+ register int i, j;
+ register char *ap;
+ int uid;
+ off_t procp;
- setbuf(stdout, obuf);
+ if (chdir("/dev") < 0) {
+ perror("/dev");
+ exit(1);
+ }
+ twidth = 80;
+ setbuf(stdout, _sobuf);
argc--, argv++;
- if (argc>0) {
+ if (argc > 0) {
ap = argv[0];
while (*ap) switch (*ap++) {
- case '-':
- break;
+ case 'C':
+ rawcpu++;
+ break;
+ case 'S':
+ sumcpu++;
+ break;
case 'a':
aflg++;
break;
-
case 'c':
- cflg++;
+ cflg = !cflg;
+ break;
+ case 'e':
+ eflg++;
break;
-
case 'g':
gflg++;
break;
-
case 'k':
kflg++;
break;
-
case 'l':
lflg++;
break;
-
- case 'r':
- rflg++;
- break;
-
case 's':
sflg++;
break;
-
case 't':
- if(*ap)
+ if (*ap)
tptr = ap;
aflg++;
gflg++;
while (*ap)
ap++;
break;
-
case 'u':
uflg++;
break;
-
case 'v':
+ cflg = 1;
vflg++;
break;
-
case 'w':
- wflg++;
+ if (twidth == 80)
+ twidth = 132;
+ else
+ twidth = BUFSIZ;
break;
-
case 'x':
xflg++;
break;
-
default:
- chkpid=atoi(--ap);
- *ap = '\0';
+ if (!isdigit(ap[-1]))
+ break;
+ chkpid = atoi(--ap);
+ *ap = 0;
aflg++;
xflg++;
break;
}
}
- coref = "/dev/kmem";
- if(kflg)
- coref = argc > 1 ? argv[1] : "/vmcore";
-
- if ((kmem = open(coref, 0)) < 0) {
- perror(coref);
- done(1);
+ openfiles(argc, argv);
+ getkvars(argc, argv);
+ getdev();
+ uid = getuid();
+ printhdr();
+ procp = nl[X_PROC].n_value;
+ for (i=0; i<NPROC; i += 8) {
+ lseek(kmem, (char *)procp, 0);
+ j = NPROC - i;
+ if (j > 8)
+ j = 8;
+ j *= sizeof (struct proc);
+ if (read(kmem, (char *)proc, j) != j)
+ cantread("proc table", kmemf);
+ procp += j;
+ for (j = j / sizeof (struct proc) - 1; j >= 0; j--) {
+ mproc = &proc[j];
+ if (mproc->p_stat == 0 ||
+ mproc->p_pgrp == 0 && xflg == 0)
+ continue;
+ if (tptr == 0 && gflg == 0 && xflg == 0 &&
+ mproc->p_ppid == 1 && (mproc->p_flag&SDETACH) == 0)
+ continue;
+ if (uid != mproc->p_uid && aflg==0 ||
+ chkpid != 0 && chkpid != mproc->p_pid)
+ continue;
+ if (vflg && gflg == 0 && xflg == 0) {
+ if (mproc->p_stat == SZOMB ||
+ mproc->p_flag&SWEXIT)
+ continue;
+ if (mproc->p_slptime > MAXSLP &&
+ (mproc->p_stat == SSLEEP ||
+ mproc->p_stat == SSTOP))
+ continue;
+ }
+ save();
+ }
}
- if ((mem = open("/dev/mem", 0)) < 0) {
- fprintf(stderr, "No mem\n");
- done(1);
+ qsort(savcom, npr, sizeof(savcom[0]), pscomp);
+ for (i=0; i<npr; i++) {
+ register struct savcom *sp = &savcom[i];
+ if (lflg)
+ lpr(sp);
+ else if (vflg)
+ vpr(sp);
+ else if (uflg)
+ upr(sp);
+ else
+ spr(sp);
+ if (sp->ap->a_flag & SWEXIT)
+ printf(" <exiting>");
+ else if (sp->ap->a_stat == SZOMB)
+ printf(" <defunct>");
+ else if (sp->ap->a_pid == 0)
+ printf(" swapper");
+ else if (sp->ap->a_pid == 2)
+ printf(" pagedaemon");
+ else
+ printf(" %.*s", twidth - cmdstart - 2, sp->ap->a_cmdp);
+ printf("\n");
}
- if (kflg)
- mem = kmem;
+ exit(npr == 0);
+}
- if ((swap = open(argc>2 ? argv[2]: "/dev/drum", 0)) < 0) {
- fprintf(stderr, "Can't open /dev/drum\n");
- done(1);
- }
+openfiles(argc, argv)
+ char **argv;
+{
- nlist(argc>3 ? argv[3] : "/vmunix", nl);
- if (nl[0].n_type==0) {
- fprintf(stderr, "No namelist\n");
- done(1);
+ kmemf = "kmem";
+ if (kflg)
+ kmemf = argc > 1 ? argv[1] : "/vmcore";
+ kmem = open(kmemf, 0);
+ if (kmem < 0) {
+ perror(kmemf);
+ exit(1);
}
+ if (kflg) {
+ mem = kmem;
+ memf = kmemf;
+ } else {
+ memf = "mem";
+ mem = open(memf, 0);
+ if (mem < 0) {
+ perror(memf);
+ exit(1);
+ }
+ }
+ swapf = argc>2 ? argv[2]: "drum";
+ swap = open(swapf, 0);
+ if (swap < 0) {
+ perror(swapf);
+ exit(1);
+ }
+}
+
+getkvars(argc, argv)
+ char **argv;
+{
+ register struct nlist *nlp;
- if(chdir("/dev") < 0) {
- fprintf(stderr, "Can't change to /dev\n");
- done(1);
+ nlistf = argc > 3 ? argv[3] : "/vmunix";
+ nlist(nlistf, nl);
+ if (nl[0].n_type == 0) {
+ fprintf(stderr, "%s: No namelist\n", nlistf);
+ exit(1);
}
if (kflg)
- for (nlp= nl; nlp < &nl[sizeof (nl)/sizeof (nl[0])]; nlp++)
- nlp->n_value &= 0x7ffffffff;
- Usrptma = nl[X_USRPTMA].n_value;
- usrpt = nl[X_USRPT].n_value;
- /*
- * read kmem 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 and size of swap
- */
- lseek(kmem, (long)nl[X_SWPLO].n_value, 0);
- read(kmem, &swplo, sizeof(swplo));
+ for (nlp = nl; nlp < &nl[sizeof (nl)/sizeof (nl[0])]; nlp++)
+ nlp->n_value = clear(nlp->n_value);
+ Usrptma = (struct pte *)nl[X_USRPTMA].n_value;
+ usrpt = (struct pte *)nl[X_USRPT].n_value;
lseek(kmem, (long)nl[X_NSWAP].n_value, 0);
- read(kmem, &nswap, sizeof (nswap));
- /*
- * If v flag get text table
- */
- if (vflg) {
- lseek(kmem, (long)nl[X_TEXT].n_value, 0);
- read(kmem, text, sizeof (text));
+ if (read(kmem, &nswap, sizeof (nswap)) != sizeof (nswap)) {
+ cantread("nswap", kmemf);
+ exit(1);
}
- if (kflg)
- swplo = 0;
- getdev();
- uid = getuid();
- if (sflg + lflg + vflg + uflg > 1) {
- printf("Cannot combine s, l, v, and/or u.\n");
+ lseek(kmem, (long)nl[X_MAXSLP].n_value, 0);
+ if (read(kmem, &maxslp, sizeof (maxslp)) != sizeof (maxslp)) {
+ cantread("maxslp", kmemf);
exit(1);
}
- /* different psout widths depending on how much printed & w flag */
- if (wflg <= 1) {
- argwidth = 63;
- if (wflg) argwidth += 52; /* 132 col term */
- if (lflg) argwidth -= 49; /* extra junk printed */
- if (vflg) argwidth -= 48; /* extra junk for -v */
- if (sflg) argwidth -= 4; /* 4 cols of stack size */
- if (uflg) argwidth -= 27; /* user name */
- } else argwidth = 127;
- if (rflg)
- ; /* No heading for raw output */
- else if (lflg)
- printf(" F S UID PID PPID CPU PRI NICE ADDR SZ RSS WCHAN TTY TIME COMMAND\n");
- else if (vflg)
- printf("F PID TT TIME TIM SL MINFLT MAJFLT SIZE RSS SRS TSIZ TRS PF COMMAND\n");
- else if (uflg)
- printf("USER PID %%CPU NICE SZ RSS TTY TIME COMMAND\n");
- else if (chkpid==0) {
- if (sflg)
- printf(" SSIZ");
- printf(" PID TTY TIME COMMAND\n");
+ lseek(kmem, (long)nl[X_CCPU].n_value, 0);
+ if (read(kmem, &ccpu, sizeof (ccpu)) != sizeof (ccpu)) {
+ cantread("ccpu", kmemf);
+ exit(1);
}
- fflush(stdout);
- for (i=0; i<NPROC; i++) {
- lseek(kmem, (long)(nl[X_PROC].n_value+i*(sizeof mproc)), 0);
- read(kmem, &mproc, sizeof mproc);
- /* skip processes that don't exist */
- if (mproc.p_stat==0)
- continue;
- /* skip those without a tty unless -x */
- if (mproc.p_pgrp==0 && xflg==0)
- continue;
- /* skip group leaders on a tty unless -g, -x, or -t.. */
- if (!gflg && !xflg && !tptr && mproc.p_pid == mproc.p_pgrp)
- continue;
- /* -g also skips those where **argv is "-" - see savcom */
- puid = mproc.p_uid;
- /* skip other peoples processes unless -a or a specific pid */
- if ((uid != puid && aflg==0) ||
- (chkpid!=0 && chkpid!=mproc.p_pid))
- continue;
- if (savcom(puid))
- npr++;
- }
- fixup(npr);
- for (i=0; i<npr; i++)
- if (prcom(&outargs[i])) {
- putchar('\n');
- fflush(stdout);
+ lseek(kmem, (long)nl[X_ECMX].n_value, 0);
+ if (read(kmem, &ecmx, sizeof (ecmx)) != sizeof (ecmx)) {
+ cantread("ecmx", kmemf);
+ exit(1);
+ }
+ if (uflg || vflg) {
+ text = (struct text *)alloc(NTEXT * sizeof (struct text));
+ if (text == 0) {
+ fprintf(stderr, "no room for text table\n");
+ exit(1);
+ }
+ lseek(kmem, (long)nl[X_TEXT].n_value, 0);
+ if (read(kmem, (char *)text, NTEXT * sizeof (struct text))
+ != NTEXT * sizeof (struct text)) {
+ cantread("text table", kmemf);
+ exit(1);
}
- done(!npr);
+ }
+}
+
+printhdr()
+{
+ char *hdr;
+
+ if (sflg+lflg+vflg+uflg > 1) {
+ fprintf(stderr, "ps: specify only one of s,l,v and u\n");
+ exit(1);
+ }
+ hdr = lflg ? lhdr : (vflg ? vhdr : (uflg ? uhdr : shdr));
+ if (lflg+vflg+uflg+sflg == 0)
+ hdr += strlen("SSIZ ");
+ cmdstart = strlen(hdr);
+ printf("%s COMMAND\n", hdr);
+ fflush(stdout);
}
+cantread(what, fromwhat)
+ char *what, *fromwhat;
+{
+
+ fprintf(stderr, "ps: error reading %s from %s", what, fromwhat);
+}
+
+struct direct dbuf;
+int dialbase;
+
getdev()
{
-#include <sys/stat.h>
register FILE *df;
- struct stat sbuf;
- struct direct dbuf;
+ register struct ttys *dp;
- if ((df = fopen("/dev", "r")) == NULL) {
- fprintf(stderr, "Can't open /dev\n");
- done(1);
+ dialbase = -1;
+ if ((df = fopen(".", "r")) == NULL) {
+ fprintf(stderr, "Can't open . in /dev\n");
+ exit(1);
}
- ndev = 0;
- while (fread(&dbuf, sizeof(dbuf), 1, df) == 1) {
- if(dbuf.d_ino == 0)
+ while (fread((char *)&dbuf, sizeof(dbuf), 1, df) == 1) {
+ if (dbuf.d_ino == 0)
continue;
- if(stat(dbuf.d_name, &sbuf) < 0)
- continue;
- if ((sbuf.st_mode&S_IFMT) != S_IFCHR)
- continue;
- strcpy(devl[ndev].dname, dbuf.d_name);
- devl[ndev].dev = sbuf.st_rdev;
- ndev++;
+ maybetty(dp);
}
fclose(df);
}
-savcom(puid)
+/*
+ * Attempt to avoid stats by guessing minor device
+ * numbers from tty names. Console is known,
+ * know that r(hp|up|mt) are unlikely as are different mem's,
+ * floppy, null, tty, etc.
+ */
+maybetty()
{
- int abuf[INTPPG];
- long addr;
- register int *ip;
- register struct psout *a;
- register char *cp, *cp1;
- long tm;
- int cc, nbad;
- int szpt, p0br;
- register char *tp;
- struct dblock db;
- struct pte apte;
+ register char *cp = dbuf.d_name;
+ register struct ttys *dp;
+ int x;
+ struct stat stb;
- /* skip long sleeping or dead processes if -v unless -g or -x */
- if (!gflg && vflg && !xflg) {
- switch (mproc.p_stat) {
+ switch (cp[0]) {
+
+ case 'c':
+ if (!strcmp(cp, "console")) {
+ x = 0;
+ goto donecand;
+ }
+ /* cu[la]? are possible!?! don't rule them out */
+ break;
- case SSLEEP:
- case SSTOP:
- if (mproc.p_slptime > MAXSLP)
+ case 'd':
+ if (!strcmp(cp, "drum"))
+ return (0);
+ break;
+
+ case 'f':
+ if (!strcmp(cp, "floppy"))
+ return (0);
+ break;
+
+ case 'k':
+ cp++;
+ if (*cp == 'U')
+ cp++;
+ goto trymem;
+
+ case 'r':
+ cp++;
+ if (*cp == 'r' || *cp == 'u' || *cp == 'h')
+ cp++;
+#define is(a,b) cp[0] == 'a' && cp[1] == 'b'
+ if (is(r,p) || is(u,p) || is(r,k) || is(r,m) || is(m,t)) {
+ cp += 2;
+ if (isdigit(*cp) && cp[2] == 0)
return (0);
- break;
+ }
+ break;
- case SRUN:
- case SIDL:
- break;
+ case 'm':
+trymem:
+ if (cp[0] == 'm' && cp[1] == 'e' && cp[2] == 'm' && cp[3] == 0)
+ return (0);
+ break;
+
+ case 'n':
+ if (!strcmp(cp, "null"))
+ return (0);
+ break;
- case SZOMB:
+ case 'v':
+ if ((cp[1] == 'a' || cp[1] == 'p') && isdigit(cp[2]) &&
+ cp[3] == 0)
return (0);
+ break;
+ }
+mightbe:
+ cp = dbuf.d_name;
+ while (cp < &dbuf.d_name[DIRSIZ] && *cp)
+ cp++;
+ --cp;
+ x = 0;
+ if (cp[-1] == 'd') {
+ if (dialbase == -1) {
+ if (stat("ttyd0", &stb) == 0)
+ dialbase = stb.st_rdev & 017;
+ else
+ dialbase = -2;
}
+ if (dialbase == -2)
+ x = 0;
+ else
+ x = 11;
}
- /* read in the user structure */
- if ((mproc.p_flag& SLOAD ) == 0) {
- /* not loaded - get from swap */
- addr = (mproc.p_swaddr+swplo)<<9;
- lseek(swap, addr, 0);
- if (read(swap, &u, sizeof(u)) != sizeof(u))
- return(0);
- } else {
- /* loaded, get each page from memory separately */
- for(cc=0; cc<UPAGES; cc++) { /* get u area */
- int upage = ctob(mproc.p_addr[cc]);
- lseek(mem,upage,0);
- if (read(mem,((int *)&u)+INTPPG*cc,NBPG) != NBPG)
- return(0);
+ if (cp > dbuf.d_name && isdigit(cp[-1]) && isdigit(*cp))
+ x += 10 * (cp[-1] - ' ') + cp[0] - '0';
+ else if (*cp >= 'a' && *cp <= 'f')
+ x += 10 + *cp - 'a';
+ else if (isdigit(*cp))
+ x += *cp - '0';
+ else
+ x = -1;
+donecand:
+ dp = (struct ttys *)alloc(sizeof (struct ttys));
+ strncpy(dp->name, dbuf.d_name, DIRSIZ);
+ dp->next = allttys;
+ dp->ttyd = -1;
+ allttys = dp;
+ if (x == -1)
+ return;
+ x &= 017;
+ dp->cand = cand[x];
+ cand[x] = dp;
+}
+
+char *
+gettty()
+{
+ register char *p;
+ register struct ttys *dp;
+ struct stat stb;
+ int x;
+
+ if (u.u_ttyp == 0)
+ return("?");
+ x = u.u_ttyd & 017;
+ for (dp = cand[x]; dp; dp = dp->cand) {
+ if (dp->ttyd == -1) {
+ if (stat(dp->name, &stb) == 0 &&
+ (stb.st_mode&S_IFMT)==S_IFCHR)
+ dp->ttyd = stb.st_rdev;
+ else
+ dp->ttyd = -2;
}
+ if (dp->ttyd == u.u_ttyd)
+ goto found;
}
- tp = gettty();
- if (tptr && strcmpn(tptr, tp, 2))
- return(0);
- a = &outargs[npr];
- /* saving com starts here */
- a->o_uid = puid;
- a->o_pid = mproc.p_pid;
- a->o_flag = mproc.p_flag;
- a->o_ppid = mproc.p_ppid;
- a->o_cpu = mproc.p_cpu;
- a->o_pctcpu = 0.0; /* This needs to be fixed later */
- a->o_pri = mproc.p_pri;
- a->o_nice = mproc.p_nice;
- a->o_addr0 = mproc.p_addr[0];
- a->o_dsize = mproc.p_dsize;
- a->o_ssize = mproc.p_ssize;
- a->o_rssize = mproc.p_rssize;
- a->o_swrss = mproc.p_swrss;
- a->o_wchan = mproc.p_wchan;
- a->o_pgrp = mproc.p_pgrp;
- a->o_tty[0] = tp[0];
- a->o_tty[1] = tp[1] ? tp[1] : ' ';
- a->o_ttyd = u.u_ttyd;
- a->o_stat = mproc.p_stat;
- a->o_flag = mproc.p_flag;
- if (a->o_stat==SZOMB) return(1);
- a->o_utime = u.u_utime;
- a->o_stime = u.u_stime;
- a->o_cutime = u.u_cutime;
- a->o_cstime = u.u_cstime;
- a->o_sigs = u.u_signal[SIGINT] + u.u_signal[SIGQUIT];
- a->o_time = mproc.p_time;
- a->o_slptime = mproc.p_slptime;
- a->o_uname[0] = 0;
- if (sflg) {
- for (cp = (char *)u.u_stack; cp < (char *)&u + ctob(UPAGES); cp++)
- if (*cp)
- break;
- a->o_stksize = (int) ((char *)&u + ctob(UPAGES) - cp);
- }
- if (mproc.p_stat==SZOMB) return(1);
- if (vflg) {
- register struct text *xp;
-
- if (mproc.p_textp) {
- xp = &text[mproc.p_textp - (struct text *)nl[5].n_value];
- a->o_xsize = xp->x_size;
- a->o_xrssize = xp->x_rssize;
- } else {
- a->o_xsize = 0;
- a->o_xrssize = 0;
+ /* ick */
+ for (dp = allttys; dp; dp = dp->next) {
+ if (dp->ttyd == -1) {
+ if (stat(dp->name, &stb) == 0)
+ dp->ttyd = stb.st_rdev;
+ else
+ dp->ttyd = -2;
}
- a->o_aveflt = mproc.p_aveflt;
- a->o_minorflt = u.u_minorflt;
- a->o_majorflt = u.u_majorflt;
+ if (dp->ttyd == u.u_ttyd)
+ goto found;
}
- strcpy(a->o_comm, u.u_comm);
- if (cflg)
- return (1);
- a->o_args[0] = 0; /* in case of early return */
- if ((mproc.p_flag & SLOAD) == 0) {
- vstodb(0, 1, &u.u_smap, &db, 1);
- addr = ctob(swplo + db.db_base);
- lseek(swap, addr, 0);
- if (read(swap, abuf, sizeof(abuf)) != sizeof(abuf))
- goto garbage;
+ return ("?");
+found:
+ p = dp->name;
+ if (p[0]=='t' && p[1]=='t' && p[2]=='y')
+ p += 3;
+ return (p);
+}
+
+save()
+{
+ register struct savcom *sp;
+ register struct asav *ap;
+ register char *cp;
+ register struct text *xp;
+ char *ttyp, *cmdp;
+
+ if (mproc->p_stat != SZOMB && getu() == 0)
+ return;
+ ttyp = gettty();
+ if (xflg == 0 && ttyp[0] == '?' || tptr && strcmpn(tptr, ttyp, 2))
+ return;
+ sp = &savcom[npr];
+ cmdp = getcmd();
+ if (cmdp == 0)
+ return;
+ sp->ap = ap = (struct asav *)alloc(sizeof (struct asav));
+ sp->ap->a_cmdp = cmdp;
+#define e(a,b) ap->a = mproc->b
+ e(a_flag, p_flag); e(a_stat, p_stat); e(a_nice, p_nice);
+ e(a_uid, p_uid); e(a_pid, p_pid); e(a_pri, p_pri);
+ e(a_slptime, p_slptime); e(a_time, p_time);
+ ap->a_tty[0] = ttyp[0];
+ ap->a_tty[1] = ttyp[1] ? ttyp[1] : ' ';
+ if (ap->a_stat == SZOMB) {
+ register struct xproc *xp = (struct xproc *)mproc;
+
+ ap->a_cpu = xp->xp_vm.vm_utime + xp->xp_vm.vm_stime;
} else {
- szpt = u.u_pcb.pcb_szpt;
- p0br = kflg ? clear((int)mproc.p_p0br) : (int)mproc.p_p0br;
- cc = Usrptma + (p0br + NBPG*(szpt-1) - usrpt)/NPTEPG;
- lseek(kmem, cc, 0);
- if (read(kmem, &apte, sizeof(apte)) != sizeof(apte))
- goto garbage;
- lseek(mem, ctob(apte.pg_pfnum), 0);
- if (read(mem,pagetbl,sizeof(pagetbl)) != sizeof(pagetbl))
- goto garbage;
- if (pagetbl[NPTEPG-1].pg_fod == 0 && pagetbl[NPTEPG-1].pg_pfnum) {
- lseek(mem,ctob((pagetbl[NPTEPG-1].pg_pfnum)),0);
- if (read(mem,abuf,sizeof(abuf)) != sizeof(abuf))
- goto garbage;
- } else {
- vstodb(0, 1, &u.u_smap, &db, 1);
- addr = ctob(swplo + db.db_base);
- lseek(swap, addr, 0);
- if (read(swap, abuf, sizeof(abuf)) != sizeof(abuf))
- goto garbage;
+ ap->a_size = mproc->p_dsize + mproc->p_ssize;
+ e(a_rss, p_rssize);
+ ap->a_ttyd = u.u_ttyd;
+ ap->a_cpu = u.u_vm.vm_utime + u.u_vm.vm_stime;
+ if (sumcpu)
+ ap->a_cpu += u.u_cvm.vm_utime + u.u_cvm.vm_stime;
+ if (mproc->p_textp && text) {
+ xp = &text[mproc->p_textp -
+ (struct text *)nl[X_TEXT].n_value];
+ ap->a_tsiz = xp->x_size;
+ ap->a_txtrss = xp->x_rssize;
+ ap->a_xccount = xp->x_ccount;
}
}
- abuf[INTPPG] = 0;
- for (ip = &abuf[INTPPG-2]; ip > abuf;) {
- if (*--ip == -1 || *ip == 0) {
- cp = (char *)(ip+1);
- if (*cp==0)
- cp++;
- nbad = 0;
- for (cp1 = cp; cp1 < (char *)&abuf[INTPPG]; cp1++) {
- cc = *cp1&0177;
- if (cc==0)
- *cp1 = ' ';
- else if (cc < ' ' || cc > 0176) {
- if (++nbad >= 5) {
- *cp1++ = ' ';
- break;
- }
- *cp1 = '?';
- } else if (cc=='=') {
- *cp1 = 0;
- while (cp1>cp && *--cp1!=' ')
- *cp1 = 0;
+#undef e
+ ap->a_cpu /= HZ;
+ if (lflg) {
+ register struct lsav *lp;
+
+ sp->sun.lp = lp = (struct lsav *)alloc(sizeof (struct lsav));
+#define e(a,b) lp->a = mproc->b
+ e(l_ppid, p_ppid); e(l_cpu, p_cpu);
+ if (ap->a_stat != SZOMB)
+ e(l_wchan, p_wchan);
+#undef e
+ lp->l_addr = pcbpf;
+ } else if (vflg) {
+ register struct vsav *vp;
+
+ sp->sun.vp = vp = (struct vsav *)alloc(sizeof (struct vsav));
+#define e(a,b) vp->a = mproc->b
+ if (ap->a_stat != SZOMB) {
+ e(v_swrss, p_swrss);
+ vp->v_majflt = u.u_vm.vm_majflt;
+ if (mproc->p_textp)
+ vp->v_txtswrss = xp->x_swrss;
+ }
+ vp->v_pctcpu = pcpu();
+#undef e
+ } else if (uflg)
+ sp->sun.u_pctcpu = pcpu();
+ else if (sflg) {
+ if (ap->a_stat != SZOMB) {
+ for (cp = (char *)u.u_stack;
+ cp < &user.upages[UPAGES][NBPG]; )
+ if (*cp++)
break;
- }
- }
- while (*--cp1==' ')
- *cp1 = 0;
- strcpy(a->o_args, cp);
-garbage:
- cp = a->o_args;
- if (cp[0]=='-'&&cp[1]<=' ' || cp[0]=='?' || cp[0]<=' ') {
- strcat(cp, " (");
- strcat(cp, u.u_comm);
- strcat(cp, ")");
- }
- cp[127] = 0; /* max room in psout is 128 chars */
- if (xflg || gflg || tptr || cp[0]!='-')
- return(1);
- return(0);
+ sp->sun.s_ssiz = (&user.upages[UPAGES][NBPG] - cp);
}
}
- goto garbage;
+ npr++;
}
-prcom(a)
- register struct psout *a;
+double
+pmem(ap)
+ register struct asav *ap;
{
- long tm;
+ double fracmem;
+ int szptudot;
- if (rflg) {
- write(1, a, sizeof (*a));
- return(0);
+ if ((ap->a_flag&SLOAD) == 0)
+ fracmem = 0.0;
+ else {
+ szptudot = UPAGES + clrnd(ctopt(ap->a_size+ap->a_tsiz));
+ fracmem = ((float)ap->a_rss+szptudot)/CLSIZE/ecmx;
+ if (ap->a_xccount)
+ fracmem += ((float)ap->a_txtrss)/CLSIZE/
+ ap->a_xccount/ecmx;
}
- if (lflg) {
- printf("%4x %c", 0xffff & a->o_flag,
- "0SWRIZT"[a->o_stat]);
- printf("%4d", a->o_uid);
- } else if (vflg) {
- switch (a->o_stat) {
-
- case SSLEEP:
- case SSTOP:
- if ((a->o_flag & SLOAD) == 0)
- printf("W");
- else if (a->o_pri >= PZERO)
- printf("S");
- else if (a->o_flag & SPAGE)
- printf("P");
- else
- printf("D");
- break;
+ return (100.0 * fracmem);
+}
- case SRUN:
- case SIDL:
- if (a->o_flag & SLOAD)
- printf("R");
- else
- printf("W");
- break;
+double
+pcpu()
+{
+ time_t time;
+
+ time = mproc->p_time;
+ if (time == 0 || (mproc->p_flag&SLOAD) == 0)
+ return (0.0);
+ if (rawcpu)
+ return (100.0 * mproc->p_pctcpu);
+ return (100.0 * mproc->p_pctcpu / (1.0 - exp(time * log(ccpu))));
+}
+
+getu()
+{
+ struct pte *pteaddr, apte;
+ int pad1; /* avoid hardware botch */
+ struct pte arguutl[UPAGES+CLSIZE];
+ int pad2; /* avoid hardware botch */
+ register int i;
+ int ncl, size;
+
+ size = sflg ? ctob(UPAGES) : sizeof (struct user);
+ if ((mproc->p_flag & SLOAD) == 0) {
+ lseek(swap, ctob(mproc->p_swaddr), 0);
+ if (read(swap, (char *)&user.user, size) != size) {
+ fprintf(stderr, "ps: cant read u for pid %d from %s\n",
+ mproc->p_pid, swapf);
+ return (0);
}
- if (a->o_nice > NZERO)
- printf("N");
- else
- printf(" ");
- } else if (uflg) {
- printf("%-8.8s", a->o_uname);
- }
- if (sflg) {
- printf("%5d", a->o_stksize);
- }
- printf("%6u", a->o_pid);
- if (lflg)
- printf("%6u%4d%4d%4d%6x", a->o_ppid, a->o_cpu&0377,
- a->o_pri, a->o_nice, a->o_addr0);
- else if (uflg)
- printf("%5.1f%4d ", a->o_pctcpu, a->o_nice);
- if (lflg || uflg)
- printf("%4d%5d", a->o_dsize+a->o_ssize, a->o_rssize);
- if (lflg)
- if (a->o_wchan)
- printf("%6x", clear(a->o_wchan));
- else
- printf(" ");
- printf(" %-2.2s", a->o_tty);
- if (a->o_stat==SZOMB) {
- printf(" <defunct>");
- return(1);
- }
- tm = (a->o_utime + a->o_stime + 30)/60;
- printf("%3ld:", tm/60);
- tm %= 60;
- printf(tm<10?"0%ld":"%ld", tm);
- if (vflg) {
-/*
- tm = (a->o_stime + 30) / 60;
- printf(" %2ld:", tm/60);
- tm %= 60;
- printf(tm<10?"0%ld":"%ld", tm);
-*/
- printf("%4d%3d", a->o_time, a->o_slptime);
- }
-#ifdef notdef
- if (0 && lflg==0) { /* 0 == old tflg (print long times) */
- tm = (a->o_cstime + 30)/60;
- printf(" %2ld:", tm/60);
- tm %= 60;
- printf(tm<10?"0%ld":"%ld", tm);
- tm = (a->o_cutime + 30)/60;
- printf(" %2ld:", tm/60);
- tm %= 60;
- printf(tm<10?"0%ld":"%ld", tm);
- }
-#endif
- if (vflg) {
- printf("%7d%7d",a->o_minorflt,a->o_majorflt);
- printf("%5d%4d%4d", a->o_dsize+a->o_ssize, a->o_rssize, a->o_swrss);
- printf("%5d%4d", a->o_xsize, a->o_xrssize);
- printf("%3d", a->o_aveflt);
+ pcbpf = 0;
+ argaddr = 0;
+ return (1);
}
- if (a->o_pid == 0) {
- printf(" swapper");
- return(1);
+ pteaddr = &Usrptma[btokmx(mproc->p_p0br) + mproc->p_szpt - 1];
+ lseek(kmem, kflg ? clear(pteaddr) : (int)pteaddr, 0);
+ if (read(kmem, (char *)&apte, sizeof(apte)) != sizeof(apte)) {
+ printf("ps: cant read indir pte to get u for pid %d from %s\n",
+ mproc->p_pid, swapf);
+ return (0);
}
- if (a->o_pid == 2) {
- printf(" pagedaemon");
- return(1);
+ lseek(mem,
+ ctob(apte.pg_pfnum+1) - (UPAGES+CLSIZE) * sizeof (struct pte), 0);
+ if (read(mem, (char *)arguutl, sizeof(arguutl)) != sizeof(arguutl)) {
+ printf("ps: cant read page table for u of pid %d from %s\n",
+ mproc->p_pid, swapf);
+ return (0);
}
- if (cflg) {
- printf(" %s", a->o_comm);
- return(1);
+ if (arguutl[0].pg_fod == 0 && arguutl[0].pg_pfnum)
+ argaddr = ctob(arguutl[0].pg_pfnum);
+ else
+ argaddr = 0;
+ pcbpf = arguutl[CLSIZE].pg_pfnum;
+ ncl = (size + NBPG*CLSIZE - 1) / (NBPG*CLSIZE);
+ while (--ncl >= 0) {
+ i = ncl * CLSIZE;
+ lseek(mem, ctob(arguutl[CLSIZE+i].pg_pfnum), 0);
+ if (read(mem, user.upages[i], CLSIZE*NBPG) != CLSIZE*NBPG) {
+ printf("ps: cant read page %d of u of pid %d from %s\n",
+ arguutl[CLSIZE+i].pg_pfnum, mproc->p_pid, memf);
+ return(0);
+ }
}
- a -> o_args[argwidth] = 0; /* force it to quit early */
- printf(" %s", a->o_args);
return (1);
}
char *
-gettty()
+getcmd()
{
- register i;
- register char *p;
+ char cmdbuf[BUFSIZ];
+ int pad1; /* avoid hardware botch */
+ union {
+ char argc[CLSIZE*NBPG];
+ int argi[CLSIZE*NBPG/sizeof (int)];
+ } argspac;
+ int pad2; /* avoid hardware botch */
+ register char *cp;
+ register int *ip;
+ char c;
+ int nbad;
+ struct dblock db;
- if (u.u_ttyp==0)
- return("?");
- for (i=0; i<ndev; i++) {
- if (devl[i].dev == u.u_ttyd) {
- p = devl[i].dname;
- if (p[0]=='t' && p[1]=='t' && p[2]=='y')
- p += 3;
- return(p);
+ if (mproc->p_stat == SZOMB || mproc->p_flag&(SSYS|SWEXIT))
+ return ("");
+ if (cflg) {
+ strncpy(cmdbuf, u.u_comm, sizeof (u.u_comm));
+ return (savestr(cmdbuf));
+ }
+ if ((mproc->p_flag & SLOAD) == 0 || argaddr == 0) {
+ vstodb(0, CLSIZE, &u.u_smap, &db, 1);
+ lseek(swap, ctob(db.db_base), 0);
+ if (read(swap, (char *)&argspac, sizeof(argspac))
+ != sizeof(argspac))
+ goto bad;
+ } else {
+ lseek(mem, argaddr, 0);
+ if (read(mem, (char *)&argspac, sizeof (argspac))
+ != sizeof (argspac))
+ goto bad;
+ }
+ ip = &argspac.argi[CLSIZE*NBPG/sizeof (int)];
+ ip -= 2; /* last arg word and .long 0 */
+ while (*--ip)
+ if (ip == argspac.argi)
+ goto retucomm;
+ *(char *)ip = ' ';
+ ip++;
+ nbad = 0;
+ for (cp = (char *)ip; cp < &argspac.argc[CLSIZE*NBPG]; cp++) {
+ c = *cp & 0177;
+ if (c == 0)
+ *cp = ' ';
+ else if (c < ' ' || c > 0176) {
+ if (++nbad >= 5*(eflg+1)) {
+ *cp++ = ' ';
+ break;
+ }
+ *cp = '?';
+ } else if (eflg == 0 && c == '=') {
+ while (*--cp != ' ')
+ if (cp <= (char *)ip)
+ break;
+ break;
}
}
- return("?");
+ *cp = 0;
+ while (*--cp == ' ')
+ *cp = 0;
+ cp = (char *)ip;
+ strncpy(cmdbuf, cp, &argspac.argc[CLSIZE*NBPG] - cp);
+ if (cp[0] == '-' || cp[0] == '?' || cp[0] <= ' ') {
+ strcat(cmdbuf, " (");
+ strncat(cmdbuf, u.u_comm, sizeof(u.u_comm));
+ strcat(cmdbuf, ")");
+ }
+/*
+ if (xflg == 0 && gflg == 0 && tptr == 0 && cp[0] == '-')
+ return (0);
+*/
+ return (savestr(cmdbuf));
+
+bad:
+ fprintf(stderr, "ps: error locating command name for pid %d\n",
+ mproc->p_pid);
+retucomm:
+ strcpy(cmdbuf, " (");
+ strncat(cmdbuf, u.u_comm, sizeof (u.u_comm));
+ strcat(cmdbuf, ")");
+ return (savestr(cmdbuf));
+}
+
+char *lhdr =
+" F UID PID PPID CP PRI NI ADDR SZ RSS WCHAN STAT TT TIME";
+lpr(sp)
+ struct savcom *sp;
+{
+ register struct asav *ap = sp->ap;
+ register struct lsav *lp = sp->sun.lp;
+
+ printf("%6x%4d%6u%6u%3d%4d%3d%5x%4d%5d",
+ ap->a_flag, ap->a_uid,
+ ap->a_pid, lp->l_ppid, lp->l_cpu&0377, ap->a_pri-PZERO,
+ ap->a_nice-NZERO, lp->l_addr, ap->a_size/2, ap->a_rss/2);
+ printf(lp->l_wchan ? " %5x" : " ", (int)lp->l_wchan&0xfffff);
+ printf(" %4.4s ", state(ap));
+ ptty(ap->a_tty);
+ ptime(ap);
+}
+
+ptty(tp)
+ char *tp;
+{
+
+ printf("%-2.2s", tp);
+}
+
+ptime(ap)
+ struct asav *ap;
+{
+
+ printf("%3ld:%02ld", ap->a_cpu / HZ, ap->a_cpu % HZ);
+}
+
+char *uhdr =
+"USER PID %CPU %MEM SZ RSS TT STAT TIME";
+upr(sp)
+ struct savcom *sp;
+{
+ register struct asav *ap = sp->ap;
+ int vmsize, rmsize;
+
+ vmsize = (ap->a_size + ap->a_tsiz)/2;
+ rmsize = ap->a_rss/2;
+ if (ap->a_xccount)
+ rmsize += ap->a_txtrss/ap->a_xccount/2;
+ printf("%-8.8s %5d%5.1f%5.1f%5d%5d",
+ getname(ap->a_uid), ap->a_pid, sp->sun.u_pctcpu, pmem(ap),
+ vmsize, rmsize);
+ putchar(' ');
+ ptty(ap->a_tty);
+ printf(" %4.4s", state(ap));
+ ptime(ap);
+}
+
+char *vhdr =
+" PID TT STAT TIME SL RE PAGEIN SIZE RSS SRS TSIZ TRS %CPU %MEM";
+vpr(sp)
+ struct savcom *sp;
+{
+ register struct vsav *vp = sp->sun.vp;
+ register struct asav *ap = sp->ap;
+
+ printf("%5u ", ap->a_pid);
+ ptty(ap->a_tty);
+ printf(" %4.4s", state(ap));
+ ptime(ap);
+ printf("%3d%3d%7d%5d%5d%5d%5d%4d%5.1f%5.1f",
+ ap->a_slptime, ap->a_time > 99 ? 99 : ap->a_time, vp->v_majflt,
+ ap->a_size/2, ap->a_rss/2, vp->v_swrss/2,
+ ap->a_tsiz/2, ap->a_txtrss/2, vp->v_pctcpu, pmem(ap));
+}
+
+char *shdr =
+"SSIZ PID TT STAT TIME";
+spr(sp)
+ struct savcom *sp;
+{
+ register struct asav *ap = sp->ap;
+
+ if (sflg)
+ printf("%4d ", sp->sun.s_ssiz);
+ printf("%5u", ap->a_pid);
+ putchar(' ');
+ ptty(ap->a_tty);
+ printf(" %4.4s", state(ap));
+ ptime(ap);
+}
+
+char *
+state(ap)
+ register struct asav *ap;
+{
+ char stat, load, nice, anom;
+ static char res[5];
+
+ switch (ap->a_stat) {
+
+ case SSTOP:
+ stat = 'T';
+ break;
+
+ case SSLEEP:
+ if (ap->a_pri >= PZERO)
+ if (ap->a_slptime >= MAXSLP)
+ stat = 'I';
+ else
+ stat = 'S';
+ else if (ap->a_flag & SPAGE)
+ stat = 'P';
+ else
+ stat = 'D';
+ break;
+
+ case SWAIT:
+ case SRUN:
+ case SIDL:
+ stat = 'R';
+ break;
+
+ case SZOMB:
+ stat = 'Z';
+ break;
+
+ default:
+ stat = '?';
+ }
+ load = ap->a_flag & SLOAD ? ' ' : 'W';
+ if (ap->a_nice < NZERO)
+ nice = '<';
+ else if (ap->a_nice > NZERO)
+ nice = 'N';
+ else
+ nice = ' ';
+ anom = ap->a_flag & (SANOM|SUANOM) ? 'A' : ' ';
+ res[0] = stat; res[1] = load; res[2] = nice; res[3] = anom;
+ return (res);
}
/*
dbp->db_base = *ip + (rev ? blk - (vsbase + dbp->db_size) : vsbase);
}
+/*ARGSUSED*/
panic(cp)
char *cp;
{
return (a < b ? a : b);
}
-done(exitno)
+pscomp(s1, s2)
+ struct savcom *s1, *s2;
{
- if (login) {
- printf("Press return when done: ");
- getchar();
- }
- exit(exitno);
+ register int i;
+
+ if (uflg)
+ return (s2->sun.u_pctcpu > s1->sun.u_pctcpu ? 1 : -1);
+ if (vflg)
+ return (vsize(s2) - vsize(s1));
+ i = s1->ap->a_ttyd - s2->ap->a_ttyd;
+ if (i == 0)
+ i = s1->ap->a_pid - s2->ap->a_pid;
+ return (i);
+}
+
+vsize(sp)
+ struct savcom *sp;
+{
+ register struct asav *ap = sp->ap;
+ register struct vsav *vp = sp->sun.vp;
+
+ if (ap->a_flag & SLOAD)
+ return (ap->a_rss +
+ ap->a_txtrss / (ap->a_xccount ? ap->a_xccount : 1));
+ return (vp->v_swrss + (ap->a_xccount ? 0 : vp->v_txtswrss));
}
+#define NMAX 8
+#define NUID 2048
+
+char names[NUID][NMAX+1];
+
/*
- * fixup figures out everybodys name and sorts into a nice order.
+ * Stolen from ls...
*/
-fixup(np) int np; {
- register int i;
+char *
+getname(uid)
+{
register struct passwd *pw;
+ static init;
struct passwd *getpwent();
- if (uflg) {
- /*
- * If we want names, traverse the password file. For each
- * passwd entry, look for it in the processes.
- * In case of multiple entries in /etc/passwd, we believe
- * the first one (same thing ls does).
- */
- while ((pw=getpwent()) != NULL) {
- for (i=0; i<np; i++)
- if (outargs[i].o_uid == pw -> pw_uid) {
- if (outargs[i].o_uname[0] == 0)
- strcpy(outargs[i].o_uname, pw -> pw_name);
- }
- }
+ if (uid >= 0 && uid < NUID && names[uid][0])
+ return (&names[uid][0]);
+ if (init == 2)
+ return (0);
+ if (init == 0)
+ setpwent(), init = 1;
+ while (pw = getpwent()) {
+ if (pw->pw_uid >= NUID)
+ continue;
+ if (names[pw->pw_uid][0])
+ continue;
+ strncpy(names[pw->pw_uid], pw->pw_name, NMAX);
+ if (pw->pw_uid == uid)
+ return (&names[uid][0]);
}
+ init = 2;
+ endpwent();
+ return (0);
+}
- qsort(outargs, np, sizeof(outargs[0]), pscomp);
+char *freebase;
+int nleft;
+
+char *
+alloc(size)
+ int size;
+{
+ register char *cp;
+ register int i;
+
+ if (size > nleft) {
+ freebase = (char *)sbrk(i = size > 2048 ? size : 2048);
+ if (freebase == 0) {
+ fprintf(stderr, "ps: ran out of memory\n");
+ exit(1);
+ }
+ nleft = i - size;
+ } else
+ nleft -= size;
+ cp = freebase;
+ for (i = size; --i >= 0; )
+ *cp++ = 0;
+ freebase = cp;
+ return (cp - size);
}
-pscomp(x1, x2) struct psout *x1, *x2; {
- register int c;
+char *
+savestr(cp)
+ char *cp;
+{
+ register int len;
+ register char *dp;
- c = (x1)->o_ttyd - (x2)->o_ttyd;
- if (c==0) c = (x1)->o_pid - (x2)->o_pid;
- return(c);
+ len = strlen(cp);
+ dp = (char *)alloc(len+1);
+ strcpy(dp, cp);
+ return (dp);
}