![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ps.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / bin|
Return to ps.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / bin |
1.1 ! root 1: #ifndef lint ! 2: static char *sccsid = "@(#)ps.c 4.26 (Berkeley) 9/25/83"; ! 3: #endif ! 4: ! 5: /* ! 6: * ps ! 7: */ ! 8: #include <stdio.h> ! 9: #include <ctype.h> ! 10: #include <nlist.h> ! 11: #include <pwd.h> ! 12: #include <sys/param.h> ! 13: #include <sys/tty.h> ! 14: #include <sys/dir.h> ! 15: #include <sys/user.h> ! 16: #include <sys/proc.h> ! 17: #include <machine/pte.h> ! 18: #include <sys/vm.h> ! 19: #include <sys/text.h> ! 20: #include <sys/stat.h> ! 21: #include <sys/mbuf.h> ! 22: #include <math.h> ! 23: ! 24: struct nlist nl[] = { ! 25: { "_proc" }, ! 26: #define X_PROC 0 ! 27: { "_Usrptmap" }, ! 28: #define X_USRPTMA 1 ! 29: { "_usrpt" }, ! 30: #define X_USRPT 2 ! 31: { "_text" }, ! 32: #define X_TEXT 3 ! 33: { "_nswap" }, ! 34: #define X_NSWAP 4 ! 35: { "_maxslp" }, ! 36: #define X_MAXSLP 5 ! 37: { "_ccpu" }, ! 38: #define X_CCPU 6 ! 39: { "_ecmx" }, ! 40: #define X_ECMX 7 ! 41: { "_nproc" }, ! 42: #define X_NPROC 8 ! 43: { "_ntext" }, ! 44: #define X_NTEXT 9 ! 45: { "_dmmin" }, ! 46: #define X_DMMIN 10 ! 47: { "_dmmax" }, ! 48: #define X_DMMAX 11 ! 49: { "_Sysmap" }, ! 50: #define X_SYSMAP 12 ! 51: { "_Syssize" }, ! 52: #define X_SYSSIZE 13 ! 53: { "" }, ! 54: }; ! 55: ! 56: struct savcom { ! 57: union { ! 58: struct lsav *lp; ! 59: float u_pctcpu; ! 60: struct vsav *vp; ! 61: int s_ssiz; ! 62: } s_un; ! 63: struct asav *ap; ! 64: } *savcom; ! 65: ! 66: struct asav { ! 67: char *a_cmdp; ! 68: int a_flag; ! 69: short a_stat, a_uid, a_pid, a_nice, a_pri, a_slptime, a_time; ! 70: size_t a_size, a_rss, a_tsiz, a_txtrss; ! 71: short a_xccount; ! 72: char a_tty[MAXNAMLEN+1]; ! 73: dev_t a_ttyd; ! 74: time_t a_cpu; ! 75: size_t a_maxrss; ! 76: }; ! 77: ! 78: char *lhdr; ! 79: struct lsav { ! 80: short l_ppid; ! 81: char l_cpu; ! 82: int l_addr; ! 83: caddr_t l_wchan; ! 84: }; ! 85: ! 86: char *uhdr; ! 87: char *shdr; ! 88: ! 89: char *vhdr; ! 90: struct vsav { ! 91: u_int v_majflt; ! 92: size_t v_swrss, v_txtswrss; ! 93: float v_pctcpu; ! 94: }; ! 95: ! 96: struct proc proc[8]; /* 8 = a few, for less syscalls */ ! 97: struct proc *mproc; ! 98: struct text *text; ! 99: ! 100: union { ! 101: struct user user; ! 102: char upages[UPAGES][NBPG]; ! 103: } user; ! 104: #define u user.user ! 105: ! 106: int chkpid; ! 107: int aflg, cflg, eflg, gflg, kflg, lflg, sflg, ! 108: uflg, vflg, xflg; ! 109: char *tptr; ! 110: char *gettty(), *getcmd(), *getname(), *savestr(), *alloc(), *state(); ! 111: char *rindex(), *calloc(), *sbrk(), *strcpy(), *strcat(), *strncat(); ! 112: char *index(), *ttyname(), mytty[16]; ! 113: long lseek(); ! 114: double pcpu(), pmem(); ! 115: int pscomp(); ! 116: int nswap, maxslp; ! 117: struct text *atext; ! 118: double ccpu; ! 119: int ecmx; ! 120: struct pte *Usrptma, *usrpt; ! 121: int nproc, ntext; ! 122: int dmmin, dmmax; ! 123: ! 124: struct ttys { ! 125: char name[MAXNAMLEN+1]; ! 126: dev_t ttyd; ! 127: struct ttys *next; ! 128: struct ttys *cand; ! 129: } *allttys, *cand[16]; ! 130: ! 131: int npr; ! 132: ! 133: int cmdstart; ! 134: int twidth; ! 135: char *kmemf, *memf, *swapf, *nlistf; ! 136: int kmem, mem, swap = -1; ! 137: int rawcpu, sumcpu; ! 138: ! 139: int pcbpf; ! 140: int argaddr; ! 141: extern char _sobuf[]; ! 142: ! 143: #define pgtok(a) ((a)/(1024/NBPG)) ! 144: ! 145: main(argc, argv) ! 146: char **argv; ! 147: { ! 148: register int i, j; ! 149: register char *ap; ! 150: int uid; ! 151: off_t procp; ! 152: ! 153: twidth = 80; ! 154: argc--, argv++; ! 155: if (argc > 0) { ! 156: ap = argv[0]; ! 157: while (*ap) switch (*ap++) { ! 158: ! 159: case 'C': ! 160: rawcpu++; ! 161: break; ! 162: case 'S': ! 163: sumcpu++; ! 164: break; ! 165: case 'a': ! 166: aflg++; ! 167: break; ! 168: case 'c': ! 169: cflg = !cflg; ! 170: break; ! 171: case 'e': ! 172: eflg++; ! 173: break; ! 174: case 'g': ! 175: gflg++; ! 176: break; ! 177: case 'k': ! 178: kflg++; ! 179: break; ! 180: case 'l': ! 181: lflg++; ! 182: break; ! 183: case 's': ! 184: sflg++; ! 185: break; ! 186: case 't': ! 187: if (*ap) ! 188: tptr = ap; ! 189: else if ((tptr = ttyname(2)) != 0) { ! 190: strcpy(mytty, tptr); ! 191: if ((tptr = index(mytty,'y')) != 0) ! 192: tptr++; ! 193: } ! 194: aflg++; ! 195: gflg++; ! 196: if (tptr && *tptr == '?') ! 197: xflg++; ! 198: while (*ap) ! 199: ap++; ! 200: break; ! 201: case 'u': ! 202: uflg++; ! 203: break; ! 204: case 'v': ! 205: cflg = 1; ! 206: vflg++; ! 207: break; ! 208: case 'w': ! 209: if (twidth == 80) ! 210: twidth = 132; ! 211: else ! 212: twidth = BUFSIZ; ! 213: break; ! 214: case 'x': ! 215: xflg++; ! 216: break; ! 217: default: ! 218: if (!isdigit(ap[-1])) ! 219: break; ! 220: chkpid = atoi(--ap); ! 221: *ap = 0; ! 222: aflg++; ! 223: xflg++; ! 224: break; ! 225: } ! 226: } ! 227: openfiles(argc, argv); ! 228: getkvars(argc, argv); ! 229: if (chdir("/dev") < 0) { ! 230: perror("/dev"); ! 231: exit(1); ! 232: } ! 233: getdev(); ! 234: uid = getuid(); ! 235: printhdr(); ! 236: procp = getw(nl[X_PROC].n_value); ! 237: nproc = getw(nl[X_NPROC].n_value); ! 238: savcom = (struct savcom *)calloc(nproc, sizeof (*savcom)); ! 239: for (i=0; i<nproc; i += 8) { ! 240: klseek(kmem, (long)procp, 0); ! 241: j = nproc - i; ! 242: if (j > 8) ! 243: j = 8; ! 244: j *= sizeof (struct proc); ! 245: if (read(kmem, (char *)proc, j) != j) { ! 246: cantread("proc table", kmemf); ! 247: exit(1); ! 248: } ! 249: procp += j; ! 250: for (j = j / sizeof (struct proc) - 1; j >= 0; j--) { ! 251: mproc = &proc[j]; ! 252: if (mproc->p_stat == 0 || ! 253: mproc->p_pgrp == 0 && xflg == 0) ! 254: continue; ! 255: if (tptr == 0 && gflg == 0 && xflg == 0 && ! 256: mproc->p_ppid == 1) ! 257: continue; ! 258: if (uid != mproc->p_uid && aflg==0 || ! 259: chkpid != 0 && chkpid != mproc->p_pid) ! 260: continue; ! 261: if (vflg && gflg == 0 && xflg == 0) { ! 262: if (mproc->p_stat == SZOMB || ! 263: mproc->p_flag&SWEXIT) ! 264: continue; ! 265: if (mproc->p_slptime > MAXSLP && ! 266: (mproc->p_stat == SSLEEP || ! 267: mproc->p_stat == SSTOP)) ! 268: continue; ! 269: } ! 270: save(); ! 271: } ! 272: } ! 273: qsort(savcom, npr, sizeof(savcom[0]), pscomp); ! 274: for (i=0; i<npr; i++) { ! 275: register struct savcom *sp = &savcom[i]; ! 276: if (lflg) ! 277: lpr(sp); ! 278: else if (vflg) ! 279: vpr(sp); ! 280: else if (uflg) ! 281: upr(sp); ! 282: else ! 283: spr(sp); ! 284: if (sp->ap->a_flag & SWEXIT) ! 285: printf(" <exiting>"); ! 286: else if (sp->ap->a_stat == SZOMB) ! 287: printf(" <defunct>"); ! 288: else if (sp->ap->a_pid == 0) ! 289: printf(" swapper"); ! 290: else if (sp->ap->a_pid == 2) ! 291: printf(" pagedaemon"); ! 292: else if (sp->ap->a_pid == 3 && sp->ap->a_flag & SSYS) ! 293: printf(" ip input"); ! 294: else ! 295: printf(" %.*s", twidth - cmdstart - 2, sp->ap->a_cmdp); ! 296: printf("\n"); ! 297: } ! 298: exit(npr == 0); ! 299: } ! 300: ! 301: getw(loc) ! 302: unsigned long loc; ! 303: { ! 304: long word; ! 305: ! 306: klseek(kmem, (long)loc, 0); ! 307: if (read(kmem, (char *)&word, sizeof (word)) != sizeof (word)) ! 308: printf("error reading kmem at %x\n", loc); ! 309: return (word); ! 310: } ! 311: ! 312: klseek(fd, loc, off) ! 313: int fd; ! 314: long loc; ! 315: int off; ! 316: { ! 317: ! 318: long v; ! 319: long addr; ! 320: struct pte pte; ! 321: ! 322: if (kflg && (loc & 0xc0000000) != 0) { ! 323: loc &= ~0xc0000000; ! 324: v = btop(loc); ! 325: if(v >= nl[X_SYSSIZE].n_value) { ! 326: printf("address botch %x\n", loc); ! 327: return; ! 328: } ! 329: addr = (long)((struct pte *)nl[X_SYSMAP].n_value + v); ! 330: lseek(fd, addr & ~0xc0000000, 0); ! 331: if(read(fd, (char *)&pte, sizeof(pte)) != sizeof(pte)) { ! 332: printf("Error reading kmem for pte at %x\n", addr); ! 333: return; ! 334: } ! 335: if (pte.pg_v == 0 && (pte.pg_fod || pte.pg_pfnum == 0)) { ! 336: printf("pte bad for %x\n", addr); ! 337: return; ! 338: } ! 339: loc = (long)ptob(pte.pg_pfnum) + (loc & PGOFSET); ! 340: } ! 341: (void) lseek(fd, (long)loc, off); ! 342: } ! 343: ! 344: openfiles(argc, argv) ! 345: char **argv; ! 346: { ! 347: ! 348: kmemf = "/dev/kmem"; ! 349: if (kflg) ! 350: kmemf = argc > 2 ? argv[2] : "/vmcore"; ! 351: kmem = open(kmemf, 0); ! 352: if (kmem < 0) { ! 353: perror(kmemf); ! 354: exit(1); ! 355: } ! 356: if (kflg) { ! 357: mem = kmem; ! 358: memf = kmemf; ! 359: } else { ! 360: memf = "/dev/mem"; ! 361: mem = open(memf, 0); ! 362: if (mem < 0) { ! 363: perror(memf); ! 364: exit(1); ! 365: } ! 366: } ! 367: if (kflg == 0 || argc > 3) { ! 368: swapf = argc>3 ? argv[3]: "/dev/drum"; ! 369: swap = open(swapf, 0); ! 370: if (swap < 0) { ! 371: perror(swapf); ! 372: exit(1); ! 373: } ! 374: } ! 375: } ! 376: ! 377: getkvars(argc, argv) ! 378: char **argv; ! 379: { ! 380: register struct nlist *nlp; ! 381: ! 382: nlistf = argc > 1 ? argv[1] : "/vmunix"; ! 383: nlist(nlistf, nl); ! 384: if (nl[0].n_type == 0) { ! 385: fprintf(stderr, "%s: No namelist\n", nlistf); ! 386: exit(1); ! 387: } ! 388: if (kflg) ! 389: for (nlp = nl; nlp < &nl[sizeof (nl)/sizeof (nl[0])]; nlp++) ! 390: nlp->n_value = nlp->n_value; ! 391: usrpt = (struct pte *)nl[X_USRPT].n_value; ! 392: Usrptma = (struct pte *)nl[X_USRPTMA].n_value; ! 393: klseek(kmem, (long)nl[X_NSWAP].n_value, 0); ! 394: if (read(kmem, (char *)&nswap, sizeof (nswap)) != sizeof (nswap)) { ! 395: cantread("nswap", kmemf); ! 396: exit(1); ! 397: } ! 398: klseek(kmem, (long)nl[X_MAXSLP].n_value, 0); ! 399: if (read(kmem, (char *)&maxslp, sizeof (maxslp)) != sizeof (maxslp)) { ! 400: cantread("maxslp", kmemf); ! 401: exit(1); ! 402: } ! 403: klseek(kmem, (long)nl[X_CCPU].n_value, 0); ! 404: if (read(kmem, (char *)&ccpu, sizeof (ccpu)) != sizeof (ccpu)) { ! 405: cantread("ccpu", kmemf); ! 406: exit(1); ! 407: } ! 408: klseek(kmem, (long)nl[X_ECMX].n_value, 0); ! 409: if (read(kmem, (char *)&ecmx, sizeof (ecmx)) != sizeof (ecmx)) { ! 410: cantread("ecmx", kmemf); ! 411: exit(1); ! 412: } ! 413: if (uflg || vflg) { ! 414: ntext = getw(nl[X_NTEXT].n_value); ! 415: text = (struct text *)alloc(ntext * sizeof (struct text)); ! 416: if (text == 0) { ! 417: fprintf(stderr, "no room for text table\n"); ! 418: exit(1); ! 419: } ! 420: atext = (struct text *)getw(nl[X_TEXT].n_value); ! 421: klseek(kmem, (long)atext, 0); ! 422: if (read(kmem, (char *)text, ntext * sizeof (struct text)) ! 423: != ntext * sizeof (struct text)) { ! 424: cantread("text table", kmemf); ! 425: exit(1); ! 426: } ! 427: } ! 428: dmmin = getw(nl[X_DMMIN].n_value); ! 429: dmmax = getw(nl[X_DMMAX].n_value); ! 430: } ! 431: ! 432: printhdr() ! 433: { ! 434: char *hdr; ! 435: ! 436: if (sflg+lflg+vflg+uflg > 1) { ! 437: fprintf(stderr, "ps: specify only one of s,l,v and u\n"); ! 438: exit(1); ! 439: } ! 440: hdr = lflg ? lhdr : ! 441: (vflg ? vhdr : ! 442: (uflg ? uhdr : shdr)); ! 443: if (lflg+vflg+uflg+sflg == 0) ! 444: hdr += strlen("SSIZ "); ! 445: cmdstart = strlen(hdr); ! 446: printf("%s COMMAND\n", hdr); ! 447: (void) fflush(stdout); ! 448: } ! 449: ! 450: cantread(what, fromwhat) ! 451: char *what, *fromwhat; ! 452: { ! 453: ! 454: fprintf(stderr, "ps: error reading %s from %s\n", what, fromwhat); ! 455: } ! 456: ! 457: struct direct *dbuf; ! 458: int dialbase; ! 459: ! 460: getdev() ! 461: { ! 462: register DIR *df; ! 463: ! 464: dialbase = -1; ! 465: if ((df = opendir(".")) == NULL) { ! 466: fprintf(stderr, "Can't open . in /dev\n"); ! 467: exit(1); ! 468: } ! 469: while ((dbuf = readdir(df)) != NULL) ! 470: maybetty(); ! 471: closedir(df); ! 472: } ! 473: ! 474: /* ! 475: * Attempt to avoid stats by guessing minor device ! 476: * numbers from tty names. Console is known, ! 477: * know that r(hp|up|mt) are unlikely as are different mem's, ! 478: * floppy, null, tty, etc. ! 479: */ ! 480: maybetty() ! 481: { ! 482: register char *cp = dbuf->d_name; ! 483: register struct ttys *dp; ! 484: int x; ! 485: struct stat stb; ! 486: ! 487: switch (cp[0]) { ! 488: ! 489: case 'c': ! 490: if (!strcmp(cp, "console")) { ! 491: x = 0; ! 492: goto donecand; ! 493: } ! 494: /* cu[la]? are possible!?! don't rule them out */ ! 495: break; ! 496: ! 497: case 'd': ! 498: if (!strcmp(cp, "drum")) ! 499: return; ! 500: break; ! 501: ! 502: case 'f': ! 503: if (!strcmp(cp, "floppy")) ! 504: return; ! 505: break; ! 506: ! 507: case 'k': ! 508: cp++; ! 509: if (*cp == 'U') ! 510: cp++; ! 511: goto trymem; ! 512: ! 513: case 'r': ! 514: cp++; ! 515: if (*cp == 'r' || *cp == 'u' || *cp == 'h') ! 516: cp++; ! 517: #define is(a,b) cp[0] == 'a' && cp[1] == 'b' ! 518: if (is(r,p) || is(u,p) || is(r,k) || is(r,m) || is(m,t)) { ! 519: cp += 2; ! 520: if (isdigit(*cp) && cp[2] == 0) ! 521: return; ! 522: } ! 523: break; ! 524: ! 525: case 'm': ! 526: trymem: ! 527: if (cp[0] == 'm' && cp[1] == 'e' && cp[2] == 'm' && cp[3] == 0) ! 528: return; ! 529: if (cp[0] == 'm' && cp[1] == 't') ! 530: return; ! 531: break; ! 532: ! 533: case 'n': ! 534: if (!strcmp(cp, "null")) ! 535: return; ! 536: break; ! 537: ! 538: case 'v': ! 539: if ((cp[1] == 'a' || cp[1] == 'p') && isdigit(cp[2]) && ! 540: cp[3] == 0) ! 541: return; ! 542: break; ! 543: } ! 544: cp = dbuf->d_name + dbuf->d_namlen - 1; ! 545: x = 0; ! 546: if (cp[-1] == 'd') { ! 547: if (dialbase == -1) { ! 548: if (stat("ttyd0", &stb) == 0) ! 549: dialbase = stb.st_rdev & 017; ! 550: else ! 551: dialbase = -2; ! 552: } ! 553: if (dialbase == -2) ! 554: x = 0; ! 555: else ! 556: x = 11; ! 557: } ! 558: if (cp > dbuf->d_name && isdigit(cp[-1]) && isdigit(*cp)) ! 559: x += 10 * (cp[-1] - ' ') + cp[0] - '0'; ! 560: else if (*cp >= 'a' && *cp <= 'f') ! 561: x += 10 + *cp - 'a'; ! 562: else if (isdigit(*cp)) ! 563: x += *cp - '0'; ! 564: else ! 565: x = -1; ! 566: donecand: ! 567: dp = (struct ttys *)alloc(sizeof (struct ttys)); ! 568: (void) strcpy(dp->name, dbuf->d_name); ! 569: dp->next = allttys; ! 570: dp->ttyd = -1; ! 571: allttys = dp; ! 572: if (x == -1) ! 573: return; ! 574: x &= 017; ! 575: dp->cand = cand[x]; ! 576: cand[x] = dp; ! 577: } ! 578: ! 579: char * ! 580: gettty() ! 581: { ! 582: register char *p; ! 583: register struct ttys *dp; ! 584: struct stat stb; ! 585: int x; ! 586: ! 587: if (u.u_ttyp == 0) ! 588: return("?"); ! 589: x = u.u_ttyd & 017; ! 590: for (dp = cand[x]; dp; dp = dp->cand) { ! 591: if (dp->ttyd == -1) { ! 592: if (stat(dp->name, &stb) == 0 && ! 593: (stb.st_mode&S_IFMT)==S_IFCHR) ! 594: dp->ttyd = stb.st_rdev; ! 595: else ! 596: dp->ttyd = -2; ! 597: } ! 598: if (dp->ttyd == u.u_ttyd) ! 599: goto found; ! 600: } ! 601: /* ick */ ! 602: for (dp = allttys; dp; dp = dp->next) { ! 603: if (dp->ttyd == -1) { ! 604: if (stat(dp->name, &stb) == 0 && ! 605: (stb.st_mode&S_IFMT)==S_IFCHR) ! 606: dp->ttyd = stb.st_rdev; ! 607: else ! 608: dp->ttyd = -2; ! 609: } ! 610: if (dp->ttyd == u.u_ttyd) ! 611: goto found; ! 612: } ! 613: return ("?"); ! 614: found: ! 615: p = dp->name; ! 616: if (p[0]=='t' && p[1]=='t' && p[2]=='y') ! 617: p += 3; ! 618: return (p); ! 619: } ! 620: ! 621: save() ! 622: { ! 623: register struct savcom *sp; ! 624: register struct asav *ap; ! 625: register char *cp; ! 626: register struct text *xp; ! 627: char *ttyp, *cmdp; ! 628: ! 629: if (mproc->p_stat != SZOMB && getu() == 0) ! 630: return; ! 631: ttyp = gettty(); ! 632: if (xflg == 0 && ttyp[0] == '?' || tptr && strncmp(tptr, ttyp, 2)) ! 633: return; ! 634: sp = &savcom[npr]; ! 635: cmdp = getcmd(); ! 636: if (cmdp == 0) ! 637: return; ! 638: sp->ap = ap = (struct asav *)alloc(sizeof (struct asav)); ! 639: sp->ap->a_cmdp = cmdp; ! 640: #define e(a,b) ap->a = mproc->b ! 641: e(a_flag, p_flag); e(a_stat, p_stat); e(a_nice, p_nice); ! 642: e(a_uid, p_uid); e(a_pid, p_pid); e(a_pri, p_pri); ! 643: e(a_slptime, p_slptime); e(a_time, p_time); ! 644: ap->a_tty[0] = ttyp[0]; ! 645: ap->a_tty[1] = ttyp[1] ? ttyp[1] : ' '; ! 646: if (ap->a_stat == SZOMB) { ! 647: ap->a_cpu = 0; ! 648: } else { ! 649: ap->a_size = mproc->p_dsize + mproc->p_ssize; ! 650: e(a_rss, p_rssize); ! 651: ap->a_ttyd = u.u_ttyd; ! 652: ap->a_cpu = u.u_ru.ru_utime.tv_sec + u.u_ru.ru_stime.tv_sec; ! 653: if (sumcpu) ! 654: ap->a_cpu += u.u_cru.ru_utime.tv_sec + u.u_cru.ru_stime.tv_sec; ! 655: if (mproc->p_textp && text) { ! 656: xp = &text[mproc->p_textp - atext]; ! 657: ap->a_tsiz = xp->x_size; ! 658: ap->a_txtrss = xp->x_rssize; ! 659: ap->a_xccount = xp->x_ccount; ! 660: } ! 661: } ! 662: #undef e ! 663: ap->a_maxrss = mproc->p_maxrss; ! 664: if (lflg) { ! 665: register struct lsav *lp; ! 666: ! 667: sp->s_un.lp = lp = (struct lsav *)alloc(sizeof (struct lsav)); ! 668: #define e(a,b) lp->a = mproc->b ! 669: e(l_ppid, p_ppid); e(l_cpu, p_cpu); ! 670: if (ap->a_stat != SZOMB) ! 671: e(l_wchan, p_wchan); ! 672: #undef e ! 673: lp->l_addr = pcbpf; ! 674: } else if (vflg) { ! 675: register struct vsav *vp; ! 676: ! 677: sp->s_un.vp = vp = (struct vsav *)alloc(sizeof (struct vsav)); ! 678: #define e(a,b) vp->a = mproc->b ! 679: if (ap->a_stat != SZOMB) { ! 680: e(v_swrss, p_swrss); ! 681: vp->v_majflt = u.u_ru.ru_majflt; ! 682: if (mproc->p_textp) ! 683: vp->v_txtswrss = xp->x_swrss; ! 684: } ! 685: vp->v_pctcpu = pcpu(); ! 686: #undef e ! 687: } else if (uflg) ! 688: sp->s_un.u_pctcpu = pcpu(); ! 689: else if (sflg) { ! 690: if (ap->a_stat != SZOMB) { ! 691: for (cp = (char *)u.u_stack; ! 692: cp < &user.upages[UPAGES][0]; ) ! 693: if (*cp++) ! 694: break; ! 695: sp->s_un.s_ssiz = (&user.upages[UPAGES][0] - cp); ! 696: } ! 697: } ! 698: ! 699: npr++; ! 700: } ! 701: ! 702: double ! 703: pmem(ap) ! 704: register struct asav *ap; ! 705: { ! 706: double fracmem; ! 707: int szptudot; ! 708: ! 709: if ((ap->a_flag&SLOAD) == 0) ! 710: fracmem = 0.0; ! 711: else { ! 712: szptudot = UPAGES + clrnd(ctopt(ap->a_size+ap->a_tsiz)); ! 713: fracmem = ((float)ap->a_rss+szptudot)/CLSIZE/ecmx; ! 714: if (ap->a_xccount) ! 715: fracmem += ((float)ap->a_txtrss)/CLSIZE/ ! 716: ap->a_xccount/ecmx; ! 717: } ! 718: return (100.0 * fracmem); ! 719: } ! 720: ! 721: double ! 722: pcpu() ! 723: { ! 724: time_t time; ! 725: ! 726: time = mproc->p_time; ! 727: if (time == 0 || (mproc->p_flag&SLOAD) == 0) ! 728: return (0.0); ! 729: if (rawcpu) ! 730: return (100.0 * mproc->p_pctcpu); ! 731: return (100.0 * mproc->p_pctcpu / (1.0 - exp(time * log(ccpu)))); ! 732: } ! 733: ! 734: getu() ! 735: { ! 736: struct pte *pteaddr, apte; ! 737: struct pte arguutl[UPAGES+CLSIZE]; ! 738: register int i; ! 739: int ncl, size; ! 740: ! 741: size = sflg ? ctob(UPAGES) : sizeof (struct user); ! 742: if ((mproc->p_flag & SLOAD) == 0) { ! 743: if (swap < 0) ! 744: return (0); ! 745: (void) lseek(swap, (long)dtob(mproc->p_swaddr), 0); ! 746: if (read(swap, (char *)&user.user, size) != size) { ! 747: fprintf(stderr, "ps: cant read u for pid %d from %s\n", ! 748: mproc->p_pid, swapf); ! 749: return (0); ! 750: } ! 751: pcbpf = 0; ! 752: argaddr = 0; ! 753: return (1); ! 754: } ! 755: if (kflg) ! 756: mproc->p_p0br = (struct pte *)mproc->p_p0br; ! 757: pteaddr = &Usrptma[btokmx(mproc->p_p0br) + mproc->p_szpt - 1]; ! 758: klseek(kmem, (long)pteaddr, 0); ! 759: if (read(kmem, (char *)&apte, sizeof(apte)) != sizeof(apte)) { ! 760: printf("ps: cant read indir pte to get u for pid %d from %s\n", ! 761: mproc->p_pid, swapf); ! 762: return (0); ! 763: } ! 764: klseek(mem, ! 765: (long)ctob(apte.pg_pfnum+1) - (UPAGES+CLSIZE) * sizeof (struct pte), ! 766: 0); ! 767: if (read(mem, (char *)arguutl, sizeof(arguutl)) != sizeof(arguutl)) { ! 768: printf("ps: cant read page table for u of pid %d from %s\n", ! 769: mproc->p_pid, kmemf); ! 770: return (0); ! 771: } ! 772: if (arguutl[0].pg_fod == 0 && arguutl[0].pg_pfnum) ! 773: argaddr = ctob(arguutl[0].pg_pfnum); ! 774: else ! 775: argaddr = 0; ! 776: pcbpf = arguutl[CLSIZE].pg_pfnum; ! 777: ncl = (size + NBPG*CLSIZE - 1) / (NBPG*CLSIZE); ! 778: while (--ncl >= 0) { ! 779: i = ncl * CLSIZE; ! 780: klseek(mem, (long)ctob(arguutl[CLSIZE+i].pg_pfnum), 0); ! 781: if (read(mem, user.upages[i], CLSIZE*NBPG) != CLSIZE*NBPG) { ! 782: printf("ps: cant read page %d of u of pid %d from %s\n", ! 783: arguutl[CLSIZE+i].pg_pfnum, mproc->p_pid, memf); ! 784: return(0); ! 785: } ! 786: } ! 787: return (1); ! 788: } ! 789: ! 790: char * ! 791: getcmd() ! 792: { ! 793: char cmdbuf[CLSIZE*NBPG]; ! 794: union { ! 795: char argc[CLSIZE*NBPG]; ! 796: int argi[CLSIZE*NBPG/sizeof (int)]; ! 797: } argspac; ! 798: register char *cp; ! 799: register int *ip; ! 800: char c; ! 801: int nbad; ! 802: struct dblock db; ! 803: char *file; ! 804: ! 805: if (mproc->p_stat == SZOMB || mproc->p_flag&(SSYS|SWEXIT)) ! 806: return (""); ! 807: if (cflg) { ! 808: (void) strncpy(cmdbuf, u.u_comm, sizeof (u.u_comm)); ! 809: return (savestr(cmdbuf)); ! 810: } ! 811: if ((mproc->p_flag & SLOAD) == 0 || argaddr == 0) { ! 812: if (swap < 0) ! 813: goto retucomm; ! 814: vstodb(0, CLSIZE, &u.u_smap, &db, 1); ! 815: (void) lseek(swap, (long)dtob(db.db_base), 0); ! 816: if (read(swap, (char *)&argspac, sizeof(argspac)) ! 817: != sizeof(argspac)) ! 818: goto bad; ! 819: file = swapf; ! 820: } else { ! 821: klseek(mem, (long)argaddr, 0); ! 822: if (read(mem, (char *)&argspac, sizeof (argspac)) ! 823: != sizeof (argspac)) ! 824: goto bad; ! 825: file = memf; ! 826: } ! 827: ip = &argspac.argi[CLSIZE*NBPG/sizeof (int)]; ! 828: ip -= 2; /* last arg word and .long 0 */ ! 829: while (*--ip) ! 830: if (ip == argspac.argi) ! 831: goto retucomm; ! 832: *(char *)ip = ' '; ! 833: ip++; ! 834: nbad = 0; ! 835: for (cp = (char *)ip; cp < &argspac.argc[CLSIZE*NBPG]; cp++) { ! 836: c = *cp & 0177; ! 837: if (c == 0) ! 838: *cp = ' '; ! 839: else if (c < ' ' || c > 0176) { ! 840: if (++nbad >= 5*(eflg+1)) { ! 841: *cp++ = ' '; ! 842: break; ! 843: } ! 844: *cp = '?'; ! 845: } else if (eflg == 0 && c == '=') { ! 846: while (*--cp != ' ') ! 847: if (cp <= (char *)ip) ! 848: break; ! 849: break; ! 850: } ! 851: } ! 852: *cp = 0; ! 853: while (*--cp == ' ') ! 854: *cp = 0; ! 855: cp = (char *)ip; ! 856: (void) strncpy(cmdbuf, cp, &argspac.argc[CLSIZE*NBPG] - cp); ! 857: if (cp[0] == '-' || cp[0] == '?' || cp[0] <= ' ') { ! 858: (void) strcat(cmdbuf, " ("); ! 859: (void) strncat(cmdbuf, u.u_comm, sizeof(u.u_comm)); ! 860: (void) strcat(cmdbuf, ")"); ! 861: } ! 862: /* ! 863: if (xflg == 0 && gflg == 0 && tptr == 0 && cp[0] == '-') ! 864: return (0); ! 865: */ ! 866: return (savestr(cmdbuf)); ! 867: ! 868: bad: ! 869: fprintf(stderr, "ps: error locating command name for pid %d from %s\n", ! 870: mproc->p_pid, file); ! 871: retucomm: ! 872: (void) strcpy(cmdbuf, " ("); ! 873: (void) strncat(cmdbuf, u.u_comm, sizeof (u.u_comm)); ! 874: (void) strcat(cmdbuf, ")"); ! 875: return (savestr(cmdbuf)); ! 876: } ! 877: ! 878: char *lhdr = ! 879: " F UID PID PPID CP PRI NI ADDR SZ RSS WCHAN STAT TT TIME"; ! 880: lpr(sp) ! 881: struct savcom *sp; ! 882: { ! 883: register struct asav *ap = sp->ap; ! 884: register struct lsav *lp = sp->s_un.lp; ! 885: ! 886: printf("%7x%4d%6u%6u%3d%4d%3d%5x%4d%5d", ! 887: ap->a_flag, ap->a_uid, ! 888: ap->a_pid, lp->l_ppid, lp->l_cpu&0377, ap->a_pri-PZERO, ! 889: ap->a_nice-NZERO, lp->l_addr, pgtok(ap->a_size), pgtok(ap->a_rss)); ! 890: printf(lp->l_wchan ? " %5x" : " ", (int)lp->l_wchan&0xfffff); ! 891: printf(" %4.4s ", state(ap)); ! 892: ptty(ap->a_tty); ! 893: ptime(ap); ! 894: } ! 895: ! 896: ptty(tp) ! 897: char *tp; ! 898: { ! 899: ! 900: printf("%-2.2s", tp); ! 901: } ! 902: ! 903: ptime(ap) ! 904: struct asav *ap; ! 905: { ! 906: ! 907: printf("%3ld:%02ld", ap->a_cpu / 60, ap->a_cpu % 60); ! 908: } ! 909: ! 910: char *uhdr = ! 911: "USER PID %CPU %MEM SZ RSS TT STAT TIME"; ! 912: upr(sp) ! 913: struct savcom *sp; ! 914: { ! 915: register struct asav *ap = sp->ap; ! 916: int vmsize, rmsize; ! 917: ! 918: vmsize = pgtok((ap->a_size + ap->a_tsiz)); ! 919: rmsize = pgtok(ap->a_rss); ! 920: if (ap->a_xccount) ! 921: rmsize += pgtok(ap->a_txtrss/ap->a_xccount); ! 922: printf("%-8.8s %5d%5.1f%5.1f%5d%5d", ! 923: getname(ap->a_uid), ap->a_pid, sp->s_un.u_pctcpu, pmem(ap), ! 924: vmsize, rmsize); ! 925: putchar(' '); ! 926: ptty(ap->a_tty); ! 927: printf(" %4.4s", state(ap)); ! 928: ptime(ap); ! 929: } ! 930: ! 931: char *vhdr = ! 932: " SIZE PID TT STAT TIME SL RE PAGEIN SIZE RSS LIM TSIZ TRS %CPU %MEM"+5; ! 933: vpr(sp) ! 934: struct savcom *sp; ! 935: { ! 936: register struct vsav *vp = sp->s_un.vp; ! 937: register struct asav *ap = sp->ap; ! 938: ! 939: printf("%5u ", ap->a_pid); ! 940: ptty(ap->a_tty); ! 941: printf(" %4.4s", state(ap)); ! 942: ptime(ap); ! 943: printf("%3d%3d%7d%5d%5d", ! 944: ap->a_slptime > 99 ? 99 : ap-> a_slptime, ! 945: ap->a_time > 99 ? 99 : ap->a_time, vp->v_majflt, ! 946: pgtok(ap->a_size), pgtok(ap->a_rss)); ! 947: if (ap->a_maxrss == (RLIM_INFINITY/NBPG)) ! 948: printf(" xx"); ! 949: else ! 950: printf("%5d", pgtok(ap->a_maxrss)); ! 951: printf("%5d%4d%5.1f%5.1f", ! 952: pgtok(ap->a_tsiz), pgtok(ap->a_txtrss), vp->v_pctcpu, pmem(ap)); ! 953: } ! 954: ! 955: char *shdr = ! 956: "SSIZ PID TT STAT TIME"; ! 957: spr(sp) ! 958: struct savcom *sp; ! 959: { ! 960: register struct asav *ap = sp->ap; ! 961: ! 962: if (sflg) ! 963: printf("%4d ", sp->s_un.s_ssiz); ! 964: printf("%5u", ap->a_pid); ! 965: putchar(' '); ! 966: ptty(ap->a_tty); ! 967: printf(" %4.4s", state(ap)); ! 968: ptime(ap); ! 969: } ! 970: ! 971: char * ! 972: state(ap) ! 973: register struct asav *ap; ! 974: { ! 975: char stat, load, nice, anom; ! 976: static char res[5]; ! 977: ! 978: switch (ap->a_stat) { ! 979: ! 980: case SSTOP: ! 981: stat = 'T'; ! 982: break; ! 983: ! 984: case SSLEEP: ! 985: if (ap->a_pri >= PZERO) ! 986: if (ap->a_slptime >= MAXSLP) ! 987: stat = 'I'; ! 988: else ! 989: stat = 'S'; ! 990: else if (ap->a_flag & SPAGE) ! 991: stat = 'P'; ! 992: else ! 993: stat = 'D'; ! 994: break; ! 995: ! 996: case SWAIT: ! 997: case SRUN: ! 998: case SIDL: ! 999: stat = 'R'; ! 1000: break; ! 1001: ! 1002: case SZOMB: ! 1003: stat = 'Z'; ! 1004: break; ! 1005: ! 1006: default: ! 1007: stat = '?'; ! 1008: } ! 1009: load = ap->a_flag & SLOAD ? (ap->a_rss>ap->a_maxrss ? '>' : ' ') : 'W'; ! 1010: if (ap->a_nice < NZERO) ! 1011: nice = '<'; ! 1012: else if (ap->a_nice > NZERO) ! 1013: nice = 'N'; ! 1014: else ! 1015: nice = ' '; ! 1016: anom = (ap->a_flag&SUANOM) ? 'A' : ((ap->a_flag&SSEQL) ? 'S' : ' '); ! 1017: res[0] = stat; res[1] = load; res[2] = nice; res[3] = anom; ! 1018: return (res); ! 1019: } ! 1020: ! 1021: /* ! 1022: * Given a base/size pair in virtual swap area, ! 1023: * return a physical base/size pair which is the ! 1024: * (largest) initial, physically contiguous block. ! 1025: */ ! 1026: vstodb(vsbase, vssize, dmp, dbp, rev) ! 1027: register int vsbase; ! 1028: int vssize; ! 1029: struct dmap *dmp; ! 1030: register struct dblock *dbp; ! 1031: { ! 1032: register int blk = dmmin; ! 1033: register swblk_t *ip = dmp->dm_map; ! 1034: ! 1035: vsbase = ctod(vsbase); ! 1036: vssize = ctod(vssize); ! 1037: if (vsbase < 0 || vsbase + vssize > dmp->dm_size) ! 1038: panic("vstodb"); ! 1039: while (vsbase >= blk) { ! 1040: vsbase -= blk; ! 1041: if (blk < dmmax) ! 1042: blk *= 2; ! 1043: ip++; ! 1044: } ! 1045: if (*ip <= 0 || *ip + blk > nswap) ! 1046: panic("vstodb *ip"); ! 1047: dbp->db_size = min(vssize, blk - vsbase); ! 1048: dbp->db_base = *ip + (rev ? blk - (vsbase + dbp->db_size) : vsbase); ! 1049: } ! 1050: ! 1051: /*ARGSUSED*/ ! 1052: panic(cp) ! 1053: char *cp; ! 1054: { ! 1055: ! 1056: #ifdef DEBUG ! 1057: printf("%s\n", cp); ! 1058: #endif ! 1059: } ! 1060: ! 1061: min(a, b) ! 1062: { ! 1063: ! 1064: return (a < b ? a : b); ! 1065: } ! 1066: ! 1067: pscomp(s1, s2) ! 1068: struct savcom *s1, *s2; ! 1069: { ! 1070: register int i; ! 1071: ! 1072: if (uflg) ! 1073: return (s2->s_un.u_pctcpu > s1->s_un.u_pctcpu ? 1 : -1); ! 1074: if (vflg) ! 1075: return (vsize(s2) - vsize(s1)); ! 1076: i = s1->ap->a_ttyd - s2->ap->a_ttyd; ! 1077: if (i == 0) ! 1078: i = s1->ap->a_pid - s2->ap->a_pid; ! 1079: return (i); ! 1080: } ! 1081: ! 1082: vsize(sp) ! 1083: struct savcom *sp; ! 1084: { ! 1085: register struct asav *ap = sp->ap; ! 1086: register struct vsav *vp = sp->s_un.vp; ! 1087: ! 1088: if (ap->a_flag & SLOAD) ! 1089: return (ap->a_rss + ! 1090: ap->a_txtrss / (ap->a_xccount ? ap->a_xccount : 1)); ! 1091: return (vp->v_swrss + (ap->a_xccount ? 0 : vp->v_txtswrss)); ! 1092: } ! 1093: ! 1094: #define NMAX 8 /* sizeof loginname (should be sizeof (utmp.ut_name)) */ ! 1095: #define NUID 2048 /* must not be a multiple of 5 */ ! 1096: ! 1097: struct nametable { ! 1098: char nt_name[NMAX+1]; ! 1099: int nt_uid; ! 1100: } nametable[NUID]; ! 1101: ! 1102: struct nametable * ! 1103: findslot(uid) ! 1104: unsigned short uid; ! 1105: { ! 1106: register struct nametable *n, *start; ! 1107: ! 1108: /* ! 1109: * find the uid or an empty slot. ! 1110: * return NULL if neither found. ! 1111: */ ! 1112: ! 1113: n = start = nametable + (uid % (NUID - 20)); ! 1114: while (n->nt_name[0] && n->nt_uid != uid) { ! 1115: if ((n += 5) >= &nametable[NUID]) ! 1116: n -= NUID; ! 1117: if (n == start) ! 1118: return((struct nametable *)NULL); ! 1119: } ! 1120: return(n); ! 1121: } ! 1122: ! 1123: char * ! 1124: getname(uid) ! 1125: { ! 1126: register struct passwd *pw; ! 1127: static init = 0; ! 1128: struct passwd *getpwent(); ! 1129: register struct nametable *n; ! 1130: ! 1131: /* ! 1132: * find uid in hashed table; add it if not found. ! 1133: * return pointer to name. ! 1134: */ ! 1135: ! 1136: if ((n = findslot(uid)) == NULL) ! 1137: return((char *)NULL); ! 1138: ! 1139: if (n->nt_name[0]) /* occupied? */ ! 1140: return(n->nt_name); ! 1141: ! 1142: switch (init) { ! 1143: case 0: ! 1144: setpwent(); ! 1145: init = 1; ! 1146: /* intentional fall-thru */ ! 1147: case 1: ! 1148: while (pw = getpwent()) { ! 1149: if (pw->pw_uid < 0) ! 1150: continue; ! 1151: if ((n = findslot(pw->pw_uid)) == NULL) { ! 1152: endpwent(); ! 1153: init = 2; ! 1154: return((char *)NULL); ! 1155: } ! 1156: if (n->nt_name[0]) ! 1157: continue; /* duplicate, not uid */ ! 1158: strncpy(n->nt_name, pw->pw_name, NMAX); ! 1159: n->nt_uid = pw->pw_uid; ! 1160: if (pw->pw_uid == uid) ! 1161: return (n->nt_name); ! 1162: } ! 1163: endpwent(); ! 1164: init = 2; ! 1165: /* intentional fall-thru */ ! 1166: case 2: ! 1167: return ((char *)NULL); ! 1168: } ! 1169: } ! 1170: ! 1171: char *freebase; ! 1172: int nleft; ! 1173: ! 1174: char * ! 1175: alloc(size) ! 1176: int size; ! 1177: { ! 1178: register char *cp; ! 1179: register int i; ! 1180: ! 1181: #ifdef sun ! 1182: size = (size+1)&~1; ! 1183: #endif ! 1184: if (size > nleft) { ! 1185: freebase = (char *)sbrk((int)(i = size > 2048 ? size : 2048)); ! 1186: if (freebase == (char *)-1) { ! 1187: fprintf(stderr, "ps: ran out of memory\n"); ! 1188: exit(1); ! 1189: } ! 1190: nleft = i - size; ! 1191: } else ! 1192: nleft -= size; ! 1193: cp = freebase; ! 1194: for (i = size; --i >= 0; ) ! 1195: *cp++ = 0; ! 1196: freebase = cp; ! 1197: return (cp - size); ! 1198: } ! 1199: ! 1200: char * ! 1201: savestr(cp) ! 1202: char *cp; ! 1203: { ! 1204: register int len; ! 1205: register char *dp; ! 1206: ! 1207: len = strlen(cp); ! 1208: dp = (char *)alloc((len+1+3) & ~3); ! 1209: (void) strcpy(dp, cp); ! 1210: return (dp); ! 1211: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.