![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pstat.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / etc|
Return to pstat.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / etc |
1.1 ! root 1: /* ! 2: * Copyright (c) 1980 Regents of the University of California. ! 3: * All rights reserved. The Berkeley software License Agreement ! 4: * specifies the terms and conditions for redistribution. ! 5: */ ! 6: ! 7: #ifndef lint ! 8: char copyright[] = ! 9: "@(#) Copyright (c) 1980 Regents of the University of California.\n\ ! 10: All rights reserved.\n"; ! 11: #endif /* not lint */ ! 12: ! 13: #ifndef lint ! 14: static char sccsid[] = "@(#)pstat.c 5.18 (Berkeley) 2/27/88"; ! 15: #endif /* not lint */ ! 16: ! 17: /* ! 18: * Print system stuff ! 19: */ ! 20: ! 21: #include <sys/param.h> ! 22: #include <sys/dir.h> ! 23: #define KERNEL ! 24: #include <sys/file.h> ! 25: #undef KERNEL ! 26: #include <sys/user.h> ! 27: #include <sys/proc.h> ! 28: #include <sys/text.h> ! 29: #include <sys/inode.h> ! 30: #include <sys/map.h> ! 31: #include <sys/ioctl.h> ! 32: #include <sys/tty.h> ! 33: #include <sys/conf.h> ! 34: #include <sys/vm.h> ! 35: #include <nlist.h> ! 36: #include <machine/pte.h> ! 37: #include <stdio.h> ! 38: ! 39: #define mask(x) (x&0377) ! 40: #define clear(x) ((int)x &~ KERNBASE) ! 41: ! 42: char *fcore = "/dev/kmem"; ! 43: char *fmem = "/dev/mem"; ! 44: char *fnlist = "/vmunix"; ! 45: int fc, fm; ! 46: ! 47: struct nlist nl[] = { ! 48: #define SINODE 0 ! 49: { "_inode" }, ! 50: #define STEXT 1 ! 51: { "_text" }, ! 52: #define SPROC 2 ! 53: { "_proc" }, ! 54: #define SCONS 3 ! 55: { "_cons" }, ! 56: #define SFIL 4 ! 57: { "_file" }, ! 58: #define USRPTMA 5 ! 59: { "_Usrptmap" }, ! 60: #define USRPT 6 ! 61: { "_usrpt" }, ! 62: #define SWAPMAP 7 ! 63: { "_swapmap" }, ! 64: #define SNPROC 8 ! 65: { "_nproc" }, ! 66: #define SNTEXT 9 ! 67: { "_ntext" }, ! 68: #define SNFILE 10 ! 69: { "_nfile" }, ! 70: #define SNINODE 11 ! 71: { "_ninode" }, ! 72: #define SNSWAPMAP 12 ! 73: { "_nswapmap" }, ! 74: #define SPTY 13 ! 75: { "_pt_tty" }, ! 76: #define SDMMIN 14 ! 77: { "_dmmin" }, ! 78: #define SDMMAX 15 ! 79: { "_dmmax" }, ! 80: #define SNSWDEV 16 ! 81: { "_nswdev" }, ! 82: #define SSWDEVT 17 ! 83: { "_swdevt" }, ! 84: #define SYSMAP 18 ! 85: { "_Sysmap" }, ! 86: #define SNPTY 19 ! 87: { "_npty" }, ! 88: #ifdef vax ! 89: #define SDZ (SNPTY+1) ! 90: { "_dz_tty" }, ! 91: #define SNDZ (SNPTY+2) ! 92: { "_dz_cnt" }, ! 93: #define SDMF (SNPTY+3) ! 94: { "_dmf_tty" }, ! 95: #define SNDMF (SNPTY+4) ! 96: { "_ndmf" }, ! 97: #define SDH (SNPTY+5) ! 98: { "_dh11" }, ! 99: #define SNDH (SNPTY+6) ! 100: { "_ndh11" }, ! 101: #define SDHU (SNPTY+7) ! 102: { "_dhu_tty" }, ! 103: #define SNDHU (SNPTY+8) ! 104: { "_ndhu" }, ! 105: #define SDMZ (SNPTY+9) ! 106: { "_dmz_tty" }, ! 107: #define SNDMZ (SNPTY+10) ! 108: { "_ndmz" }, ! 109: #define SQD (SNPTY+11) ! 110: { "_qd_tty" }, ! 111: #define SNQD (SNPTY+12) ! 112: { "_nNQD" }, ! 113: #endif ! 114: #ifdef tahoe ! 115: #define SVX (SNPTY+1) ! 116: { "_vx_tty" }, ! 117: #define SNVX (SNPTY+2) ! 118: { "_nvx" }, ! 119: #define SMP (SNPTY+3) ! 120: { "_mp_tty" }, ! 121: #define SNMP (SNPTY+4) ! 122: { "_nmp" }, ! 123: #endif ! 124: { "" } ! 125: }; ! 126: ! 127: int inof; ! 128: int txtf; ! 129: int prcf; ! 130: int ttyf; ! 131: int usrf; ! 132: long ubase; ! 133: int filf; ! 134: int swpf; ! 135: int totflg; ! 136: char partab[1]; ! 137: struct cdevsw cdevsw[1]; ! 138: struct bdevsw bdevsw[1]; ! 139: int allflg; ! 140: int kflg; ! 141: struct pte *Usrptma; ! 142: struct pte *usrpt; ! 143: u_long getword(); ! 144: off_t mkphys(); ! 145: ! 146: main(argc, argv) ! 147: int argc; ! 148: char **argv; ! 149: { ! 150: extern char *optarg; ! 151: extern int optind; ! 152: int ch; ! 153: ! 154: while ((ch = getopt(argc, argv, "Tafikptu:sx")) != EOF) ! 155: switch((char)ch) { ! 156: case 'T': ! 157: totflg++; ! 158: break; ! 159: case 'a': ! 160: allflg++; ! 161: /*FALLTHROUGH*/ ! 162: case 'p': ! 163: prcf++; ! 164: break; ! 165: case 'f': ! 166: filf++; ! 167: break; ! 168: case 'i': ! 169: inof++; ! 170: break; ! 171: case 'k': /* undocumented */ ! 172: kflg++; ! 173: fcore = fmem = "/vmcore"; ! 174: break; ! 175: case 't': ! 176: ttyf++; ! 177: break; ! 178: case 'u': ! 179: usrf++; ! 180: sscanf(optarg, "%x", &ubase); ! 181: break; ! 182: case 's': ! 183: swpf++; ! 184: break; ! 185: case 'x': ! 186: txtf++; ! 187: break; ! 188: case '?': ! 189: default: ! 190: printf("usage: pstat -[Tafiptsx] [-u [ubase]] [system] [core]\n"); ! 191: exit(1); ! 192: } ! 193: argc -= optind; ! 194: argv += optind; ! 195: ! 196: if (argc>1) { ! 197: fcore = fmem = argv[1]; ! 198: kflg++; ! 199: } ! 200: if ((fc = open(fcore, O_RDONLY, 0)) < 0) { ! 201: perror(fcore); ! 202: exit(1); ! 203: } ! 204: if ((fm = open(fmem, O_RDONLY, 0)) < 0) { ! 205: perror(fmem); ! 206: exit(1); ! 207: } ! 208: if (argc>0) ! 209: fnlist = argv[0]; ! 210: nlist(fnlist, nl); ! 211: if (nl[0].n_type == 0) { ! 212: printf("pstat: no namelist.\n"); ! 213: exit(1); ! 214: } ! 215: usrpt = (struct pte *)nl[USRPT].n_value; ! 216: Usrptma = (struct pte *)nl[USRPTMA].n_value; ! 217: if (!(filf | totflg | inof | prcf | txtf | ttyf | usrf | swpf)) { ! 218: printf("pstat: one or more of -[aixptfsu] is required\n"); ! 219: exit(1); ! 220: } ! 221: if (filf||totflg) ! 222: dofile(); ! 223: if (inof||totflg) ! 224: doinode(); ! 225: if (prcf||totflg) ! 226: doproc(); ! 227: if (txtf||totflg) ! 228: dotext(); ! 229: if (ttyf) ! 230: dotty(); ! 231: if (usrf) ! 232: dousr(); ! 233: if (swpf||totflg) ! 234: doswap(); ! 235: } ! 236: ! 237: doinode() ! 238: { ! 239: register struct inode *ip; ! 240: struct inode *xinode, *ainode; ! 241: register int nin; ! 242: int ninode; ! 243: ! 244: nin = 0; ! 245: ninode = getword(nl[SNINODE].n_value); ! 246: xinode = (struct inode *)calloc(ninode, sizeof (struct inode)); ! 247: ainode = (struct inode *)getword(nl[SINODE].n_value); ! 248: if (ninode < 0 || ninode > 10000) { ! 249: fprintf(stderr, "number of inodes is preposterous (%d)\n", ! 250: ninode); ! 251: return; ! 252: } ! 253: if (xinode == NULL) { ! 254: fprintf(stderr, "can't allocate memory for inode table\n"); ! 255: return; ! 256: } ! 257: lseek(fc, mkphys((off_t)ainode), 0); ! 258: read(fc, xinode, ninode * sizeof(struct inode)); ! 259: for (ip = xinode; ip < &xinode[ninode]; ip++) ! 260: if (ip->i_count) ! 261: nin++; ! 262: if (totflg) { ! 263: printf("%3d/%3d inodes\n", nin, ninode); ! 264: return; ! 265: } ! 266: printf("%d/%d active inodes\n", nin, ninode); ! 267: printf(" LOC FLAGS CNT DEVICE RDC WRC INO MODE NLK UID SIZE/DEV\n"); ! 268: for (ip = xinode; ip < &xinode[ninode]; ip++) { ! 269: if (ip->i_count == 0) ! 270: continue; ! 271: printf("%8.1x ", ainode + (ip - xinode)); ! 272: putf(ip->i_flag&ILOCKED, 'L'); ! 273: putf(ip->i_flag&IUPD, 'U'); ! 274: putf(ip->i_flag&IACC, 'A'); ! 275: putf(ip->i_flag&IMOUNT, 'M'); ! 276: putf(ip->i_flag&IWANT, 'W'); ! 277: putf(ip->i_flag&ITEXT, 'T'); ! 278: putf(ip->i_flag&ICHG, 'C'); ! 279: putf(ip->i_flag&ISHLOCK, 'S'); ! 280: putf(ip->i_flag&IEXLOCK, 'E'); ! 281: putf(ip->i_flag&ILWAIT, 'Z'); ! 282: printf("%4d", ip->i_count&0377); ! 283: printf("%4d,%3d", major(ip->i_dev), minor(ip->i_dev)); ! 284: printf("%4d", ip->i_shlockc&0377); ! 285: printf("%4d", ip->i_exlockc&0377); ! 286: printf("%6d", ip->i_number); ! 287: printf("%6x", ip->i_mode & 0xffff); ! 288: printf("%4d", ip->i_nlink); ! 289: printf("%4d", ip->i_uid); ! 290: if ((ip->i_mode&IFMT)==IFBLK || (ip->i_mode&IFMT)==IFCHR) ! 291: printf("%6d,%3d", major(ip->i_rdev), minor(ip->i_rdev)); ! 292: else ! 293: printf("%10ld", ip->i_size); ! 294: printf("\n"); ! 295: } ! 296: free(xinode); ! 297: } ! 298: ! 299: u_long ! 300: getword(loc) ! 301: off_t loc; ! 302: { ! 303: u_long word; ! 304: ! 305: if (kflg) ! 306: loc = clear(loc); ! 307: lseek(fc, loc, 0); ! 308: read(fc, &word, sizeof (word)); ! 309: return (word); ! 310: } ! 311: ! 312: putf(v, n) ! 313: { ! 314: if (v) ! 315: printf("%c", n); ! 316: else ! 317: printf(" "); ! 318: } ! 319: ! 320: dotext() ! 321: { ! 322: register struct text *xp; ! 323: int ntext; ! 324: struct text *xtext, *atext; ! 325: int ntx, ntxca; ! 326: ! 327: ntx = ntxca = 0; ! 328: ntext = getword(nl[SNTEXT].n_value); ! 329: xtext = (struct text *)calloc(ntext, sizeof (struct text)); ! 330: atext = (struct text *)getword(nl[STEXT].n_value); ! 331: if (ntext < 0 || ntext > 10000) { ! 332: fprintf(stderr, "number of texts is preposterous (%d)\n", ! 333: ntext); ! 334: return; ! 335: } ! 336: if (xtext == NULL) { ! 337: fprintf(stderr, "can't allocate memory for text table\n"); ! 338: return; ! 339: } ! 340: lseek(fc, mkphys((off_t)atext), 0); ! 341: read(fc, xtext, ntext * sizeof (struct text)); ! 342: for (xp = xtext; xp < &xtext[ntext]; xp++) { ! 343: if (xp->x_iptr != NULL) ! 344: ntxca++; ! 345: if (xp->x_count != 0) ! 346: ntx++; ! 347: } ! 348: if (totflg) { ! 349: printf("%3d/%3d texts active, %3d used\n", ntx, ntext, ntxca); ! 350: return; ! 351: } ! 352: printf("%d/%d active texts, %d used\n", ntx, ntext, ntxca); ! 353: printf("\ ! 354: LOC FLAGS DADDR CADDR RSS SIZE IPTR CNT CCNT FORW BACK\n"); ! 355: for (xp = xtext; xp < &xtext[ntext]; xp++) { ! 356: if (xp->x_iptr == NULL) ! 357: continue; ! 358: printf("%8.1x", atext + (xp - xtext)); ! 359: printf(" "); ! 360: putf(xp->x_flag&XPAGI, 'P'); ! 361: putf(xp->x_flag&XTRC, 'T'); ! 362: putf(xp->x_flag&XWRIT, 'W'); ! 363: putf(xp->x_flag&XLOAD, 'L'); ! 364: putf(xp->x_flag&XLOCK, 'K'); ! 365: putf(xp->x_flag&XWANT, 'w'); ! 366: printf("%5x", xp->x_daddr[0]); ! 367: printf("%10x", xp->x_caddr); ! 368: printf("%5d", xp->x_rssize); ! 369: printf("%5d", xp->x_size); ! 370: printf("%10.1x", xp->x_iptr); ! 371: printf("%5d", xp->x_count&0377); ! 372: printf("%5d", xp->x_ccount); ! 373: printf("%10x", xp->x_forw); ! 374: printf("%9x", xp->x_back); ! 375: printf("\n"); ! 376: } ! 377: free(xtext); ! 378: } ! 379: ! 380: doproc() ! 381: { ! 382: struct proc *xproc, *aproc; ! 383: int nproc; ! 384: register struct proc *pp; ! 385: register loc, np; ! 386: struct pte apte; ! 387: ! 388: nproc = getword(nl[SNPROC].n_value); ! 389: xproc = (struct proc *)calloc(nproc, sizeof (struct proc)); ! 390: aproc = (struct proc *)getword(nl[SPROC].n_value); ! 391: if (nproc < 0 || nproc > 10000) { ! 392: fprintf(stderr, "number of procs is preposterous (%d)\n", ! 393: nproc); ! 394: return; ! 395: } ! 396: if (xproc == NULL) { ! 397: fprintf(stderr, "can't allocate memory for proc table\n"); ! 398: return; ! 399: } ! 400: lseek(fc, mkphys((off_t)aproc), 0); ! 401: read(fc, xproc, nproc * sizeof (struct proc)); ! 402: np = 0; ! 403: for (pp=xproc; pp < &xproc[nproc]; pp++) ! 404: if (pp->p_stat) ! 405: np++; ! 406: if (totflg) { ! 407: printf("%3d/%3d processes\n", np, nproc); ! 408: return; ! 409: } ! 410: printf("%d/%d processes\n", np, nproc); ! 411: printf(" LOC S F POIP PRI SIG UID SLP TIM CPU NI PGRP PID PPID ADDR RSS SRSS SIZE WCHAN LINK TEXTP\n"); ! 412: for (pp=xproc; pp<&xproc[nproc]; pp++) { ! 413: if (pp->p_stat==0 && allflg==0) ! 414: continue; ! 415: printf("%8x", aproc + (pp - xproc)); ! 416: printf(" %2d", pp->p_stat); ! 417: printf(" %4x", pp->p_flag & 0xffff); ! 418: printf(" %4d", pp->p_poip); ! 419: printf(" %3d", pp->p_pri); ! 420: printf(" %8x", pp->p_sig); ! 421: printf(" %4d", pp->p_uid); ! 422: printf(" %3d", pp->p_slptime); ! 423: printf(" %3d", pp->p_time); ! 424: printf(" %4d", pp->p_cpu&0377); ! 425: printf(" %3d", pp->p_nice); ! 426: printf(" %6d", pp->p_pgrp); ! 427: printf(" %6d", pp->p_pid); ! 428: printf(" %6d", pp->p_ppid); ! 429: if (kflg) ! 430: pp->p_addr = (struct pte *)clear((int)pp->p_addr); ! 431: if (pp->p_flag & SLOAD) { ! 432: lseek(fc, (long)pp->p_addr, 0); ! 433: read(fc, &apte, sizeof(apte)); ! 434: printf(" %8x", apte.pg_pfnum); ! 435: } else ! 436: printf(" %8x", pp->p_swaddr); ! 437: printf(" %4x", pp->p_rssize); ! 438: printf(" %4x", pp->p_swrss); ! 439: printf(" %5x", pp->p_dsize+pp->p_ssize); ! 440: printf(" %7x", clear(pp->p_wchan)); ! 441: printf(" %7x", clear(pp->p_link)); ! 442: printf(" %7x", clear(pp->p_textp)); ! 443: printf("\n"); ! 444: } ! 445: free(xproc); ! 446: } ! 447: ! 448: static char mesg[] = ! 449: " # RAW CAN OUT MODE ADDR DEL COL STATE PGRP DISC\n"; ! 450: static int ttyspace = 128; ! 451: static struct tty *tty; ! 452: ! 453: dotty() ! 454: { ! 455: extern char *malloc(); ! 456: ! 457: if ((tty = (struct tty *)malloc(ttyspace * sizeof(*tty))) == 0) { ! 458: printf("pstat: out of memory\n"); ! 459: return; ! 460: } ! 461: printf("1 cons\n"); ! 462: if (kflg) ! 463: nl[SCONS].n_value = clear(nl[SCONS].n_value); ! 464: lseek(fc, (long)nl[SCONS].n_value, 0); ! 465: read(fc, tty, sizeof(*tty)); ! 466: printf(mesg); ! 467: ttyprt(&tty[0], 0); ! 468: #ifdef vax ! 469: if (nl[SNQD].n_type != 0) ! 470: doqdss(); ! 471: if (nl[SNDZ].n_type != 0) ! 472: dottytype("dz", SDZ, SNDZ); ! 473: if (nl[SNDH].n_type != 0) ! 474: dottytype("dh", SDH, SNDH); ! 475: if (nl[SNDMF].n_type != 0) ! 476: dottytype("dmf", SDMF, SNDMF); ! 477: if (nl[SNDHU].n_type != 0) ! 478: dottytype("dhu", SDHU, SNDHU); ! 479: if (nl[SNDMZ].n_type != 0) ! 480: dottytype("dmz", SDMZ, SNDMZ); ! 481: #endif ! 482: #ifdef tahoe ! 483: if (nl[SNVX].n_type != 0) ! 484: dottytype("vx", SVX, SNVX); ! 485: if (nl[SNMP].n_type != 0) ! 486: dottytype("mp", SMP, SNMP); ! 487: #endif ! 488: if (nl[SNPTY].n_type != 0) ! 489: dottytype("pty", SPTY, SNPTY); ! 490: } ! 491: ! 492: /* ! 493: * Special case the qdss because there are 4 tty structs per qdss ! 494: * and only the first of each is used as a tty. ! 495: */ ! 496: #ifdef vax ! 497: doqdss() ! 498: { ! 499: int nqd; ! 500: register struct tty *tp; ! 501: ! 502: if (kflg) { ! 503: nl[SNQD].n_value = clear(nl[SNQD].n_value); ! 504: nl[SQD].n_value = clear(nl[SQD].n_value); ! 505: } ! 506: lseek(fc, (long)nl[SNQD].n_value, 0); ! 507: read(fc, &nqd, sizeof(nqd)); ! 508: printf("%d qd\n", nqd); ! 509: lseek(fc, (long)nl[SQD].n_value, 0); ! 510: read(fc, tty, nqd * sizeof(struct tty) * 4); ! 511: printf(mesg); ! 512: for (tp = tty; tp < &tty[nqd * 4]; tp += 4) ! 513: ttyprt(tp, tp - tty); ! 514: } ! 515: #endif ! 516: ! 517: dottytype(name, type, number) ! 518: char *name; ! 519: { ! 520: int ntty; ! 521: register struct tty *tp; ! 522: extern char *realloc(); ! 523: ! 524: if (tty == (struct tty *)0) ! 525: return; ! 526: if (kflg) { ! 527: nl[number].n_value = clear(nl[number].n_value); ! 528: nl[type].n_value = clear(nl[type].n_value); ! 529: } ! 530: lseek(fc, (long)nl[number].n_value, 0); ! 531: read(fc, &ntty, sizeof(ntty)); ! 532: printf("%d %s lines\n", ntty, name); ! 533: if (ntty > ttyspace) { ! 534: ttyspace = ntty; ! 535: if ((tty = (struct tty *)realloc(tty, ttyspace * sizeof(*tty))) == 0) { ! 536: printf("pstat: out of memory\n"); ! 537: return; ! 538: } ! 539: } ! 540: lseek(fc, (long)nl[type].n_value, 0); ! 541: read(fc, tty, ntty * sizeof(struct tty)); ! 542: printf(mesg); ! 543: for (tp = tty; tp < &tty[ntty]; tp++) ! 544: ttyprt(tp, tp - tty); ! 545: } ! 546: ! 547: ttyprt(atp, line) ! 548: struct tty *atp; ! 549: { ! 550: register struct tty *tp; ! 551: ! 552: printf("%2d", line); ! 553: tp = atp; ! 554: switch (tp->t_line) { ! 555: ! 556: #ifdef notdef ! 557: case NETLDISC: ! 558: if (tp->t_rec) ! 559: printf("%4d%4d", 0, tp->t_inbuf); ! 560: else ! 561: printf("%4d%4d", tp->t_inbuf, 0); ! 562: break; ! 563: #endif ! 564: ! 565: default: ! 566: printf("%4d%4d", tp->t_rawq.c_cc, tp->t_canq.c_cc); ! 567: } ! 568: printf("%4d %8x %8x%4d%4d", tp->t_outq.c_cc, tp->t_flags, ! 569: tp->t_addr, tp->t_delct, tp->t_col); ! 570: putf(tp->t_state&TS_TIMEOUT, 'T'); ! 571: putf(tp->t_state&TS_WOPEN, 'W'); ! 572: putf(tp->t_state&TS_ISOPEN, 'O'); ! 573: putf(tp->t_state&TS_FLUSH, 'F'); ! 574: putf(tp->t_state&TS_CARR_ON, 'C'); ! 575: putf(tp->t_state&TS_BUSY, 'B'); ! 576: putf(tp->t_state&TS_ASLEEP, 'A'); ! 577: putf(tp->t_state&TS_XCLUDE, 'X'); ! 578: putf(tp->t_state&TS_TTSTOP, 'S'); ! 579: putf(tp->t_state&TS_HUPCLS, 'H'); ! 580: printf("%6d", tp->t_pgrp); ! 581: switch (tp->t_line) { ! 582: ! 583: case OTTYDISC: ! 584: printf("\n"); ! 585: break; ! 586: ! 587: case NTTYDISC: ! 588: printf(" ntty\n"); ! 589: break; ! 590: ! 591: case NETLDISC: ! 592: printf(" berknet\n"); ! 593: break; ! 594: ! 595: case TABLDISC: ! 596: printf(" tab\n"); ! 597: break; ! 598: ! 599: case SLIPDISC: ! 600: printf(" slip\n"); ! 601: break; ! 602: ! 603: default: ! 604: printf(" %d\n", tp->t_line); ! 605: } ! 606: } ! 607: ! 608: dousr() ! 609: { ! 610: struct user U; ! 611: register i, j, *ip; ! 612: register struct nameidata *nd = &U.u_nd; ! 613: ! 614: /* This wins only if CLBYTES >= sizeof (struct user) */ ! 615: lseek(fm, ubase * NBPG, 0); ! 616: read(fm, &U, sizeof(U)); ! 617: printf("pcb"); ! 618: ip = (int *)&U.u_pcb; ! 619: while (ip < &U.u_arg[0]) { ! 620: if ((ip - (int *)&U.u_pcb) % 4 == 0) ! 621: printf("\t"); ! 622: printf("%x ", *ip++); ! 623: if ((ip - (int *)&U.u_pcb) % 4 == 0) ! 624: printf("\n"); ! 625: } ! 626: if ((ip - (int *)&U.u_pcb) % 4 != 0) ! 627: printf("\n"); ! 628: printf("arg"); ! 629: for (i=0; i<sizeof(U.u_arg)/sizeof(U.u_arg[0]); i++) { ! 630: if (i%5==0) ! 631: printf("\t"); ! 632: printf(" %.1x", U.u_arg[i]); ! 633: if (i%5==4) ! 634: printf("\n"); ! 635: } ! 636: if (i%5) ! 637: printf("\n"); ! 638: printf("segflg\t%d\nerror %d\n", nd->ni_segflg, U.u_error); ! 639: printf("uids\t%d,%d,%d,%d\n", U.u_uid,U.u_gid,U.u_ruid,U.u_rgid); ! 640: printf("procp\t%.1x\n", U.u_procp); ! 641: printf("ap\t%.1x\n", U.u_ap); ! 642: printf("r_val?\t%.1x %.1x\n", U.u_r.r_val1, U.u_r.r_val2); ! 643: printf("base, count, offset %.1x %.1x %ld\n", nd->ni_base, ! 644: nd->ni_count, nd->ni_offset); ! 645: printf("cdir rdir %.1x %.1x\n", U.u_cdir, U.u_rdir); ! 646: printf("dirp %.1x\n", nd->ni_dirp); ! 647: printf("dent %d %.14s\n", nd->ni_dent.d_ino, nd->ni_dent.d_name); ! 648: printf("pdir %.1o\n", nd->ni_pdir); ! 649: printf("file"); ! 650: for (i=0; i<NOFILE; i++) { ! 651: if (i % 8 == 0) ! 652: printf("\t"); ! 653: printf("%9.1x", U.u_ofile[i]); ! 654: if (i % 8 == 7) ! 655: printf("\n"); ! 656: } ! 657: if (i % 8) ! 658: printf("\n"); ! 659: printf("pofile"); ! 660: for (i=0; i<NOFILE; i++) { ! 661: if (i % 8 == 0) ! 662: printf("\t"); ! 663: printf("%9.1x", U.u_pofile[i]); ! 664: if (i % 8 == 7) ! 665: printf("\n"); ! 666: } ! 667: if (i % 8) ! 668: printf("\n"); ! 669: printf("ssave"); ! 670: for (i=0; i<sizeof(label_t)/sizeof(int); i++) { ! 671: if (i%5==0) ! 672: printf("\t"); ! 673: printf("%9.1x", U.u_ssave.val[i]); ! 674: if (i%5==4) ! 675: printf("\n"); ! 676: } ! 677: if (i%5) ! 678: printf("\n"); ! 679: printf("sigs"); ! 680: for (i=0; i<NSIG; i++) { ! 681: if (i % 8 == 0) ! 682: printf("\t"); ! 683: printf("%.1x ", U.u_signal[i]); ! 684: if (i % 8 == 7) ! 685: printf("\n"); ! 686: } ! 687: if (i % 8) ! 688: printf("\n"); ! 689: printf("code\t%.1x\n", U.u_code); ! 690: printf("ar0\t%.1x\n", U.u_ar0); ! 691: printf("prof\t%x %x %x %x\n", U.u_prof.pr_base, U.u_prof.pr_size, ! 692: U.u_prof.pr_off, U.u_prof.pr_scale); ! 693: printf("\neosys\t%d\n", U.u_eosys); ! 694: printf("ttyp\t%.1x\n", U.u_ttyp); ! 695: printf("ttyd\t%d,%d\n", major(U.u_ttyd), minor(U.u_ttyd)); ! 696: printf("comm %.14s\n", U.u_comm); ! 697: printf("start\t%ld\n", U.u_start.tv_sec); ! 698: printf("acflag\t%ld\n", U.u_acflag); ! 699: printf("cmask\t%ld\n", U.u_cmask); ! 700: printf("sizes\t%.1x %.1x %.1x\n", U.u_tsize, U.u_dsize, U.u_ssize); ! 701: printf("ru\t"); ! 702: ip = (int *)&U.u_ru; ! 703: for (i = 0; i < sizeof(U.u_ru)/sizeof(int); i++) ! 704: printf("%ld ", ip[i]); ! 705: printf("\n"); ! 706: ip = (int *)&U.u_cru; ! 707: printf("cru\t"); ! 708: for (i = 0; i < sizeof(U.u_cru)/sizeof(int); i++) ! 709: printf("%ld ", ip[i]); ! 710: printf("\n"); ! 711: #ifdef notdef ! 712: i = U.u_stack - &U; ! 713: while (U[++i] == 0); ! 714: i &= ~07; ! 715: while (i < 512) { ! 716: printf("%x ", 0140000+2*i); ! 717: for (j=0; j<8; j++) ! 718: printf("%9x", U[i++]); ! 719: printf("\n"); ! 720: } ! 721: #endif ! 722: } ! 723: ! 724: oatoi(s) ! 725: char *s; ! 726: { ! 727: register v; ! 728: ! 729: v = 0; ! 730: while (*s) ! 731: v = (v<<3) + *s++ - '0'; ! 732: return(v); ! 733: } ! 734: ! 735: dofile() ! 736: { ! 737: int nfile; ! 738: struct file *xfile, *afile; ! 739: register struct file *fp; ! 740: register nf; ! 741: int loc; ! 742: static char *dtypes[] = { "???", "inode", "socket" }; ! 743: ! 744: nf = 0; ! 745: nfile = getword(nl[SNFILE].n_value); ! 746: xfile = (struct file *)calloc(nfile, sizeof (struct file)); ! 747: afile = (struct file *)getword(nl[SFIL].n_value); ! 748: if (nfile < 0 || nfile > 10000) { ! 749: fprintf(stderr, "number of files is preposterous (%d)\n", ! 750: nfile); ! 751: return; ! 752: } ! 753: if (xfile == NULL) { ! 754: fprintf(stderr, "can't allocate memory for file table\n"); ! 755: return; ! 756: } ! 757: lseek(fc, mkphys((off_t)afile), 0); ! 758: read(fc, xfile, nfile * sizeof (struct file)); ! 759: for (fp=xfile; fp < &xfile[nfile]; fp++) ! 760: if (fp->f_count) ! 761: nf++; ! 762: if (totflg) { ! 763: printf("%3d/%3d files\n", nf, nfile); ! 764: return; ! 765: } ! 766: printf("%d/%d open files\n", nf, nfile); ! 767: printf(" LOC TYPE FLG CNT MSG DATA OFFSET\n"); ! 768: for (fp=xfile,loc=(int)afile; fp < &xfile[nfile]; fp++,loc+=sizeof(xfile[0])) { ! 769: if (fp->f_count==0) ! 770: continue; ! 771: printf("%8x ", loc); ! 772: if (fp->f_type <= DTYPE_SOCKET) ! 773: printf("%-8.8s", dtypes[fp->f_type]); ! 774: else ! 775: printf("%8d", fp->f_type); ! 776: putf(fp->f_flag&FREAD, 'R'); ! 777: putf(fp->f_flag&FWRITE, 'W'); ! 778: putf(fp->f_flag&FAPPEND, 'A'); ! 779: putf(fp->f_flag&FSHLOCK, 'S'); ! 780: putf(fp->f_flag&FEXLOCK, 'X'); ! 781: putf(fp->f_flag&FASYNC, 'I'); ! 782: printf(" %3d", mask(fp->f_count)); ! 783: printf(" %3d", mask(fp->f_msgcount)); ! 784: printf(" %8.1x", fp->f_data); ! 785: if (fp->f_offset < 0) ! 786: printf(" %x\n", fp->f_offset); ! 787: else ! 788: printf(" %ld\n", fp->f_offset); ! 789: } ! 790: free(xfile); ! 791: } ! 792: ! 793: int dmmin, dmmax, nswdev; ! 794: ! 795: doswap() ! 796: { ! 797: struct proc *proc; ! 798: int nproc; ! 799: struct text *xtext; ! 800: int ntext; ! 801: struct map *swapmap; ! 802: int nswapmap; ! 803: struct swdevt *swdevt, *sw; ! 804: register struct proc *pp; ! 805: int nswap, used, tused, free, waste; ! 806: int db, sb; ! 807: register struct mapent *me; ! 808: register struct text *xp; ! 809: int i, j; ! 810: long rmalloc(); ! 811: ! 812: nproc = getword(nl[SNPROC].n_value); ! 813: ntext = getword(nl[SNTEXT].n_value); ! 814: if (nproc < 0 || nproc > 10000 || ntext < 0 || ntext > 10000) { ! 815: fprintf(stderr, "number of procs/texts is preposterous (%d, %d)\n", ! 816: nproc, ntext); ! 817: return; ! 818: } ! 819: proc = (struct proc *)calloc(nproc, sizeof (struct proc)); ! 820: if (proc == NULL) { ! 821: fprintf(stderr, "can't allocate memory for proc table\n"); ! 822: exit(1); ! 823: } ! 824: xtext = (struct text *)calloc(ntext, sizeof (struct text)); ! 825: if (xtext == NULL) { ! 826: fprintf(stderr, "can't allocate memory for text table\n"); ! 827: exit(1); ! 828: } ! 829: nswapmap = getword(nl[SNSWAPMAP].n_value); ! 830: swapmap = (struct map *)calloc(nswapmap, sizeof (struct map)); ! 831: if (swapmap == NULL) { ! 832: fprintf(stderr, "can't allocate memory for swapmap\n"); ! 833: exit(1); ! 834: } ! 835: nswdev = getword(nl[SNSWDEV].n_value); ! 836: swdevt = (struct swdevt *)calloc(nswdev, sizeof (struct swdevt)); ! 837: if (swdevt == NULL) { ! 838: fprintf(stderr, "can't allocate memory for swdevt table\n"); ! 839: exit(1); ! 840: } ! 841: lseek(fc, mkphys((off_t)nl[SSWDEVT].n_value), L_SET); ! 842: read(fc, swdevt, nswdev * sizeof (struct swdevt)); ! 843: lseek(fc, mkphys((off_t)getword(nl[SPROC].n_value)), 0); ! 844: read(fc, proc, nproc * sizeof (struct proc)); ! 845: lseek(fc, mkphys((off_t)getword(nl[STEXT].n_value)), 0); ! 846: read(fc, xtext, ntext * sizeof (struct text)); ! 847: lseek(fc, mkphys((off_t)getword(nl[SWAPMAP].n_value)), 0); ! 848: read(fc, swapmap, nswapmap * sizeof (struct map)); ! 849: swapmap->m_name = "swap"; ! 850: swapmap->m_limit = (struct mapent *)&swapmap[nswapmap]; ! 851: dmmin = getword(nl[SDMMIN].n_value); ! 852: dmmax = getword(nl[SDMMAX].n_value); ! 853: nswap = 0; ! 854: for (sw = swdevt; sw < &swdevt[nswdev]; sw++) ! 855: if (sw->sw_freed) ! 856: nswap += sw->sw_nblks; ! 857: free = 0; ! 858: for (me = (struct mapent *)(swapmap+1); ! 859: me < (struct mapent *)&swapmap[nswapmap]; me++) ! 860: free += me->m_size; ! 861: tused = 0; ! 862: for (xp = xtext; xp < &xtext[ntext]; xp++) ! 863: if (xp->x_iptr!=NULL) { ! 864: tused += ctod(clrnd(xp->x_size)); ! 865: if (xp->x_flag & XPAGI) ! 866: tused += ctod(clrnd(ctopt(xp->x_size))); ! 867: } ! 868: used = tused; ! 869: waste = 0; ! 870: for (pp = proc; pp < &proc[nproc]; pp++) { ! 871: if (pp->p_stat == 0 || pp->p_stat == SZOMB) ! 872: continue; ! 873: if (pp->p_flag & SSYS) ! 874: continue; ! 875: db = ctod(pp->p_dsize), sb = up(db); ! 876: used += sb; ! 877: waste += sb - db; ! 878: db = ctod(pp->p_ssize), sb = up(db); ! 879: used += sb; ! 880: waste += sb - db; ! 881: if ((pp->p_flag&SLOAD) == 0) ! 882: used += ctod(vusize(pp)); ! 883: } ! 884: if (totflg) { ! 885: #define btok(x) ((x) / (1024 / DEV_BSIZE)) ! 886: printf("%3d/%3d 00k swap\n", ! 887: btok(used/100), btok((used+free)/100)); ! 888: return; ! 889: } ! 890: printf("%dk used (%dk text), %dk free, %dk wasted, %dk missing\n", ! 891: btok(used), btok(tused), btok(free), btok(waste), ! 892: /* a dmmax/2 block goes to argmap */ ! 893: btok(nswap - dmmax/2 - (used + free))); ! 894: printf("avail: "); ! 895: for (i = dmmax; i >= dmmin; i /= 2) { ! 896: j = 0; ! 897: while (rmalloc(swapmap, i) != 0) ! 898: j++; ! 899: if (j) printf("%d*%dk ", j, btok(i)); ! 900: } ! 901: free = 0; ! 902: for (me = (struct mapent *)(swapmap+1); ! 903: me < (struct mapent *)&swapmap[nswapmap]; me++) ! 904: free += me->m_size; ! 905: printf("%d*1k\n", btok(free)); ! 906: } ! 907: ! 908: up(size) ! 909: register int size; ! 910: { ! 911: register int i, block; ! 912: ! 913: i = 0; ! 914: block = dmmin; ! 915: while (i < size) { ! 916: i += block; ! 917: if (block < dmmax) ! 918: block *= 2; ! 919: } ! 920: return (i); ! 921: } ! 922: ! 923: /* ! 924: * Compute number of pages to be allocated to the u. area ! 925: * and data and stack area page tables, which are stored on the ! 926: * disk immediately after the u. area. ! 927: */ ! 928: vusize(p) ! 929: register struct proc *p; ! 930: { ! 931: register int tsz = p->p_tsize / NPTEPG; ! 932: ! 933: /* ! 934: * We do not need page table space on the disk for page ! 935: * table pages wholly containing text. ! 936: */ ! 937: return (clrnd(UPAGES + ! 938: clrnd(ctopt(p->p_tsize+p->p_dsize+p->p_ssize+UPAGES)) - tsz)); ! 939: } ! 940: ! 941: /* ! 942: * Allocate 'size' units from the given ! 943: * map. Return the base of the allocated space. ! 944: * In a map, the addresses are increasing and the ! 945: * list is terminated by a 0 size. ! 946: * ! 947: * Algorithm is first-fit. ! 948: * ! 949: * This routine knows about the interleaving of the swapmap ! 950: * and handles that. ! 951: */ ! 952: long ! 953: rmalloc(mp, size) ! 954: register struct map *mp; ! 955: long size; ! 956: { ! 957: register struct mapent *ep = (struct mapent *)(mp+1); ! 958: register int addr; ! 959: register struct mapent *bp; ! 960: swblk_t first, rest; ! 961: ! 962: if (size <= 0 || size > dmmax) ! 963: return (0); ! 964: /* ! 965: * Search for a piece of the resource map which has enough ! 966: * free space to accomodate the request. ! 967: */ ! 968: for (bp = ep; bp->m_size; bp++) { ! 969: if (bp->m_size >= size) { ! 970: /* ! 971: * If allocating from swapmap, ! 972: * then have to respect interleaving ! 973: * boundaries. ! 974: */ ! 975: if (nswdev > 1 && ! 976: (first = dmmax - bp->m_addr%dmmax) < bp->m_size) { ! 977: if (bp->m_size - first < size) ! 978: continue; ! 979: addr = bp->m_addr + first; ! 980: rest = bp->m_size - first - size; ! 981: bp->m_size = first; ! 982: if (rest) ! 983: rmfree(mp, rest, addr+size); ! 984: return (addr); ! 985: } ! 986: /* ! 987: * Allocate from the map. ! 988: * If there is no space left of the piece ! 989: * we allocated from, move the rest of ! 990: * the pieces to the left. ! 991: */ ! 992: addr = bp->m_addr; ! 993: bp->m_addr += size; ! 994: if ((bp->m_size -= size) == 0) { ! 995: do { ! 996: bp++; ! 997: (bp-1)->m_addr = bp->m_addr; ! 998: } while ((bp-1)->m_size = bp->m_size); ! 999: } ! 1000: if (addr % CLSIZE) ! 1001: return (0); ! 1002: return (addr); ! 1003: } ! 1004: } ! 1005: return (0); ! 1006: } ! 1007: ! 1008: /* ! 1009: * Free the previously allocated space at addr ! 1010: * of size units into the specified map. ! 1011: * Sort addr into map and combine on ! 1012: * one or both ends if possible. ! 1013: */ ! 1014: rmfree(mp, size, addr) ! 1015: struct map *mp; ! 1016: long size, addr; ! 1017: { ! 1018: struct mapent *firstbp; ! 1019: register struct mapent *bp; ! 1020: register int t; ! 1021: ! 1022: /* ! 1023: * Both address and size must be ! 1024: * positive, or the protocol has broken down. ! 1025: */ ! 1026: if (addr <= 0 || size <= 0) ! 1027: goto badrmfree; ! 1028: /* ! 1029: * Locate the piece of the map which starts after the ! 1030: * returned space (or the end of the map). ! 1031: */ ! 1032: firstbp = bp = (struct mapent *)(mp + 1); ! 1033: for (; bp->m_addr <= addr && bp->m_size != 0; bp++) ! 1034: continue; ! 1035: /* ! 1036: * If the piece on the left abuts us, ! 1037: * then we should combine with it. ! 1038: */ ! 1039: if (bp > firstbp && (bp-1)->m_addr+(bp-1)->m_size >= addr) { ! 1040: /* ! 1041: * Check no overlap (internal error). ! 1042: */ ! 1043: if ((bp-1)->m_addr+(bp-1)->m_size > addr) ! 1044: goto badrmfree; ! 1045: /* ! 1046: * Add into piece on the left by increasing its size. ! 1047: */ ! 1048: (bp-1)->m_size += size; ! 1049: /* ! 1050: * If the combined piece abuts the piece on ! 1051: * the right now, compress it in also, ! 1052: * by shifting the remaining pieces of the map over. ! 1053: */ ! 1054: if (bp->m_addr && addr+size >= bp->m_addr) { ! 1055: if (addr+size > bp->m_addr) ! 1056: goto badrmfree; ! 1057: (bp-1)->m_size += bp->m_size; ! 1058: while (bp->m_size) { ! 1059: bp++; ! 1060: (bp-1)->m_addr = bp->m_addr; ! 1061: (bp-1)->m_size = bp->m_size; ! 1062: } ! 1063: } ! 1064: goto done; ! 1065: } ! 1066: /* ! 1067: * Don't abut on the left, check for abutting on ! 1068: * the right. ! 1069: */ ! 1070: if (addr+size >= bp->m_addr && bp->m_size) { ! 1071: if (addr+size > bp->m_addr) ! 1072: goto badrmfree; ! 1073: bp->m_addr -= size; ! 1074: bp->m_size += size; ! 1075: goto done; ! 1076: } ! 1077: /* ! 1078: * Don't abut at all. Make a new entry ! 1079: * and check for map overflow. ! 1080: */ ! 1081: do { ! 1082: t = bp->m_addr; ! 1083: bp->m_addr = addr; ! 1084: addr = t; ! 1085: t = bp->m_size; ! 1086: bp->m_size = size; ! 1087: bp++; ! 1088: } while (size = t); ! 1089: /* ! 1090: * Segment at bp is to be the delimiter; ! 1091: * If there is not room for it ! 1092: * then the table is too full ! 1093: * and we must discard something. ! 1094: */ ! 1095: if (bp+1 > mp->m_limit) { ! 1096: /* ! 1097: * Back bp up to last available segment. ! 1098: * which contains a segment already and must ! 1099: * be made into the delimiter. ! 1100: * Discard second to last entry, ! 1101: * since it is presumably smaller than the last ! 1102: * and move the last entry back one. ! 1103: */ ! 1104: bp--; ! 1105: printf("%s: rmap ovflo, lost [%d,%d)\n", mp->m_name, ! 1106: (bp-1)->m_addr, (bp-1)->m_addr+(bp-1)->m_size); ! 1107: bp[-1] = bp[0]; ! 1108: bp[0].m_size = bp[0].m_addr = 0; ! 1109: } ! 1110: done: ! 1111: return; ! 1112: badrmfree: ! 1113: printf("bad rmfree\n"); ! 1114: } ! 1115: /* ! 1116: * "addr" is a kern virt addr and does not correspond ! 1117: * To a phys addr after zipping out the high bit.. ! 1118: * since it was valloc'd in the kernel. ! 1119: * ! 1120: * We return the phys addr by simulating kernel vm (/dev/kmem) ! 1121: * when we are reading a crash dump. ! 1122: */ ! 1123: off_t ! 1124: mkphys(addr) ! 1125: off_t addr; ! 1126: { ! 1127: register off_t o; ! 1128: ! 1129: if (!kflg) ! 1130: return(addr); ! 1131: addr = clear(addr); ! 1132: o = addr & PGOFSET; ! 1133: addr >>= PGSHIFT; ! 1134: addr &= PG_PFNUM; ! 1135: addr *= NBPW; ! 1136: addr = getword(nl[SYSMAP].n_value + addr); ! 1137: addr = ((addr & PG_PFNUM) << PGSHIFT) | o; ! 1138: return(addr); ! 1139: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.