![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to oops.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / oops|
Return to oops.c CVS log | Up to [Research Unix] / researchv10no / cmd / oops |
1.1 ! root 1: static char *sccsid = "@(#)ps.c 4.13 (Berkeley) 81/07/08"; ! 2: /* ! 3: * ps; VAX 4BSD version ! 4: */ ! 5: ! 6: #include <stdio.h> ! 7: #include <ctype.h> ! 8: #include <nlist.h> ! 9: #include <pwd.h> ! 10: #include <sys/param.h> ! 11: #include <sys/dir.h> ! 12: #include <sys/user.h> ! 13: #include <sys/proc.h> ! 14: #include <sys/pte.h> ! 15: #include <sys/vm.h> ! 16: #include <sys/text.h> ! 17: #include <sys/stat.h> ! 18: #include <math.h> ! 19: #include <sys/vlimit.h> ! 20: #include <ftw.h> ! 21: ! 22: struct nlist nl[] = { ! 23: { "_proc" }, ! 24: #define X_PROC 0 ! 25: { "_Usrptmap" }, ! 26: #define X_USRPTMA 1 ! 27: { "_usrpt" }, ! 28: #define X_USRPT 2 ! 29: { "_text" }, ! 30: #define X_TEXT 3 ! 31: { "_nswap" }, ! 32: #define X_NSWAP 4 ! 33: { "_maxslp" }, ! 34: #define X_MAXSLP 5 ! 35: { "_ccpu" }, ! 36: #define X_CCPU 6 ! 37: { "_ecmx" }, ! 38: #define X_ECMX 7 ! 39: { "_nproc" }, ! 40: #define X_NPROC 8 ! 41: { "_ntext" }, ! 42: #define X_NTEXT 9 ! 43: { "_hz" }, ! 44: #define X_HZ 10 ! 45: { 0 }, ! 46: }; ! 47: ! 48: struct savcom { ! 49: union { ! 50: struct lsav *lp; ! 51: float u_pctcpu; ! 52: struct vsav *vp; ! 53: int s_ssiz; ! 54: } sun; ! 55: struct asav *ap; ! 56: } *savcom; ! 57: ! 58: struct asav { ! 59: char *a_cmdp; ! 60: int a_flag; ! 61: short a_stat, a_uid, a_pid, a_nice, a_pri, a_slptime, a_time; ! 62: size_t a_size, a_rss, a_tsiz, a_txtrss; ! 63: short a_xccount; ! 64: char a_tty[DIRSIZ+1]; ! 65: dev_t a_ttyd; ! 66: time_t a_cpu; ! 67: size_t a_maxrss; ! 68: }; ! 69: ! 70: char *lhdr; ! 71: struct lsav { ! 72: short l_ppid; ! 73: char l_cpu; ! 74: int l_addr; ! 75: caddr_t l_wchan; ! 76: }; ! 77: ! 78: char *uhdr; ! 79: char *shdr; ! 80: ! 81: char *vhdr; ! 82: struct vsav { ! 83: u_int v_majflt; ! 84: size_t v_swrss, v_txtswrss; ! 85: float v_pctcpu; ! 86: }; ! 87: ! 88: struct proc proc[8]; /* 8 = a few, for less syscalls */ ! 89: struct proc *mproc; ! 90: struct text *text; ! 91: ! 92: int paduser1; /* avoid hardware mem clobbering botch */ ! 93: union { ! 94: struct user user; ! 95: char upages[UPAGES][NBPG]; ! 96: } user; ! 97: #define u user.user ! 98: int paduser2; /* avoid hardware mem clobbering botch */ ! 99: ! 100: #define clear(x) ((int)x & 0xffffff) ! 101: ! 102: int chkpid; ! 103: int aflg, cflg, eflg, gflg, kflg, lflg, sflg, uflg, vflg, xflg; ! 104: char *tptr; ! 105: char *gettty(), *getcmd(), *getname(), *savestr(), *alloc(), *state(); ! 106: double pcpu(), pmem(); ! 107: int pscomp(); ! 108: int nswap, maxslp; ! 109: struct text *atext; ! 110: double ccpu; ! 111: int ecmx; ! 112: struct pte *Usrptma, *usrpt; ! 113: int nproc, ntext, hz; ! 114: ! 115: struct ttys { ! 116: char name[DIRSIZ+1]; ! 117: dev_t ttyd; ! 118: struct ttys *next; ! 119: } *allttys; ! 120: ! 121: ! 122: int npr; ! 123: ! 124: int cmdstart; ! 125: int twidth; ! 126: char *kmemf, *memf, *swapf, *nlistf; ! 127: int kmem, mem, swap; ! 128: int rawcpu, sumcpu; ! 129: ! 130: int pcbpf; ! 131: int argaddr; ! 132: extern char _sobuf[]; ! 133: ! 134: main(argc, argv) ! 135: char **argv; ! 136: { ! 137: register int i, j; ! 138: register char *ap; ! 139: int uid, pgrp; ! 140: off_t procp; ! 141: ! 142: argc--, argv++; ! 143: twidth = 80; ! 144: setbuf(stdout, _sobuf); ! 145: if (argc > 0) { ! 146: ap = argv[0]; ! 147: while (*ap) switch (*ap++) { ! 148: ! 149: case 'C': ! 150: rawcpu++; ! 151: break; ! 152: case 'S': ! 153: sumcpu++; ! 154: break; ! 155: case 'a': ! 156: aflg++; ! 157: break; ! 158: case 'c': ! 159: cflg = !cflg; ! 160: break; ! 161: case 'e': ! 162: eflg++; ! 163: break; ! 164: case 'g': ! 165: gflg++; ! 166: break; ! 167: case 'k': ! 168: kflg++; ! 169: break; ! 170: case 'l': ! 171: lflg++; ! 172: break; ! 173: case 's': ! 174: sflg++; ! 175: break; ! 176: case 't': ! 177: if (*ap) ! 178: tptr = ap; ! 179: aflg++; ! 180: gflg++; ! 181: if (*tptr == '?') ! 182: xflg++; ! 183: while (*ap) ! 184: ap++; ! 185: break; ! 186: case 'u': ! 187: uflg++; ! 188: break; ! 189: case 'v': ! 190: cflg = 1; ! 191: vflg++; ! 192: break; ! 193: case 'w': ! 194: if (twidth == 80) ! 195: twidth = 132; ! 196: else ! 197: twidth = BUFSIZ; ! 198: break; ! 199: case 'x': ! 200: xflg++; ! 201: break; ! 202: default: ! 203: if (!isdigit(ap[-1])) ! 204: break; ! 205: chkpid = atoi(--ap); ! 206: *ap = 0; ! 207: aflg++; ! 208: xflg++; ! 209: break; ! 210: } ! 211: } ! 212: openfiles(argc, argv); ! 213: getkvars(argc, argv); ! 214: getdev("/dev"); ! 215: getdev("/dev/dk"); ! 216: getdev("/dev/pt"); ! 217: uid = getuid(); ! 218: pgrp = getpgrp(); ! 219: printhdr(); ! 220: procp = getw(nl[X_PROC].n_value); ! 221: nproc = getw(nl[X_NPROC].n_value); ! 222: hz = getw(nl[X_HZ].n_value); ! 223: savcom = (struct savcom *)calloc(nproc, sizeof (*savcom)); ! 224: for (i=0; i<nproc; i += 8) { ! 225: KMlseek(kmem, (char *)procp, 0); ! 226: j = nproc - i; ! 227: if (j > 8) ! 228: j = 8; ! 229: j *= sizeof (struct proc); ! 230: if (read(kmem, (char *)proc, j) != j) ! 231: cantread("proc table", kmemf); ! 232: procp += j; ! 233: for (j = j / sizeof (struct proc) - 1; j >= 0; j--) { ! 234: mproc = &proc[j]; ! 235: if (mproc->p_stat == 0 || ! 236: mproc->p_pgrp == 0 && xflg == 0) ! 237: continue; ! 238: /* ! 239: if (tptr == 0 && gflg == 0 && xflg == 0 && ! 240: mproc->p_ppid == 1 && (mproc->p_flag&SDETACH) == 0) ! 241: continue; ! 242: */ ! 243: ! 244: if(uid != mproc->p_uid && !aflg && mproc->p_pgrp != pgrp || ! 245: chkpid != 0 && chkpid != mproc->p_pid) ! 246: continue; ! 247: if (vflg && gflg == 0 && xflg == 0) { ! 248: if (mproc->p_stat == SZOMB || ! 249: mproc->p_flag&SWEXIT) ! 250: continue; ! 251: if (mproc->p_slptime > MAXSLP && ! 252: (mproc->p_stat == SSLEEP || ! 253: mproc->p_stat == SSTOP)) ! 254: continue; ! 255: } ! 256: save(); ! 257: } ! 258: } ! 259: qsort(savcom, npr, sizeof(savcom[0]), pscomp); ! 260: for (i=0; i<npr; i++) { ! 261: register struct savcom *sp = &savcom[i]; ! 262: if (lflg) ! 263: lpr(sp); ! 264: else if (vflg) ! 265: vpr(sp); ! 266: else if (uflg) ! 267: upr(sp); ! 268: else ! 269: spr(sp); ! 270: if (sp->ap->a_flag & SWEXIT) ! 271: printf(" <exiting>"); ! 272: else if (sp->ap->a_stat == SZOMB) ! 273: printf(" <defunct>"); ! 274: else if (sp->ap->a_pid == 0) ! 275: printf(" swapper"); ! 276: else if (sp->ap->a_pid == 2) ! 277: printf(" pagedaemon"); ! 278: else if (sp->ap->a_pid == 3 && sp->ap->a_flag & SSYS) ! 279: printf(" ip input"); ! 280: else ! 281: printf(" %.*s", twidth - cmdstart - 2, sp->ap->a_cmdp); ! 282: printf("\n"); ! 283: } ! 284: exit(npr == 0); ! 285: } ! 286: ! 287: getw(loc) ! 288: off_t loc; ! 289: { ! 290: long word; ! 291: ! 292: KMlseek(kmem, loc, 0); ! 293: if (read(kmem, &word, sizeof (word)) != sizeof (word)) ! 294: printf("error reading kmem at %x\n", loc); ! 295: return (word); ! 296: } ! 297: ! 298: openfiles(argc, argv) ! 299: char **argv; ! 300: { ! 301: ! 302: kmemf = "/dev/kmem"; ! 303: if (kflg) ! 304: kmemf = argc > 1 ? argv[1] : "/vmcore"; ! 305: kmem = open(kmemf, 0); ! 306: if (kmem < 0) { ! 307: perror(kmemf); ! 308: exit(1); ! 309: } ! 310: if (kflg) { ! 311: mem = kmem; ! 312: memf = kmemf; ! 313: } else { ! 314: memf = "/dev/mem"; ! 315: mem = open(memf, 0); ! 316: if (mem < 0) { ! 317: perror(memf); ! 318: exit(1); ! 319: } ! 320: } ! 321: swapf = argc>3 ? argv[3]: "/dev/drum"; ! 322: swap = open(swapf, 0); ! 323: if (swap < 0) { ! 324: perror(swapf); ! 325: exit(1); ! 326: } ! 327: } ! 328: ! 329: getkvars(argc, argv) ! 330: char **argv; ! 331: { ! 332: register struct nlist *nlp; ! 333: ! 334: nlistf = argc > 2 ? argv[2] : "/unix"; ! 335: nlist(nlistf, nl); ! 336: if (nl[0].n_type == 0) { ! 337: fprintf(stderr, "%s: No namelist\n", nlistf); ! 338: exit(1); ! 339: } ! 340: if (kflg) ! 341: for (nlp = nl; nlp < &nl[sizeof (nl)/sizeof (nl[0])]; nlp++) ! 342: nlp->n_value = clear(nlp->n_value); ! 343: Usrptma = (struct pte *)nl[X_USRPTMA].n_value; ! 344: usrpt = (struct pte *)nl[X_USRPT].n_value; ! 345: KMlseek(kmem, (long)nl[X_NSWAP].n_value, 0); ! 346: if (read(kmem, &nswap, sizeof (nswap)) != sizeof (nswap)) { ! 347: cantread("nswap", kmemf); ! 348: exit(1); ! 349: } ! 350: KMlseek(kmem, (long)nl[X_MAXSLP].n_value, 0); ! 351: if (read(kmem, &maxslp, sizeof (maxslp)) != sizeof (maxslp)) { ! 352: cantread("maxslp", kmemf); ! 353: exit(1); ! 354: } ! 355: KMlseek(kmem, (long)nl[X_CCPU].n_value, 0); ! 356: if (read(kmem, &ccpu, sizeof (ccpu)) != sizeof (ccpu)) { ! 357: cantread("ccpu", kmemf); ! 358: exit(1); ! 359: } ! 360: KMlseek(kmem, (long)nl[X_ECMX].n_value, 0); ! 361: if (read(kmem, &ecmx, sizeof (ecmx)) != sizeof (ecmx)) { ! 362: cantread("ecmx", kmemf); ! 363: exit(1); ! 364: } ! 365: if (uflg || vflg) { ! 366: ntext = getw(nl[X_NTEXT].n_value); ! 367: text = (struct text *)alloc(ntext * sizeof (struct text)); ! 368: if (text == 0) { ! 369: fprintf(stderr, "no room for text table\n"); ! 370: exit(1); ! 371: } ! 372: atext = (struct text *)getw(nl[X_TEXT].n_value); ! 373: KMlseek(kmem, (int)atext, 0); ! 374: if (read(kmem, (char *)text, ntext * sizeof (struct text)) ! 375: != ntext * sizeof (struct text)) { ! 376: cantread("text table", kmemf); ! 377: exit(1); ! 378: } ! 379: } ! 380: } ! 381: ! 382: printhdr() ! 383: { ! 384: char *hdr; ! 385: ! 386: if (sflg+lflg+vflg+uflg > 1) { ! 387: fprintf(stderr, "ps: specify only one of s,l,v and u\n"); ! 388: exit(1); ! 389: } ! 390: hdr = lflg ? lhdr : (vflg ? vhdr : (uflg ? uhdr : shdr)); ! 391: if (lflg+vflg+uflg+sflg == 0) ! 392: hdr += strlen("SSIZ "); ! 393: cmdstart = strlen(hdr); ! 394: printf("%s COMMAND\n", hdr); ! 395: fflush(stdout); ! 396: } ! 397: ! 398: cantread(what, fromwhat) ! 399: char *what, *fromwhat; ! 400: { ! 401: fprintf(stderr, "ps: error reading %s from %s\n", what, fromwhat); ! 402: } ! 403: ! 404: getdev(dir) ! 405: register char *dir; ! 406: { ! 407: register FILE *df; ! 408: struct direct dirent; ! 409: register struct ttys *dp; ! 410: ! 411: df = fopen (dir, "r"); ! 412: if (df != NULL) { ! 413: while (fread (&dirent, sizeof (dirent), 1, df) == 1) { ! 414: dp = (struct ttys *) alloc (sizeof (struct ttys)); ! 415: strncpy(dp->name, dirent.d_name, DIRSIZ); ! 416: dp->ttyd = dirent.d_ino; ! 417: dp->next = allttys; ! 418: allttys = dp; ! 419: } ! 420: fclose (df); ! 421: } ! 422: } ! 423: ! 424: char * ! 425: gettty() ! 426: { ! 427: register char *p; ! 428: register struct ttys *dp; ! 429: ! 430: if (u.u_ttyino != 0) { ! 431: for (dp = allttys; dp; dp = dp -> next) { ! 432: if (dp->ttyd == u.u_ttyino) { ! 433: p = dp->name; ! 434: if (p[0]=='t' && p[1]=='t' && p[2]=='y') ! 435: p += 3; ! 436: return (p); ! 437: } ! 438: } ! 439: } ! 440: return ("?"); ! 441: } ! 442: ! 443: save() ! 444: { ! 445: register struct savcom *sp; ! 446: register struct asav *ap; ! 447: register char *cp; ! 448: register struct text *xp; ! 449: char *ttyp, *cmdp; ! 450: ! 451: if (mproc->p_stat != SZOMB && getu() == 0) ! 452: return; ! 453: ttyp = gettty(); ! 454: if (xflg == 0 && ttyp[0] == '?' || tptr && strcmp(tptr, ttyp)) ! 455: return; ! 456: sp = &savcom[npr]; ! 457: cmdp = getcmd(); ! 458: if (cmdp == 0) ! 459: return; ! 460: sp->ap = ap = (struct asav *)alloc(sizeof (struct asav)); ! 461: sp->ap->a_cmdp = cmdp; ! 462: #define e(a,b) ap->a = mproc->b ! 463: e(a_flag, p_flag); e(a_stat, p_stat); e(a_nice, p_nice); ! 464: e(a_uid, p_uid); e(a_pid, p_pid); e(a_pri, p_pri); ! 465: e(a_slptime, p_slptime); e(a_time, p_time); ! 466: strncpy(ap->a_tty, ttyp, 5); ! 467: if (ap->a_stat == SZOMB) { ! 468: register struct xproc *xp = (struct xproc *)mproc; ! 469: ! 470: ap->a_cpu = xp->xp_vm.vm_utime + xp->xp_vm.vm_stime; ! 471: } else { ! 472: ap->a_size = mproc->p_dsize + mproc->p_ssize; ! 473: e(a_rss, p_rssize); ! 474: ap->a_ttyd = u.u_ttyino; ! 475: ap->a_cpu = u.u_vm.vm_utime + u.u_vm.vm_stime; ! 476: if (sumcpu) ! 477: ap->a_cpu += u.u_cvm.vm_utime + u.u_cvm.vm_stime; ! 478: if (mproc->p_textp && text) { ! 479: xp = &text[mproc->p_textp - atext]; ! 480: ap->a_tsiz = xp->x_size; ! 481: ap->a_txtrss = xp->x_rssize; ! 482: ap->a_xccount = xp->x_ccount; ! 483: } ! 484: } ! 485: #undef e ! 486: ap->a_cpu /= hz; ! 487: ap->a_maxrss = mproc->p_maxrss; ! 488: if (lflg) { ! 489: register struct lsav *lp; ! 490: ! 491: sp->sun.lp = lp = (struct lsav *)alloc(sizeof (struct lsav)); ! 492: #define e(a,b) lp->a = mproc->b ! 493: e(l_ppid, p_ppid); e(l_cpu, p_cpu); ! 494: if (ap->a_stat != SZOMB) ! 495: e(l_wchan, p_wchan); ! 496: #undef e ! 497: lp->l_addr = pcbpf; ! 498: } else if (vflg) { ! 499: register struct vsav *vp; ! 500: ! 501: sp->sun.vp = vp = (struct vsav *)alloc(sizeof (struct vsav)); ! 502: #define e(a,b) vp->a = mproc->b ! 503: if (ap->a_stat != SZOMB) { ! 504: e(v_swrss, p_swrss); ! 505: vp->v_majflt = u.u_vm.vm_majflt; ! 506: if (mproc->p_textp) ! 507: vp->v_txtswrss = xp->x_swrss; ! 508: } ! 509: vp->v_pctcpu = pcpu(); ! 510: #undef e ! 511: } else if (uflg) ! 512: sp->sun.u_pctcpu = pcpu(); ! 513: else if (sflg) { ! 514: if (ap->a_stat != SZOMB) { ! 515: for (cp = (char *)u.u_stack; ! 516: cp < &user.upages[UPAGES][0]; ) ! 517: if (*cp++) ! 518: break; ! 519: sp->sun.s_ssiz = (&user.upages[UPAGES][0] - cp); ! 520: } ! 521: } ! 522: npr++; ! 523: } ! 524: ! 525: double ! 526: pmem(ap) ! 527: register struct asav *ap; ! 528: { ! 529: double fracmem; ! 530: int szptudot; ! 531: ! 532: if ((ap->a_flag&SLOAD) == 0) ! 533: fracmem = 0.0; ! 534: else { ! 535: szptudot = UPAGES + clrnd(ctopt(ap->a_size+ap->a_tsiz)); ! 536: fracmem = ((float)ap->a_rss+szptudot)/CLSIZE/ecmx; ! 537: if (ap->a_xccount) ! 538: fracmem += ((float)ap->a_txtrss)/CLSIZE/ ! 539: ap->a_xccount/ecmx; ! 540: } ! 541: return (100.0 * fracmem); ! 542: } ! 543: ! 544: double ! 545: pcpu() ! 546: { ! 547: time_t time; ! 548: ! 549: time = mproc->p_time; ! 550: if (time == 0 || (mproc->p_flag&SLOAD) == 0) ! 551: return (0.0); ! 552: if (rawcpu) ! 553: return (100.0 * mproc->p_pctcpu); ! 554: return (100.0 * mproc->p_pctcpu / (1.0 - exp(time * log(ccpu)))); ! 555: } ! 556: ! 557: getu() ! 558: { ! 559: struct pte *pteaddr, apte; ! 560: int pad1; /* avoid hardware botch */ ! 561: struct pte arguutl[UPAGES+CLSIZE]; ! 562: int pad2; /* avoid hardware botch */ ! 563: register int i; ! 564: int ncl, size; ! 565: ! 566: size = sflg ? ctob(UPAGES) : sizeof (struct user); ! 567: if ((mproc->p_flag & SLOAD) == 0) { ! 568: lseek(swap, ctob(mproc->p_swaddr), 0); ! 569: if (read(swap, (char *)&user.user, size) != size) { ! 570: fprintf(stderr, "ps: cant read u for pid %d from %s\n", ! 571: mproc->p_pid, swapf); ! 572: return (0); ! 573: } ! 574: pcbpf = 0; ! 575: argaddr = 0; ! 576: return (1); ! 577: } ! 578: pteaddr = &Usrptma[btokmx(mproc->p_p0br) + mproc->p_szpt - 1]; ! 579: KMlseek(kmem, kflg ? clear(pteaddr) : (int)pteaddr, 0); ! 580: if (read(kmem, (char *)&apte, sizeof(apte)) != sizeof(apte)) { ! 581: printf("ps: cant read indir pte at %x to get u for pid %d from %s\n", ! 582: pteaddr, mproc->p_pid, kmemf); ! 583: return (0); ! 584: } ! 585: lseek(mem, ! 586: ctob(apte.pg_pfnum+1) - (UPAGES+CLSIZE) * sizeof (struct pte), 0); ! 587: if (read(mem, (char *)arguutl, sizeof(arguutl)) != sizeof(arguutl)) { ! 588: printf("ps: cant read page table for u of pid %d from %s\n", ! 589: mproc->p_pid, memf); ! 590: return (0); ! 591: } ! 592: if (arguutl[0].pg_fod == 0 && arguutl[0].pg_pfnum) ! 593: argaddr = ctob(arguutl[0].pg_pfnum); ! 594: else ! 595: argaddr = 0; ! 596: pcbpf = arguutl[CLSIZE].pg_pfnum; ! 597: ncl = (size + NBPG*CLSIZE - 1) / (NBPG*CLSIZE); ! 598: while (--ncl >= 0) { ! 599: i = ncl * CLSIZE; ! 600: lseek(mem, ctob(arguutl[CLSIZE+i].pg_pfnum), 0); ! 601: if (read(mem, user.upages[i], CLSIZE*NBPG) != CLSIZE*NBPG) { ! 602: printf("ps: cant read page %d of u of pid %d from %s\n", ! 603: arguutl[CLSIZE+i].pg_pfnum, mproc->p_pid, memf); ! 604: return(0); ! 605: } ! 606: } ! 607: return (1); ! 608: } ! 609: ! 610: char * ! 611: getcmd() ! 612: { ! 613: char cmdbuf[BUFSIZ]; ! 614: int pad1; /* avoid hardware botch */ ! 615: union { ! 616: char argc[CLSIZE*NBPG]; ! 617: int argi[CLSIZE*NBPG/sizeof (int)]; ! 618: } argspac; ! 619: int pad2; /* avoid hardware botch */ ! 620: register char *cp; ! 621: register int *ip; ! 622: char c; ! 623: int nbad; ! 624: struct dblock db; ! 625: ! 626: if (mproc->p_stat == SZOMB || mproc->p_flag&(SSYS|SWEXIT)) ! 627: return (""); ! 628: if (cflg) { ! 629: strncpy(cmdbuf, u.u_comm, sizeof (u.u_comm)); ! 630: return (savestr(cmdbuf)); ! 631: } ! 632: if ((mproc->p_flag & SLOAD) == 0 || argaddr == 0) { ! 633: vstodb(0, CLSIZE, &u.u_smap, &db, 1); ! 634: lseek(swap, ctob(db.db_base), 0); ! 635: if (read(swap, (char *)&argspac, sizeof(argspac)) ! 636: != sizeof(argspac)) ! 637: goto bad; ! 638: } else { ! 639: lseek(mem, argaddr, 0); ! 640: if (read(mem, (char *)&argspac, sizeof (argspac)) ! 641: != sizeof (argspac)) ! 642: goto bad; ! 643: } ! 644: ip = &argspac.argi[CLSIZE*NBPG/sizeof (int)]; ! 645: ip -= 2; /* last arg word and .long 0 */ ! 646: while (*--ip) ! 647: if (ip == argspac.argi) ! 648: goto retucomm; ! 649: *(char *)ip = ' '; ! 650: ip++; ! 651: nbad = 0; ! 652: for (cp = (char *)ip; cp < &argspac.argc[CLSIZE*NBPG]; cp++) { ! 653: c = *cp & 0177; ! 654: if (c == 0) ! 655: *cp = ' '; ! 656: else if (c < ' ' || c > 0176) { ! 657: if (++nbad >= 5*(eflg+1)) { ! 658: *cp++ = ' '; ! 659: break; ! 660: } ! 661: *cp = '?'; ! 662: } else if (eflg == 0 && c == '=') { ! 663: while (*--cp != ' ') ! 664: if (cp <= (char *)ip) ! 665: break; ! 666: break; ! 667: } ! 668: } ! 669: *cp = 0; ! 670: while (*--cp == ' ') ! 671: *cp = 0; ! 672: cp = (char *)ip; ! 673: strncpy(cmdbuf, cp, &argspac.argc[CLSIZE*NBPG] - cp); ! 674: if (cp[0] == '-' || cp[0] == '?' || cp[0] <= ' ') { ! 675: strcat(cmdbuf, " ("); ! 676: strncat(cmdbuf, u.u_comm, sizeof(u.u_comm)); ! 677: strcat(cmdbuf, ")"); ! 678: } ! 679: if (xflg == 0 && gflg == 0 && tptr == 0 && cp[0] == '-') ! 680: return (0); ! 681: return (savestr(cmdbuf)); ! 682: ! 683: bad: ! 684: fprintf(stderr, "ps: error locating command name for pid %d\n", ! 685: mproc->p_pid); ! 686: retucomm: ! 687: strcpy(cmdbuf, " ("); ! 688: strncat(cmdbuf, u.u_comm, sizeof (u.u_comm)); ! 689: strcat(cmdbuf, ")"); ! 690: return (savestr(cmdbuf)); ! 691: } ! 692: ! 693: char *lhdr = ! 694: "F UID PID PPID CP PRI NI ADDR SZ RSS WCHAN STAT TTY TIME"; ! 695: lpr(sp) ! 696: struct savcom *sp; ! 697: { ! 698: register struct asav *ap = sp->ap; ! 699: register struct lsav *lp = sp->sun.lp; ! 700: ! 701: printf("%x%5d%6u%6u%4d%4d%4d%5x%4d%5d", ! 702: ap->a_flag, ap->a_uid, ! 703: ap->a_pid, lp->l_ppid, lp->l_cpu&0377, ap->a_pri-PZERO, ! 704: ap->a_nice-NZERO, lp->l_addr, ap->a_size/2, ap->a_rss/2); ! 705: printf(lp->l_wchan ? "%9x" : " ", (int)lp->l_wchan&~0x80000000); ! 706: printf(" %4.4s ", state(ap)); ! 707: ptty(ap->a_tty); ! 708: ptime(ap); ! 709: } ! 710: ! 711: ptty(tp) ! 712: char *tp; ! 713: { ! 714: ! 715: printf("%-5.5s", tp); ! 716: } ! 717: ! 718: ptime(ap) ! 719: struct asav *ap; ! 720: { ! 721: ! 722: printf("%4ld:%02ld", ap->a_cpu / hz, ap->a_cpu % hz); ! 723: } ! 724: ! 725: char *uhdr = ! 726: "USER PID %CPU %MEM SZ RSS TTY STAT TIME"; ! 727: upr(sp) ! 728: struct savcom *sp; ! 729: { ! 730: register struct asav *ap = sp->ap; ! 731: int vmsize, rmsize; ! 732: ! 733: vmsize = (ap->a_size + ap->a_tsiz)/2; ! 734: rmsize = ap->a_rss/2; ! 735: if (ap->a_xccount) ! 736: rmsize += ap->a_txtrss/ap->a_xccount/2; ! 737: printf("%-8.8s %5d%5.1f%5.1f%5d%5d", ! 738: getname(ap->a_uid), ap->a_pid, sp->sun.u_pctcpu, pmem(ap), ! 739: vmsize, rmsize); ! 740: putchar(' '); ! 741: ptty(ap->a_tty); ! 742: printf(" %4.4s", state(ap)); ! 743: ptime(ap); ! 744: } ! 745: ! 746: char *vhdr = ! 747: " PID TTY STAT TIME SL RE PAGEIN SIZE RSS LIM TSIZ TRS %CPU %MEM"; ! 748: vpr(sp) ! 749: struct savcom *sp; ! 750: { ! 751: register struct vsav *vp = sp->sun.vp; ! 752: register struct asav *ap = sp->ap; ! 753: ! 754: printf("%5u ", ap->a_pid); ! 755: ptty(ap->a_tty); ! 756: printf(" %4.4s", state(ap)); ! 757: ptime(ap); ! 758: printf("%3d%3d%7d%5d%5d", ! 759: ap->a_slptime > 99 ? 99 : ap-> a_slptime, ! 760: ap->a_time > 99 ? 99 : ap->a_time, vp->v_majflt, ! 761: ap->a_size/2, ap->a_rss/2); ! 762: if (ap->a_maxrss == (INFINITY/NBPG)) ! 763: printf(" xx"); ! 764: else ! 765: printf("%5d", ap->a_maxrss/2); ! 766: printf("%5d%4d%5.1f%5.1f", ! 767: ap->a_tsiz/2, ap->a_txtrss/2, vp->v_pctcpu, pmem(ap)); ! 768: } ! 769: ! 770: char *shdr = ! 771: "SSIZ PID TTY STAT TIME"; ! 772: spr(sp) ! 773: struct savcom *sp; ! 774: { ! 775: register struct asav *ap = sp->ap; ! 776: ! 777: if (sflg) ! 778: printf("%4d ", sp->sun.s_ssiz); ! 779: printf("%5u", ap->a_pid); ! 780: putchar(' '); ! 781: ptty(ap->a_tty); ! 782: printf(" %4.4s", state(ap)); ! 783: ptime(ap); ! 784: } ! 785: ! 786: char * ! 787: state(ap) ! 788: register struct asav *ap; ! 789: { ! 790: char stat, load, nice, anom; ! 791: static char res[5]; ! 792: ! 793: switch (ap->a_stat) { ! 794: ! 795: case SSTOP: ! 796: stat = 'T'; ! 797: break; ! 798: ! 799: case SSLEEP: ! 800: if (ap->a_pri >= PZERO) ! 801: if (ap->a_slptime >= MAXSLP) ! 802: stat = 'I'; ! 803: else ! 804: stat = 'S'; ! 805: else if (ap->a_flag & SPAGE) ! 806: stat = 'P'; ! 807: else ! 808: stat = 'D'; ! 809: break; ! 810: ! 811: case SWAIT: ! 812: case SRUN: ! 813: case SIDL: ! 814: stat = 'R'; ! 815: break; ! 816: ! 817: case SZOMB: ! 818: stat = 'Z'; ! 819: break; ! 820: ! 821: default: ! 822: stat = '?'; ! 823: } ! 824: load = ap->a_flag & SLOAD ? (ap->a_rss>ap->a_maxrss ? '>' : ' ') : 'W'; ! 825: if (ap->a_nice < NZERO) ! 826: nice = '<'; ! 827: else if (ap->a_nice > NZERO) ! 828: nice = 'N'; ! 829: else ! 830: nice = ' '; ! 831: anom = (ap->a_flag&SUANOM) ? 'A' : ((ap->a_flag&SSEQL) ? 'S' : ' '); ! 832: res[0] = stat; res[1] = load; res[2] = nice; res[3] = anom; ! 833: return (res); ! 834: } ! 835: ! 836: /* ! 837: * Given a base/size pair in virtual swap area, ! 838: * return a physical base/size pair which is the ! 839: * (largest) initial, physically contiguous block. ! 840: */ ! 841: vstodb(vsbase, vssize, dmp, dbp, rev) ! 842: register int vsbase; ! 843: int vssize; ! 844: struct dmap *dmp; ! 845: register struct dblock *dbp; ! 846: { ! 847: register int blk = DMMIN; ! 848: register swblk_t *ip = dmp->dm_map; ! 849: ! 850: if (vsbase < 0 || vsbase + vssize > dmp->dm_size) ! 851: panic("vstodb"); ! 852: while (vsbase >= blk) { ! 853: vsbase -= blk; ! 854: if (blk < DMMAX) ! 855: blk *= 2; ! 856: ip++; ! 857: } ! 858: if (*ip <= 0 || *ip + blk > nswap) ! 859: panic("vstodb *ip"); ! 860: dbp->db_size = min(vssize, blk - vsbase); ! 861: dbp->db_base = *ip + (rev ? blk - (vsbase + dbp->db_size) : vsbase); ! 862: } ! 863: ! 864: /*ARGSUSED*/ ! 865: panic(cp) ! 866: char *cp; ! 867: { ! 868: ! 869: #ifdef DEBUG ! 870: printf("%s\n", cp); ! 871: #endif ! 872: } ! 873: ! 874: min(a, b) ! 875: { ! 876: ! 877: return (a < b ? a : b); ! 878: } ! 879: ! 880: pscomp(s1, s2) ! 881: struct savcom *s1, *s2; ! 882: { ! 883: register int i; ! 884: ! 885: if (uflg) ! 886: return (s2->sun.u_pctcpu > s1->sun.u_pctcpu ? 1 : -1); ! 887: if (vflg) ! 888: return (vsize(s2) - vsize(s1)); ! 889: i = s1->ap->a_ttyd - s2->ap->a_ttyd; ! 890: if (i == 0) ! 891: i = s1->ap->a_pid - s2->ap->a_pid; ! 892: return (i); ! 893: } ! 894: ! 895: vsize(sp) ! 896: struct savcom *sp; ! 897: { ! 898: register struct asav *ap = sp->ap; ! 899: register struct vsav *vp = sp->sun.vp; ! 900: ! 901: if (ap->a_flag & SLOAD) ! 902: return (ap->a_rss + ! 903: ap->a_txtrss / (ap->a_xccount ? ap->a_xccount : 1)); ! 904: return (vp->v_swrss + (ap->a_xccount ? 0 : vp->v_txtswrss)); ! 905: } ! 906: ! 907: #define NMAX 8 ! 908: #define NUID 2048 ! 909: ! 910: char names[NUID][NMAX+1]; ! 911: ! 912: /* ! 913: * Stolen from ls... ! 914: */ ! 915: char * ! 916: getname(uid) ! 917: { ! 918: register struct passwd *pw; ! 919: static init; ! 920: struct passwd *getpwent(); ! 921: ! 922: if (uid >= 0 && uid < NUID && names[uid][0]) ! 923: return (&names[uid][0]); ! 924: if (init == 2) ! 925: return (0); ! 926: if (init == 0) ! 927: setpwent(), init = 1; ! 928: while (pw = getpwent()) { ! 929: if (pw->pw_uid >= NUID) ! 930: continue; ! 931: if (names[pw->pw_uid][0]) ! 932: continue; ! 933: strncpy(names[pw->pw_uid], pw->pw_name, NMAX); ! 934: if (pw->pw_uid == uid) ! 935: return (&names[uid][0]); ! 936: } ! 937: init = 2; ! 938: endpwent(); ! 939: return (0); ! 940: } ! 941: ! 942: char *freebase; ! 943: int nleft; ! 944: ! 945: char * ! 946: alloc(size) ! 947: int size; ! 948: { ! 949: register char *cp; ! 950: register int i; ! 951: ! 952: if (size > nleft) { ! 953: freebase = (char *)sbrk(i = size > 2048 ? size : 2048); ! 954: if (freebase == 0) { ! 955: fprintf(stderr, "ps: ran out of memory\n"); ! 956: exit(1); ! 957: } ! 958: nleft = i - size; ! 959: } else ! 960: nleft -= size; ! 961: cp = freebase; ! 962: for (i = size; --i >= 0; ) ! 963: *cp++ = 0; ! 964: freebase = cp; ! 965: return (cp - size); ! 966: } ! 967: ! 968: char * ! 969: savestr(cp) ! 970: char *cp; ! 971: { ! 972: register int len; ! 973: register char *dp; ! 974: ! 975: len = strlen(cp); ! 976: dp = (char *)alloc(len+1); ! 977: strcpy(dp, cp); ! 978: return (dp); ! 979: } ! 980: ! 981: KMlseek(f, a, c) ! 982: long a; ! 983: { ! 984: if (kflg) ! 985: a = clear(a); ! 986: lseek(f, a, c); ! 987: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.