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