X-Git-Url: https://git.subgeniuskitty.com/unix-history/.git/blobdiff_plain/3d9f6a3506111d2a150a01e5757725164b415bfd..c223880f1d3c80acd7d7e3388e1d2cce1e225fa5:/usr/src/bin/ps/ps.c diff --git a/usr/src/bin/ps/ps.c b/usr/src/bin/ps/ps.c index 11414d99c3..832f79e20d 100644 --- a/usr/src/bin/ps/ps.c +++ b/usr/src/bin/ps/ps.c @@ -1,61 +1,109 @@ -#ifndef lint -static char *sccsid = "@(#)ps.c 4.17 (Berkeley) %G%"; -#endif - /* - * ps + * Copyright (c) 1980 Regents of the University of California. + * All rights reserved. The Berkeley software License Agreement + * specifies the terms and conditions for redistribution. */ +#ifndef lint +char copyright[] = +"@(#) Copyright (c) 1980 Regents of the University of California.\n\ + All rights reserved.\n"; +#endif not lint + +#ifndef lint +static char sccsid[] = "@(#)ps.c 5.4 (Berkeley) %G%"; +#endif not lint + #include #include -#include +#include #include #include +#include #include -#include +#include #include #include -#include +#include #include #include #include +#include #include -#include +#include -struct nlist nl[] = { - { "_proc" }, +char *nl_names[] = { + "_proc", #define X_PROC 0 - { "_Usrptmap" }, -#define X_USRPTMA 1 - { "_usrpt" }, + "_Usrptmap", +#define X_USRPTMAP 1 + "_usrpt", #define X_USRPT 2 - { "_text" }, + "_text", #define X_TEXT 3 - { "_nswap" }, + "_nswap", #define X_NSWAP 4 - { "_maxslp" }, + "_maxslp", #define X_MAXSLP 5 - { "_ccpu" }, + "_ccpu", #define X_CCPU 6 - { "_ecmx" }, + "_ecmx", #define X_ECMX 7 - { "_nproc" }, + "_nproc", #define X_NPROC 8 - { "_ntext" }, + "_ntext", #define X_NTEXT 9 - { "_hz" }, -#define X_HZ 10 - { 0 }, + "_dmmin", +#define X_DMMIN 10 + "_dmmax", +#define X_DMMAX 11 + "_Sysmap", +#define X_SYSMAP 12 + "_Syssize", +#define X_SYSSIZE 13 + "_inode", +#define X_INODE 14 + "_file", +#define X_FILE 15 + "_cfree", +#define X_CFREE 16 + "_callout", +#define X_CALLOUT 17 + "_swapmap", +#define X_SWAPMAP 18 + "_argmap", +#define X_ARGMAP 19 + "_kernelmap", +#define X_KERNELMAP 20 + "_mbmap", +#define X_MBMAP 21 + "_nch", +#define X_NCH 22 + "_quota", +#define X_QUOTA 23 + "_dquot", +#define X_DQUOT 24 + "_swbuf", +#define X_SWBUF 25 + "_buf", +#define X_BUF 26 + "_cmap", +#define X_CMAP 27 + "_buffers", +#define X_BUFFERS 28 + "" }; +struct nlist *nl; /* all because we can't init unions */ +int nllen; /* # of nlist entries */ + struct savcom { union { struct lsav *lp; float u_pctcpu; struct vsav *vp; int s_ssiz; - struct sssav *ssp; - } sun; + } s_un; struct asav *ap; } *savcom; @@ -72,6 +120,7 @@ struct asav { }; char *lhdr; +int wcwidth; /* width of the wchan field for sprintf*/ struct lsav { short l_ppid; char l_cpu; @@ -79,13 +128,6 @@ struct lsav { caddr_t l_wchan; }; -char *sshdr; -struct sssav { - short ss_ppid; - short ss_brother; - short ss_sons; -}; - char *uhdr; char *shdr; @@ -96,7 +138,9 @@ struct vsav { float v_pctcpu; }; -struct proc proc[8]; /* 8 = a few, for less syscalls */ +#define NPROC 16 + +struct proc proc[NPROC]; /* a few, for less syscalls */ struct proc *mproc; struct text *text; @@ -106,42 +150,94 @@ union { } user; #define u user.user -#define clear(x) ((int)x & 0x7fffffff) +#ifndef PSFILE +char *psdb = "/etc/psdatabase"; +#else +char *psdb = PSFILE; +#endif int chkpid; -int aflg, cflg, eflg, gflg, kflg, lflg, sflg, ssflg, - nonssflg, uflg, vflg, xflg; +int aflg, cflg, eflg, gflg, kflg, lflg, nflg, sflg, + uflg, vflg, xflg, Uflg; +int nchans; /* total # of wait channels */ char *tptr; -char *gettty(), *getcmd(), *getname(), *savestr(), *alloc(), *state(); +char *gettty(), *getcmd(), *getname(), *savestr(), *state(); char *rindex(), *calloc(), *sbrk(), *strcpy(), *strcat(), *strncat(); +char *strncpy(), *index(), *ttyname(), mytty[MAXPATHLEN+1]; +char *malloc(), *getchan(); long lseek(); +off_t vtophys(); double pcpu(), pmem(); +int wchancomp(); int pscomp(); int nswap, maxslp; struct text *atext; double ccpu; int ecmx; -struct pte *Usrptma, *usrpt; -int nproc, ntext, hz; +struct pte *Usrptmap, *usrpt; +int nproc, ntext; +int dmmin, dmmax; +struct pte *Sysmap; +int Syssize; + +int nttys; struct ttys { - char name[MAXNAMLEN+1]; dev_t ttyd; - struct ttys *next; - struct ttys *cand; -} *allttys, *cand[16]; + int cand; + char name[MAXNAMLEN+1]; +} *allttys; +int cand[16] = {-1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1}; +struct lttys { + struct ttys ttys; + struct lttys *next; +} *lallttys; + +/* + * struct for the symbolic wait channel info + * + * WNAMESIZ is the max # of chars saved of the symbolic wchan gleaned + * from the namelist. Normally, only WSNAMESIZ are printed in the long + * format, unless the terminal width is greater than WTSIZ wide. + */ +#define WNAMESIZ 12 +#define WSNAMESIZ 6 +#define WTSIZ 95 + +struct wchan { + char wc_name[WNAMESIZ+1]; /* symbolic name */ + caddr_t wc_caddr; /* addr in kmem */ +} *wchanhd; /* an array sorted by wc_caddr */ + +#define NWCINDEX 10 /* the size of the index array */ + +caddr_t wchan_index[NWCINDEX]; /* used to speed searches */ +/* + * names listed here are not kept as wait channels -- this is used to + * remove names that confuse ps, like symbols that define the end of an + * array that happen to be equal to the next symbol. + */ +char *wchan_stop_list[] = { + "umbabeg", + "umbaend", + "calimit", + NULL +}; int npr; int cmdstart; int twidth; +struct winsize win; char *kmemf, *memf, *swapf, *nlistf; -int kmem, mem, swap; +int kmem, mem, swap = -1; int rawcpu, sumcpu; int pcbpf; int argaddr; -extern char _sobuf[]; + +#define pgtok(a) ((a)/(1024/NBPG)) main(argc, argv) char **argv; @@ -150,71 +246,78 @@ main(argc, argv) register char *ap; int uid; off_t procp; + int width; - if (chdir("/dev") < 0) { - perror("/dev"); - exit(1); - } - twidth = 80; - - if (ap = rindex(argv[0], '/')) - ap++; + if (ioctl(0, TIOCGWINSZ, &win) == -1) + twidth = 80; else - ap = argv[0]; - if (*ap == 's') /* If name starts with 's' */ - ssflg++; - + twidth = (win.ws_col == 0 ? 80 : win.ws_col); argc--, argv++; if (argc > 0) { ap = argv[0]; while (*ap) switch (*ap++) { case 'C': - rawcpu++; nonssflg++; + rawcpu++; break; case 'S': sumcpu++; break; + + case 'U': + Uflg++; + break; + case 'a': aflg++; break; case 'c': - cflg = !cflg; nonssflg++; + cflg = !cflg; break; case 'e': - eflg++; nonssflg++; + eflg++; break; case 'g': - gflg++; nonssflg++; + gflg++; break; case 'k': - kflg++; nonssflg++; + kflg++; break; case 'l': - lflg++; nonssflg++; + lflg++; + break; + case 'n': + nflg++; break; case 's': - sflg++; nonssflg++; + sflg++; break; case 't': if (*ap) tptr = ap; - aflg++; nonssflg++; + else if ((tptr = ttyname(0)) != 0) { + tptr = strcpy(mytty, tptr); + if (strncmp(tptr, "/dev/", 5) == 0) + tptr += 5; + } + if (strncmp(tptr, "tty", 3) == 0) + tptr += 3; + aflg++; gflg++; - if (*tptr == '?') + if (tptr && *tptr == '?') xflg++; while (*ap) ap++; break; case 'u': - uflg++; nonssflg++; + uflg++; break; case 'v': cflg = 1; - vflg++; nonssflg++; + vflg++; break; case 'w': - if (twidth == 80) + if (twidth < 132) twidth = 132; else twidth = BUFSIZ; @@ -222,45 +325,33 @@ main(argc, argv) case 'x': xflg++; break; - case 'y': /* Rand 2/81 */ - ssflg++; - break; default: if (!isdigit(ap[-1])) break; chkpid = atoi(--ap); *ap = 0; - aflg++; nonssflg++; + aflg++; xflg++; break; } } - if (ssflg) { - if (nonssflg) { - fprintf (stderr, "Usage: ss [axwS]\n"); - exit(1); - } - uflg++; - gflg++; - } - openfiles(argc, argv); getkvars(argc, argv); - getdev(); uid = getuid(); printhdr(); procp = getw(nl[X_PROC].n_value); nproc = getw(nl[X_NPROC].n_value); - hz = getw(nl[X_HZ].n_value); - savcom = (struct savcom *)calloc(nproc, sizeof (*savcom)); - for (i=0; i 8) - j = 8; + if (j > NPROC) + j = NPROC; j *= sizeof (struct proc); - if (read(kmem, (char *)proc, j) != j) + if (read(kmem, (char *)proc, j) != j) { cantread("proc table", kmemf); + exit(1); + } procp += j; for (j = j / sizeof (struct proc) - 1; j >= 0; j--) { mproc = &proc[j]; @@ -270,8 +361,9 @@ main(argc, argv) if (tptr == 0 && gflg == 0 && xflg == 0 && mproc->p_ppid == 1) continue; - if (uid != mproc->p_uid && aflg==0 || - chkpid != 0 && chkpid != mproc->p_pid) + if (uid != mproc->p_uid && aflg==0) + continue; + if (chkpid != 0 && chkpid != mproc->p_pid) continue; if (vflg && gflg == 0 && xflg == 0) { if (mproc->p_stat == SZOMB || @@ -285,11 +377,10 @@ main(argc, argv) save(); } } - qsort(savcom, npr, sizeof(savcom[0]), pscomp); - if (ssflg) { - walk(npr); - exit (npr == 0); - } + width = twidth - cmdstart - 2; + if (width < 0) + width = 0; + qsort((char *) savcom, npr, sizeof(savcom[0]), pscomp); for (i=0; iap->a_flag & SWEXIT) - printf(" "); - else if (sp->ap->a_stat == SZOMB) + if (sp->ap->a_stat == SZOMB) printf(" "); + else if (sp->ap->a_flag & SWEXIT) + printf(" "); else if (sp->ap->a_pid == 0) printf(" swapper"); else if (sp->ap->a_pid == 2) printf(" pagedaemon"); - else if (sp->ap->a_pid == 3 && sp->ap->a_flag & SSYS) - printf(" ip input"); else printf(" %.*s", twidth - cmdstart - 2, sp->ap->a_cmdp); printf("\n"); @@ -320,7 +409,7 @@ main(argc, argv) getw(loc) unsigned long loc; { - long word; + int word; klseek(kmem, (long)loc, 0); if (read(kmem, (char *)&word, sizeof (word)) != sizeof (word)) @@ -333,19 +422,87 @@ klseek(fd, loc, off) long loc; int off; { - - if (kflg) - loc &= 0x7fffffff; + if (kflg) { + if ((loc = vtophys(loc)) == -1) + return; + } (void) lseek(fd, (long)loc, off); } +writepsdb(unixname) + char *unixname; +{ + register FILE *fp; + struct lttys *lt; + + setgid(getgid()); + setuid(getuid()); + if ((fp = fopen(psdb, "w")) == NULL) { + perror(psdb); + exit(1); + } else + fchmod(fileno(fp), 0644); + fwrite((char *) &nllen, sizeof nllen, 1, fp); + fwrite((char *) nl, sizeof (struct nlist), nllen, fp); + fwrite((char *) cand, sizeof (cand), 1, fp); + fwrite((char *) &nttys, sizeof nttys, 1, fp); + for (lt = lallttys ; lt ; lt = lt->next) + fwrite((char *)<->ttys, sizeof (struct ttys), 1, fp); + fwrite((char *) &nchans, sizeof nchans, 1, fp); + fwrite((char *) wchanhd, sizeof (struct wchan), nchans, fp); + fwrite((char *) wchan_index, sizeof (caddr_t), NWCINDEX, fp); + fwrite(unixname, strlen(unixname) + 1, 1, fp); + fclose(fp); +} + +readpsdb(unixname) + char *unixname; +{ + register i; + register FILE *fp; + char unamebuf[BUFSIZ]; + char *p = unamebuf; + extern int errno; + + if ((fp = fopen(psdb, "r")) == NULL) { + if (errno == ENOENT) + return (0); + perror(psdb); + exit(1); + } + + fread((char *) &nllen, sizeof nllen, 1, fp); + nl = (struct nlist *) malloc (nllen * sizeof (struct nlist)); + fread((char *) nl, sizeof (struct nlist), nllen, fp); + fread((char *) cand, sizeof (cand), 1, fp); + fread((char *) &nttys, sizeof nttys, 1, fp); + allttys = (struct ttys *)malloc(sizeof(struct ttys)*nttys); + if (allttys == NULL) { + fprintf(stderr, "ps: Can't malloc space for tty table\n"); + exit(1); + } + fread((char *) allttys, sizeof (struct ttys), nttys, fp); + fread((char *) &nchans, sizeof nchans, 1, fp); + wchanhd = (struct wchan *) malloc(nchans * sizeof (struct wchan)); + if (wchanhd == NULL) { + fprintf(stderr, "ps: Can't malloc space for wait channels\n"); + nflg++; + fseek(fp, (long) nchans * sizeof (struct wchan), 1); + } else + fread((char *) wchanhd, sizeof (struct wchan), nchans, fp); + fread((char *) wchan_index, sizeof (caddr_t), NWCINDEX, fp); + while ((*p = getc(fp)) != '\0') + p++; + return (strcmp(unixname, unamebuf) == 0); +} + openfiles(argc, argv) char **argv; { - kmemf = "kmem"; + kmemf = "/dev/kmem"; if (kflg) - kmemf = argc > 1 ? argv[1] : "/vmcore"; + kmemf = argc > 2 ? argv[2] : "/vmcore"; kmem = open(kmemf, 0); if (kmem < 0) { perror(kmemf); @@ -355,37 +512,70 @@ openfiles(argc, argv) mem = kmem; memf = kmemf; } else { - memf = "mem"; + memf = "/dev/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); + if (kflg == 0 || argc > 3) { + swapf = argc>3 ? argv[3]: "/dev/drum"; + swap = open(swapf, 0); + if (swap < 0) { + perror(swapf); + exit(1); + } } } getkvars(argc, argv) char **argv; { - register struct nlist *nlp; + int faildb = 0; /* true if psdatabase init failed */ + + nlistf = argc > 1 ? argv[1] : "/vmunix"; + if (Uflg) { + init_nlist(); + nlist(nlistf, nl); + getvchans(); + getdev(); + writepsdb(nlistf); + exit (0); + } else if (!readpsdb(nlistf)) { + init_nlist(); + if (!kflg) + nl[X_SYSMAP].n_un.n_name = ""; + faildb = 1; + nlist(nlistf, nl); + nttys = 0; + getdev(); + } - 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 = clear(nlp->n_value); - Usrptma = (struct pte *)nl[X_USRPTMA].n_value; + if (kflg) { + /* We must do the sys map first because klseek uses it */ + long addr; + + Syssize = nl[X_SYSSIZE].n_value; + Sysmap = (struct pte *) + calloc((unsigned) Syssize, sizeof (struct pte)); + if (Sysmap == NULL) { + fprintf(stderr, "Out of space for Sysmap\n"); + exit(1); + } + addr = (long) nl[X_SYSMAP].n_value; + addr &= ~0x80000000; + (void) lseek(kmem, addr, 0); + read(kmem, (char *) Sysmap, Syssize * sizeof (struct pte)); + } + if (faildb) + getvchans(); usrpt = (struct pte *)nl[X_USRPT].n_value; + Usrptmap = (struct pte *)nl[X_USRPTMAP].n_value; klseek(kmem, (long)nl[X_NSWAP].n_value, 0); if (read(kmem, (char *)&nswap, sizeof (nswap)) != sizeof (nswap)) { cantread("nswap", kmemf); @@ -408,7 +598,8 @@ getkvars(argc, argv) } if (uflg || vflg) { ntext = getw(nl[X_NTEXT].n_value); - text = (struct text *)alloc(ntext * sizeof (struct text)); + text = (struct text *) + calloc((unsigned) ntext, sizeof (struct text)); if (text == 0) { fprintf(stderr, "no room for text table\n"); exit(1); @@ -421,8 +612,47 @@ getkvars(argc, argv) exit(1); } } + dmmin = getw(nl[X_DMMIN].n_value); + dmmax = getw(nl[X_DMMAX].n_value); } +/* + * get the valloc'ed kernel variables for symbolic wait channels + */ +getvchans() +{ + int i, tmp; + + if (nflg) + return; + +#define addv(i) addchan(&nl[i].n_un.n_name[1], getw(nl[i].n_value)) + addv(X_INODE); + addv(X_FILE); + addv(X_PROC); + addv(X_TEXT); + addv(X_CFREE); + addv(X_CALLOUT); + addv(X_SWAPMAP); + addv(X_ARGMAP); + addv(X_KERNELMAP); + addv(X_MBMAP); + addv(X_NCH); + if (nl[X_QUOTA].n_value != 0) { /* these are #ifdef QUOTA */ + addv(X_QUOTA); + addv(X_DQUOT); + } + addv(X_SWBUF); + addv(X_BUF); + addv(X_CMAP); + addv(X_BUFFERS); + qsort(wchanhd, nchans, sizeof (struct wchan), wchancomp); + for (i = 0; i < NWCINDEX; i++) { + tmp = i * nchans; + wchan_index[i] = wchanhd[tmp / NWCINDEX].wc_caddr; + } +#undef addv +} printhdr() { char *hdr; @@ -431,10 +661,29 @@ printhdr() fprintf(stderr, "ps: specify only one of s,l,v and u\n"); exit(1); } - hdr = ssflg ? sshdr : - (lflg ? lhdr : - (vflg ? vhdr : - (uflg ? uhdr : shdr))); + if (lflg) { + if (nflg) + wcwidth = 6; + else if (twidth > WTSIZ) + wcwidth = -WNAMESIZ; + else + wcwidth = -WSNAMESIZ; + if ((hdr = malloc(strlen(lhdr) + WNAMESIZ)) == NULL) { + fprintf(stderr, "ps: out of memory\n"); + exit(1); + } + sprintf(hdr, lhdr, wcwidth, "WCHAN"); + } else if (vflg) + hdr = vhdr; + else if (uflg) { + /* add enough on so that it can hold the sprintf below */ + if ((hdr = malloc(strlen(uhdr) + 10)) == NULL) { + fprintf(stderr, "ps: out of memory\n"); + exit(1); + } + sprintf(hdr, uhdr, nflg ? " UID" : "USER "); + } else + hdr = shdr; if (lflg+vflg+uflg+sflg == 0) hdr += strlen("SSIZ "); cmdstart = strlen(hdr); @@ -446,7 +695,7 @@ cantread(what, fromwhat) char *what, *fromwhat; { - fprintf(stderr, "ps: error reading %s from %s", what, fromwhat); + fprintf(stderr, "ps: error reading %s from %s\n", what, fromwhat); } struct direct *dbuf; @@ -455,7 +704,13 @@ int dialbase; getdev() { register DIR *df; + struct ttys *t; + struct lttys *lt; + if (chdir("/dev") < 0) { + perror("/dev"); + exit(1); + } dialbase = -1; if ((df = opendir(".")) == NULL) { fprintf(stderr, "Can't open . in /dev\n"); @@ -464,6 +719,13 @@ getdev() while ((dbuf = readdir(df)) != NULL) maybetty(); closedir(df); + allttys = (struct ttys *)malloc(sizeof(struct ttys)*nttys); + if (allttys == NULL) { + fprintf(stderr, "ps: Can't malloc space for tty table\n"); + exit(1); + } + for (lt = lallttys, t = allttys; lt ; lt = lt->next, t++) + *t = lt->ttys; } /* @@ -475,7 +737,8 @@ getdev() maybetty() { register char *cp = dbuf->d_name; - register struct ttys *dp; + static struct lttys *dp; + struct lttys *olddp; int x; struct stat stb; @@ -507,10 +770,9 @@ maybetty() 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)) { + if (is(h,p) || is(r,a) || is(u,p) || is(h,k) + || is(r,b) || is(m,t)) { cp += 2; if (isdigit(*cp) && cp[2] == 0) return; @@ -528,6 +790,13 @@ trymem: case 'n': if (!strcmp(cp, "null")) return; + if (!strncmp(cp, "nrmt", 4)) + return; + break; + + case 'p': + if (cp[1] && cp[1] == 't' && cp[2] == 'y') + return; break; case 'v': @@ -559,16 +828,40 @@ trymem: else x = -1; donecand: - dp = (struct ttys *)alloc(sizeof (struct ttys)); - (void) strcpy(dp->name, dbuf->d_name); - dp->next = allttys; - dp->ttyd = -1; - allttys = dp; + olddp = dp; + dp = (struct lttys *)malloc(sizeof(struct lttys)); + if (dp == NULL) { + fprintf(stderr, "ps: Can't malloc space for tty table\n"); + exit(1); + } + if (lallttys == NULL) + lallttys = dp; + nttys++; + if (olddp) + olddp->next = dp; + dp->next = NULL; + (void) strcpy(dp->ttys.name, dbuf->d_name); + if (Uflg) { + if (stat(dp->ttys.name, &stb) == 0 && + (stb.st_mode&S_IFMT)==S_IFCHR) + dp->ttys.ttyd = x = stb.st_rdev; + else { + nttys--; + if (lallttys == dp) + lallttys = NULL; + free(dp); + dp = olddp; + if (dp) + dp->next = NULL; + return; + } + } else + dp->ttys.ttyd = -1; if (x == -1) return; x &= 017; - dp->cand = cand[x]; - cand[x] = dp; + dp->ttys.cand = cand[x]; + cand[x] = nttys-1; } char * @@ -582,7 +875,8 @@ gettty() if (u.u_ttyp == 0) return("?"); x = u.u_ttyd & 017; - for (dp = cand[x]; dp; dp = dp->cand) { + for (dp = &allttys[cand[x]]; dp != &allttys[-1]; + dp = &allttys[dp->cand]) { if (dp->ttyd == -1) { if (stat(dp->name, &stb) == 0 && (stb.st_mode&S_IFMT)==S_IFCHR) @@ -594,7 +888,7 @@ gettty() goto found; } /* ick */ - for (dp = allttys; dp; dp = dp->next) { + for (dp = allttys; dp < &allttys[nttys]; dp++) { if (dp->ttyd == -1) { if (stat(dp->name, &stb) == 0 && (stb.st_mode&S_IFMT)==S_IFCHR) @@ -630,7 +924,7 @@ save() cmdp = getcmd(); if (cmdp == 0) return; - sp->ap = ap = (struct asav *)alloc(sizeof (struct asav)); + sp->ap = ap = (struct asav *)calloc(1, 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); @@ -639,16 +933,14 @@ save() 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; + ap->a_cpu = 0; } else { 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; + ap->a_cpu = u.u_ru.ru_utime.tv_sec + u.u_ru.ru_stime.tv_sec; if (sumcpu) - ap->a_cpu += u.u_cvm.vm_utime + u.u_cvm.vm_stime; + ap->a_cpu += u.u_cru.ru_utime.tv_sec + u.u_cru.ru_stime.tv_sec; if (mproc->p_textp && text) { xp = &text[mproc->p_textp - atext]; ap->a_tsiz = xp->x_size; @@ -657,12 +949,12 @@ save() } } #undef e - ap->a_cpu /= hz; ap->a_maxrss = mproc->p_maxrss; if (lflg) { register struct lsav *lp; - sp->sun.lp = lp = (struct lsav *)alloc(sizeof (struct lsav)); + sp->s_un.lp = lp = (struct lsav *) + calloc(1, 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) @@ -672,32 +964,26 @@ save() } else if (vflg) { register struct vsav *vp; - sp->sun.vp = vp = (struct vsav *)alloc(sizeof (struct vsav)); + sp->s_un.vp = vp = (struct vsav *) + calloc(1, 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; + vp->v_majflt = u.u_ru.ru_majflt; if (mproc->p_textp) vp->v_txtswrss = xp->x_swrss; } vp->v_pctcpu = pcpu(); #undef e - } else if (uflg) { - if (!ssflg) - sp->sun.u_pctcpu = pcpu(); - else { - register struct sssav *ssp; - - sp->sun.ssp =ssp= (struct sssav *)alloc(sizeof (struct sssav)); - ssp->ss_ppid = mproc->p_ppid; - } - } else if (sflg) { + } else if (uflg) + sp->s_un.u_pctcpu = pcpu(); + else if (sflg) { if (ap->a_stat != SZOMB) { for (cp = (char *)u.u_stack; cp < &user.upages[UPAGES][0]; ) if (*cp++) break; - sp->sun.s_ssiz = (&user.upages[UPAGES][0] - cp); + sp->s_un.s_ssiz = (&user.upages[UPAGES][0] - cp); } } @@ -745,7 +1031,9 @@ getu() size = sflg ? ctob(UPAGES) : sizeof (struct user); if ((mproc->p_flag & SLOAD) == 0) { - (void) lseek(swap, (long)ctob(mproc->p_swaddr), 0); + if (swap < 0) + return (0); + (void) lseek(swap, (long)dtob(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); @@ -755,21 +1043,19 @@ getu() argaddr = 0; return (1); } - if (kflg) - mproc->p_p0br = (struct pte *)clear(mproc->p_p0br); - pteaddr = &Usrptma[btokmx(mproc->p_p0br) + mproc->p_szpt - 1]; + pteaddr = &Usrptmap[btokmx(mproc->p_p0br) + mproc->p_szpt - 1]; klseek(kmem, (long)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); + mproc->p_pid, kmemf); return (0); } - (void) lseek(mem, + lseek(mem, (long)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); + mproc->p_pid, memf); return (0); } if (arguutl[0].pg_fod == 0 && arguutl[0].pg_pfnum) @@ -780,7 +1066,7 @@ getu() ncl = (size + NBPG*CLSIZE - 1) / (NBPG*CLSIZE); while (--ncl >= 0) { i = ncl * CLSIZE; - (void) lseek(mem, (long)ctob(arguutl[CLSIZE+i].pg_pfnum), 0); + lseek(mem, (long)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); @@ -793,7 +1079,7 @@ getu() char * getcmd() { - char cmdbuf[BUFSIZ]; + char cmdbuf[CLSIZE*NBPG]; union { char argc[CLSIZE*NBPG]; int argi[CLSIZE*NBPG/sizeof (int)]; @@ -803,6 +1089,7 @@ getcmd() char c; int nbad; struct dblock db; + char *file; if (mproc->p_stat == SZOMB || mproc->p_flag&(SSYS|SWEXIT)) return (""); @@ -811,16 +1098,20 @@ getcmd() return (savestr(cmdbuf)); } if ((mproc->p_flag & SLOAD) == 0 || argaddr == 0) { + if (swap < 0) + goto retucomm; vstodb(0, CLSIZE, &u.u_smap, &db, 1); - (void) lseek(swap, (long)ctob(db.db_base), 0); + (void) lseek(swap, (long)dtob(db.db_base), 0); if (read(swap, (char *)&argspac, sizeof(argspac)) != sizeof(argspac)) goto bad; + file = swapf; } else { - (void) lseek(mem, (long)argaddr, 0); + lseek(mem, (long)argaddr, 0); if (read(mem, (char *)&argspac, sizeof (argspac)) != sizeof (argspac)) goto bad; + file = memf; } ip = &argspac.argi[CLSIZE*NBPG/sizeof (int)]; ip -= 2; /* last arg word and .long 0 */ @@ -857,15 +1148,11 @@ getcmd() (void) strncat(cmdbuf, u.u_comm, sizeof(u.u_comm)); (void) 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); + fprintf(stderr, "ps: error locating command name for pid %d from %s\n", + mproc->p_pid, file); retucomm: (void) strcpy(cmdbuf, " ("); (void) strncat(cmdbuf, u.u_comm, sizeof (u.u_comm)); @@ -874,18 +1161,23 @@ retucomm: } char *lhdr = -" F UID PID PPID CP PRI NI ADDR SZ RSS WCHAN STAT TT TIME"; +" F UID PID PPID CP PRI NI ADDR SZ RSS %*s STAT TT TIME"; lpr(sp) struct savcom *sp; { register struct asav *ap = sp->ap; - register struct lsav *lp = sp->sun.lp; + register struct lsav *lp = sp->s_un.lp; - printf("%6x%4d%6u%6u%3d%4d%3d%5x%4d%5d", + printf("%7x%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); + ap->a_nice-NZERO, lp->l_addr, pgtok(ap->a_size), pgtok(ap->a_rss)); + if (lp->l_wchan == 0) + printf(" %*s", wcwidth, ""); + else if (nflg) + printf(" %*x", wcwidth, (int)lp->l_wchan&0xffffff); + else + printf(" %*.*s", wcwidth, abs(wcwidth), getchan(lp->l_wchan)); printf(" %4.4s ", state(ap)); ptty(ap->a_tty); ptime(ap); @@ -902,24 +1194,27 @@ ptime(ap) struct asav *ap; { - printf("%3ld:%02ld", ap->a_cpu / hz, ap->a_cpu % hz); + printf("%3ld:%02ld", ap->a_cpu / 60, ap->a_cpu % 60); } char *uhdr = -"USER PID %CPU %MEM SZ RSS TT STAT TIME"; +"%s 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; + vmsize = pgtok((ap->a_size + ap->a_tsiz)); + rmsize = pgtok(ap->a_rss); 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); + rmsize += pgtok(ap->a_txtrss/ap->a_xccount); + if (nflg) + printf("%4d ", ap->a_uid); + else + printf("%-8.8s ", getname(ap->a_uid)); + printf("%5d%5.1f%5.1f%5d%5d", + ap->a_pid, sp->s_un.u_pctcpu, pmem(ap), vmsize, rmsize); putchar(' '); ptty(ap->a_tty); printf(" %4.4s", state(ap)); @@ -927,11 +1222,11 @@ upr(sp) } char *vhdr = -" PID TT STAT TIME SL RE PAGEIN SIZE RSS LIM TSIZ TRS %CPU %MEM"; +" SIZE PID TT STAT TIME SL RE PAGEIN SIZE RSS LIM TSIZ TRS %CPU %MEM"+5; vpr(sp) struct savcom *sp; { - register struct vsav *vp = sp->sun.vp; + register struct vsav *vp = sp->s_un.vp; register struct asav *ap = sp->ap; printf("%5u ", ap->a_pid); @@ -941,13 +1236,13 @@ vpr(sp) printf("%3d%3d%7d%5d%5d", ap->a_slptime > 99 ? 99 : ap-> a_slptime, ap->a_time > 99 ? 99 : ap->a_time, vp->v_majflt, - ap->a_size/2, ap->a_rss/2); - if (ap->a_maxrss == (INFINITY/NBPG)) + pgtok(ap->a_size), pgtok(ap->a_rss)); + if (ap->a_maxrss == (RLIM_INFINITY/NBPG)) printf(" xx"); else - printf("%5d", ap->a_maxrss/2); + printf("%5d", pgtok(ap->a_maxrss)); printf("%5d%4d%5.1f%5.1f", - ap->a_tsiz/2, ap->a_txtrss/2, vp->v_pctcpu, pmem(ap)); + pgtok(ap->a_tsiz), pgtok(ap->a_txtrss), vp->v_pctcpu, pmem(ap)); } char *shdr = @@ -958,7 +1253,7 @@ spr(sp) register struct asav *ap = sp->ap; if (sflg) - printf("%4d ", sp->sun.s_ssiz); + printf("%4d ", sp->s_un.s_ssiz); printf("%5u", ap->a_pid); putchar(' '); ptty(ap->a_tty); @@ -1027,14 +1322,16 @@ vstodb(vsbase, vssize, dmp, dbp, rev) struct dmap *dmp; register struct dblock *dbp; { - register int blk = DMMIN; + register int blk = dmmin; register swblk_t *ip = dmp->dm_map; + vsbase = ctod(vsbase); + vssize = ctod(vssize); if (vsbase < 0 || vsbase + vssize > dmp->dm_size) panic("vstodb"); while (vsbase >= blk) { vsbase -= blk; - if (blk < DMMAX) + if (blk < dmmax) blk *= 2; ip++; } @@ -1065,8 +1362,8 @@ pscomp(s1, s2) { register int i; - if (uflg && !ssflg) - return (s2->sun.u_pctcpu > s1->sun.u_pctcpu ? 1 : -1); + if (uflg) + return (s2->s_un.u_pctcpu > s1->s_un.u_pctcpu ? 1 : -1); if (vflg) return (vsize(s2) - vsize(s1)); i = s1->ap->a_ttyd - s2->ap->a_ttyd; @@ -1079,7 +1376,7 @@ vsize(sp) struct savcom *sp; { register struct asav *ap = sp->ap; - register struct vsav *vp = sp->sun.vp; + register struct vsav *vp = sp->s_un.vp; if (ap->a_flag & SLOAD) return (ap->a_rss + @@ -1087,163 +1384,299 @@ vsize(sp) return (vp->v_swrss + (ap->a_xccount ? 0 : vp->v_txtswrss)); } -#define NMAX 8 -#define NUID 2048 +#include + +struct utmp utmp; +#define NMAX (sizeof (utmp.ut_name)) +#define SCPYN(a, b) strncpy(a, b, NMAX) + +#define NUID 64 -char names[NUID][NMAX+1]; +struct ncache { + int uid; + char name[NMAX+1]; +} nc[NUID]; /* - * Stolen from ls... + * This function assumes that the password file is hashed + * (or some such) to allow fast access based on a uid key. */ char * getname(uid) { register struct passwd *pw; - static init; struct passwd *getpwent(); + register int cp; + extern int _pw_stayopen; - 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; - (void) strncpy(names[pw->pw_uid], pw->pw_name, NMAX); - if (pw->pw_uid == uid) - return (&names[uid][0]); - } - init = 2; - endpwent(); - return (0); -} - -char *freebase; -int nleft; - -char * -alloc(size) - int size; -{ - register char *cp; - register int i; + _pw_stayopen = 1; - if (size > nleft) { - freebase = (char *)sbrk((int)(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); +#if (((NUID) & ((NUID) - 1)) != 0) + cp = uid % (NUID); +#else + cp = uid & ((NUID) - 1); +#endif + if (uid >= 0 && nc[cp].uid == uid && nc[cp].name[0]) + return (nc[cp].name); + pw = getpwuid(uid); + if (!pw) + return (0); + nc[cp].uid = uid; + SCPYN(nc[cp].name, pw->pw_name); + return (nc[cp].name); } char * savestr(cp) char *cp; { - register int len; + register unsigned len; register char *dp; len = strlen(cp); - dp = (char *)alloc(len+1); + dp = (char *)calloc(len+1, sizeof (char)); (void) strcpy(dp, cp); return (dp); } -walk(np) - int np; +/* + * This routine was stolen from adb to simulate memory management + * on the VAX. + */ +off_t +vtophys(loc) +long loc; { - register int i, j, k, l, m; -#undef afl -#undef sfl -#define afl(i,f) savcom[i].ap -> f -#define sfl(i,f) savcom[i].sun.ssp -> f - - for(i = 0; i < np; i = j) { - for(j = i; afl(j,a_ttyd) == afl(i,a_ttyd); j++) { - sfl(j,ss_brother) = -1; - sfl(j,ss_sons) = -1; - } - for(k = i+1; k < j; k++) { - if(sfl(k,ss_ppid) == sfl(i,ss_ppid)) { - for(l=i; sfl(l,ss_brother) != -1; - l=sfl(l,ss_brother)) ; - sfl(l,ss_brother) = k; - goto next; - } - for(l = i; l < j; l++) { - if(l == k) continue; - if(sfl(k,ss_ppid) == afl(l,a_pid)) { - if(sfl(l,ss_sons) == -1) - sfl(l,ss_sons) = k; - else { - for(m = sfl(l,ss_sons); - sfl(m,ss_brother) != -1; - m = sfl(m,ss_brother)) ; - sfl(m,ss_brother) = k; - } - goto next; - } - } - for(l = i; l < j; l++) { - if(l == k) continue; - if(sfl(k,ss_ppid) == sfl(l,ss_ppid)) { - for(m = k; sfl(m,ss_brother) != -1; - m = sfl(m,ss_brother)) ; - sfl(m,ss_brother) = l; + register p; + off_t newloc; + + newloc = loc & ~0xc0000000; + p = btop(newloc); + if ((loc & 0xc0000000) == 0) { + fprintf(stderr, "Vtophys: translating non-kernel address\n"); + return((off_t) -1); + } + if (p >= Syssize) { + fprintf(stderr, "Vtophys: page out of bound (%d>=%d)\n", + p, Syssize); + return((off_t) -1); + } + if (Sysmap[p].pg_v == 0 + && (Sysmap[p].pg_fod || Sysmap[p].pg_pfnum == 0)) { + fprintf(stderr, "Vtophys: page not valid\n"); + return((off_t) -1); + } + loc = (long) (ptob(Sysmap[p].pg_pfnum) + (loc & PGOFSET)); + return(loc); +} + +/* + * since we can't init unions, the cleanest way to use a.out.h instead + * of nlist.h (required since nlist() uses some defines) is to do a + * runtime copy into the nl array -- sigh + */ +init_nlist() +{ + register struct nlist *np; + register char **namep; + + nllen = sizeof nl_names / sizeof (char *); + np = nl = (struct nlist *) malloc(nllen * sizeof (struct nlist)); + if (np == NULL) { + fprintf(stderr, "ps: out of memory allocating namelist\n"); + exit(1); + } + namep = &nl_names[0]; + while (nllen > 0) { + np->n_un.n_name = *namep; + if (**namep == '\0') + break; + namep++; + np++; + } +} + +/* + * nlist - retreive attributes from name list (string table version) + * modified to add wait channels - Charles R. LaBrec 8/85 + */ +nlist(name, list) + char *name; + struct nlist *list; +{ + register struct nlist *p, *q; + register char *s1, *s2; + register n, m; + int maxlen, nreq; + FILE *f; + FILE *sf; + off_t sa; /* symbol address */ + off_t ss; /* start of strings */ + int type; + struct exec buf; + struct nlist space[BUFSIZ/sizeof (struct nlist)]; + char nambuf[BUFSIZ]; + + maxlen = 0; + for (q = list, nreq = 0; q->n_un.n_name && q->n_un.n_name[0]; q++, nreq++) { + q->n_type = 0; + q->n_value = 0; + q->n_desc = 0; + q->n_other = 0; + n = strlen(q->n_un.n_name); + if (n > maxlen) + maxlen = n; + } + f = fopen(name, "r"); + if (f == NULL) + return (-1); + fread((char *)&buf, sizeof buf, 1, f); + if (N_BADMAG(buf)) { + fclose(f); + return (-1); + } + sf = fopen(name, "r"); + if (sf == NULL) { + /* ??? */ + fclose(f); + return(-1); + } + sa = N_SYMOFF(buf); + ss = sa + buf.a_syms; + n = buf.a_syms; + fseek(f, sa, 0); + while (n) { + m = sizeof (space); + if (n < m) + m = n; + if (fread((char *)space, m, 1, f) != 1) + break; + n -= m; + for (q = space; (m -= sizeof(struct nlist)) >= 0; q++) { + if (q->n_un.n_strx == 0 || q->n_type & N_STAB) + continue; + /* + * since we know what type of symbols we will get, + * we can make a quick check here -- crl + */ + type = q->n_type & (N_TYPE | N_EXT); + if ((q->n_type & N_TYPE) != N_ABS + && type != (N_EXT | N_DATA) + && type != (N_EXT | N_BSS)) + continue; + fseek(sf, ss+q->n_un.n_strx, 0); + fread(nambuf, maxlen+1, 1, sf); + /* if using wchans, add it to the list of channels */ + if (!nflg) + addchan(&nambuf[1], (caddr_t) q->n_value); + for (p = list; p->n_un.n_name && p->n_un.n_name[0]; p++) { + s1 = p->n_un.n_name; + s2 = nambuf; + if (strcmp(p->n_un.n_name, nambuf) == 0) { + p->n_value = q->n_value; + p->n_type = q->n_type; + p->n_desc = q->n_desc; + p->n_other = q->n_other; + --nreq; + break; } } - next: ; } - walk1(i, 0); } +alldone: + fclose(f); + fclose(sf); + return (nreq); } -walk1(pno, depth) - int pno, depth; +/* + * add the given channel to the channel list + */ +addchan(name, caddr) +char *name; +caddr_t caddr; { - if(pno == -1) - return; -/*** printf("%5d, %d\n",outargs[pno].o_pid, depth); ***/ - walkpr(&savcom[pno], depth); - walk1(sfl(pno,ss_sons), depth+1); - walk1(sfl(pno,ss_brother), depth); -} + static int left = 0; + register struct wchan *wp; + register char **p; -char *sshdr = -"TTY User SZ RSS CPU S PID "; + for (p = wchan_stop_list; *p; p++) { + if (**p != *name) /* quick check first */ + continue; + if (strncmp(name, *p, WNAMESIZ) == 0) + return; /* if found, don't add */ + } + if (left == 0) { + if (wchanhd) { + left = 100; + wchanhd = (struct wchan *) realloc(wchanhd, + (nchans + left) * sizeof (struct wchan)); + } else { + left = 600; + wchanhd = (struct wchan *) malloc(left + * sizeof (struct wchan)); + } + if (wchanhd == NULL) { + fprintf(stderr, "ps: out of memory allocating wait channels\n"); + nflg++; + return; + } + } + left--; + wp = &wchanhd[nchans++]; + strncpy(wp->wc_name, name, WNAMESIZ); + wp->wc_name[WNAMESIZ] = '\0'; + wp->wc_caddr = caddr; +} -walkpr(a, depth) - register struct savcom *a; - int depth; +/* + * returns the symbolic wait channel corresponding to chan + */ +char * +getchan(chan) +register caddr_t chan; { + register i, iend; + register char *prevsym; + register struct wchan *wp; + + prevsym = "???"; /* nothing, to begin with */ + if (chan) { + for (i = 0; i < NWCINDEX; i++) + if ((unsigned) chan < (unsigned) wchan_index[i]) + break; + iend = i--; + if (i < 0) /* can't be found */ + return prevsym; + iend *= nchans; + iend /= NWCINDEX; + i *= nchans; + i /= NWCINDEX; + wp = &wchanhd[i]; + for ( ; i < iend; i++, wp++) { + if ((unsigned) wp->wc_caddr > (unsigned) chan) + break; + prevsym = wp->wc_name; + } + } + return prevsym; +} - if(!depth) { - printf("%-2.2s", a->ap->a_tty); - printf(" %-8.8s", getname(a->ap->a_uid)); - } else - printf(" %-8s", &".......*"[8-(depth<=8?depth:8)]); - printf("%4d%4d", a->ap->a_size/2, a->ap->a_rss/2); - ptime(a->ap); - /* Once there was a "CCPU" field here. Subsumed by -S now. */ - printf(" %4.4s", state(a->ap)); - printf("%6u ", a->ap->a_pid); - if (a->ap->a_pid == 0) - printf(" swapper"); - else if (a->ap->a_pid == 2) - printf(" pagedaemon"); +/* + * used in sorting the wait channel array + */ +int +wchancomp (w1, w2) +struct wchan *w1, *w2; +{ + register unsigned c1, c2; + + c1 = (unsigned) w1->wc_caddr; + c2 = (unsigned) w2->wc_caddr; + if (c1 > c2) + return 1; + else if (c1 == c2) + return 0; else - printf(" %.*s", twidth - cmdstart - 2, a->ap->a_cmdp); - putchar('\n'); + return -1; }