![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to analyze.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / old / analyze|
Return to analyze.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / old / analyze |
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[] = "@(#)analyze.c 5.2 (Berkeley) 5/14/86"; ! 15: #endif not lint ! 16: ! 17: /* ! 18: * Analyze - analyze a core (and optional paging area) saved from ! 19: * a virtual Unix system crash. ! 20: */ ! 21: #include <stdio.h> ! 22: #include <sys/param.h> ! 23: #include <sys/dir.h> ! 24: #include <machine/pte.h> ! 25: #include <nlist.h> ! 26: #include <sys/map.h> ! 27: #include <sys/user.h> ! 28: #include <sys/proc.h> ! 29: #include <sys/text.h> ! 30: #include <sys/cmap.h> ! 31: #include <sys/vm.h> ! 32: ! 33: int Dflg; ! 34: int dflg; ! 35: int vflg; ! 36: int mflg; ! 37: int fflg; ! 38: int sflg; ! 39: int uflg; ! 40: ! 41: /* use vprintf with care; it plays havoc with ``else's'' */ ! 42: #define vprintf if (vflg) printf ! 43: ! 44: #ifdef vax ! 45: #define clear(x) ((int)x & 0x7fffffff) ! 46: #else ! 47: #define clear(x) ((int)x) ! 48: #endif ! 49: ! 50: struct proc *proc, *aproc; ! 51: int nproc; ! 52: struct text *text, *atext; ! 53: int ntext; ! 54: struct mapent *swapmap; ! 55: int nswapmap; ! 56: int dmmin, dmmax, dmtext; ! 57: struct cmap *cmap; ! 58: int ecmx; ! 59: struct pte *usrpt; ! 60: struct pte *Usrptma; ! 61: int firstfree; ! 62: int maxfree; ! 63: int freemem; ! 64: struct pte p0br[ctopt(btoc(MAXTSIZ+MAXDSIZ+MAXSSIZ))][NPTEPG]; ! 65: int pid; ! 66: ! 67: struct paginfo { ! 68: char z_type; ! 69: char z_count; ! 70: short z_pid; ! 71: struct pte z_pte; ! 72: } *paginfo; ! 73: #define ZLOST 0 ! 74: #define ZDATA 1 ! 75: #define ZSTACK 2 ! 76: #define ZUDOT 3 ! 77: #define ZPAGET 4 ! 78: #define ZTEXT 5 ! 79: #define ZFREE 6 ! 80: #define ZINTRAN 7 ! 81: ! 82: struct dblks { ! 83: short d_first; ! 84: short d_size; ! 85: char d_type; ! 86: char d_index; ! 87: } *dblks; ! 88: int ndblks; ! 89: ! 90: #define DFREE 0 ! 91: #define DDATA 1 ! 92: #define DSTACK 2 ! 93: #define DTEXT 3 ! 94: #define DUDOT 4 ! 95: #define DPAGET 5 ! 96: ! 97: union { ! 98: char buf[UPAGES][NBPG]; ! 99: struct user U; ! 100: } u_area; ! 101: #define u u_area.U ! 102: ! 103: int fcore = -1; ! 104: int fswap = -1; ! 105: ! 106: struct nlist nl[] = { ! 107: #define X_PROC 0 ! 108: { "_proc" }, ! 109: #define X_USRPT 1 ! 110: { "_usrpt" }, ! 111: #define X_PTMA 2 ! 112: { "_Usrptmap" }, ! 113: #define X_FIRSTFREE 3 ! 114: { "_firstfree" }, ! 115: #define X_MAXFREE 4 ! 116: { "_maxfree" }, ! 117: #define X_TEXT 5 ! 118: { "_text" }, ! 119: #define X_FREEMEM 6 ! 120: { "_freemem" }, ! 121: #define X_CMAP 7 ! 122: { "_cmap" }, ! 123: #define X_ECMAP 8 ! 124: { "_ecmap" }, ! 125: #define X_SWAPMAP 9 ! 126: { "_swapmap" }, ! 127: #define X_NPROC 10 ! 128: { "_nproc" }, ! 129: #define X_NTEXT 11 ! 130: { "_ntext" }, ! 131: #define X_NSWAPMAP 12 ! 132: { "_nswapmap" }, ! 133: #define X_DMMIN 13 ! 134: { "_dmmin" }, ! 135: #define X_DMMAX 14 ! 136: { "_dmmax" }, ! 137: #define X_DMTEXT 15 ! 138: { "_dmtext" }, ! 139: { "" } ! 140: }; ! 141: ! 142: main(argc, argv) ! 143: int argc; ! 144: char **argv; ! 145: { ! 146: register struct nlist *np; ! 147: register struct proc *p; ! 148: register struct text *xp; ! 149: register struct pte *pte; ! 150: register int i; ! 151: int w, a; ! 152: ! 153: #ifdef DEBUG ! 154: setbuf(stdout, NULL); ! 155: #endif ! 156: argc--, argv++; ! 157: while (argc > 0 && argv[0][0] == '-') { ! 158: register char *cp = *argv++; ! 159: argc--; ! 160: while (*++cp) switch (*cp) { ! 161: ! 162: case 'm': ! 163: mflg++; ! 164: break; ! 165: ! 166: case 'v': ! 167: vflg++; ! 168: break; ! 169: ! 170: case 's': ! 171: if (argc < 2) ! 172: goto usage; ! 173: if ((fswap = open(argv[0], 0)) < 0) { ! 174: perror(argv[0]); ! 175: exit(1); ! 176: } ! 177: argc--,argv++; ! 178: sflg++; ! 179: break; ! 180: ! 181: case 'f': ! 182: fflg++; ! 183: break; ! 184: ! 185: case 'D': ! 186: Dflg++; ! 187: break; ! 188: ! 189: case 'd': ! 190: dflg++; ! 191: break; ! 192: ! 193: case 'u': ! 194: uflg++; ! 195: break; ! 196: ! 197: default: ! 198: goto usage; ! 199: } ! 200: } ! 201: if (argc < 1) { ! 202: usage: ! 203: fprintf(stderr, "usage: analyze [ -vmfd ] [ -s swapfile ] corefile [ system ]\n"); ! 204: exit(1); ! 205: } ! 206: close(0); ! 207: if ((fcore = open(argv[0], 0)) < 0) { ! 208: perror(argv[0]); ! 209: exit(1); ! 210: } ! 211: nlist(argc > 1 ? argv[1] : "/vmunix", nl); ! 212: if (nl[0].n_value == 0) { ! 213: fprintf(stderr, "%s: bad namelist\n", ! 214: argc > 1 ? argv[1] : "/vmunix"); ! 215: exit(1); ! 216: } ! 217: for (np = nl; np->n_name && *np->n_name; np++) ! 218: vprintf("%8.8s %x\n", np->n_name ,np->n_value ); ! 219: usrpt = (struct pte *)clear(nl[X_USRPT].n_value); ! 220: Usrptma = (struct pte *)clear(nl[X_PTMA].n_value); ! 221: firstfree = get(nl[X_FIRSTFREE].n_value); ! 222: maxfree = get(nl[X_MAXFREE].n_value); ! 223: freemem = get(nl[X_FREEMEM].n_value); ! 224: dmmin = get(nl[X_DMMIN]); ! 225: dmmax = get(nl[X_DMMAX]); ! 226: dmtext = get(nl[X_DMTEXT]); ! 227: paginfo = (struct paginfo *)calloc(maxfree, sizeof (struct paginfo)); ! 228: if (paginfo == NULL) { ! 229: fprintf(stderr, "maxfree %x?... out of mem!\n", maxfree); ! 230: exit(1); ! 231: } ! 232: vprintf("usrpt %x\nUsrptma %x\nfirstfree %x\nmaxfree %x\nfreemem %x\n", ! 233: usrpt, Usrptma, firstfree, maxfree, freemem); ! 234: { ! 235: lseek(fcore, (long)clear(nl[X_PROC].n_value), 0); ! 236: read(fcore, (char *)&aproc, sizeof aproc); ! 237: lseek(fcore, (long)clear(nl[X_NPROC].n_value), 0); ! 238: read(fcore, (char *)&nproc, sizeof nproc); ! 239: printf("%d procs\n", nproc); ! 240: proc = (struct proc *)calloc(nproc, sizeof (struct proc)); ! 241: lseek(fcore, (long)clear(aproc), 0); ! 242: if (read(fcore, (char *)proc, nproc * sizeof (struct proc)) ! 243: != nproc * sizeof (struct proc)) { ! 244: perror("proc read"); ! 245: exit(1); ! 246: } ! 247: } ! 248: { ! 249: lseek(fcore, (long)clear(nl[X_TEXT].n_value), 0); ! 250: read(fcore, (char *)&atext, sizeof atext); ! 251: lseek(fcore, (long)clear(nl[X_NTEXT].n_value), 0); ! 252: read(fcore, (char *)&ntext, sizeof ntext); ! 253: printf("%d texts\n", ntext); ! 254: text = (struct text *)calloc(ntext, sizeof (struct text)); ! 255: lseek(fcore, (long)clear(atext), 0); ! 256: if (read(fcore, (char *)text, ntext * sizeof (struct text)) ! 257: != ntext * sizeof (struct text)) { ! 258: perror("text read"); ! 259: exit(1); ! 260: } ! 261: } ! 262: i = (get(nl[X_ECMAP].n_value) - get(nl[X_CMAP].n_value)); ! 263: ecmx = i / sizeof (struct cmap); ! 264: cmap = (struct cmap *)calloc(i, 1); ! 265: if (cmap == NULL) { ! 266: fprintf(stderr, "not enough mem for %x bytes of cmap\n", i); ! 267: exit(1); ! 268: } ! 269: lseek(fcore, (long)clear(get(nl[X_CMAP].n_value)), 0); ! 270: if (read(fcore, (char *)cmap, i) != i) { ! 271: perror("cmap read"); ! 272: exit(1); ! 273: } ! 274: { struct mapent *aswapmap; ! 275: lseek(fcore, (long)clear(nl[X_SWAPMAP].n_value), 0); ! 276: read(fcore, (char *)&aswapmap, sizeof aswapmap); ! 277: lseek(fcore, (long)clear(nl[X_NSWAPMAP].n_value), 0); ! 278: read(fcore, (char *)&nswapmap, sizeof nswapmap); ! 279: nswapmap--; ! 280: printf("%d swapmap entries\n", nswapmap); ! 281: swapmap = (struct mapent *)calloc(nswapmap, sizeof (struct mapent)); ! 282: dblks = (struct dblks *)calloc(2 * nswapmap, sizeof (struct dblks)); ! 283: lseek(fcore, (long)clear(aswapmap+1), 0); ! 284: if (read(fcore, (char *)swapmap, nswapmap * sizeof (struct mapent)) ! 285: != nswapmap * sizeof (struct mapent)) { ! 286: perror("swapmap read"); ! 287: exit(1); ! 288: } ! 289: } ! 290: for (p = &proc[1]; p < proc+nproc; p++) { ! 291: p->p_p0br = (struct pte *)clear(p->p_p0br); ! 292: p->p_addr = (struct pte *)clear(p->p_addr); ! 293: if (p->p_stat == 0) ! 294: continue; ! 295: printf("proc %d ", p->p_pid); ! 296: if (p->p_stat == SZOMB) { ! 297: printf("zombie\n"); ! 298: continue; ! 299: } ! 300: if (p->p_flag & SLOAD) { ! 301: printf("loaded, p0br %x, ", p->p_p0br); ! 302: printf("%d pages of page tables:", p->p_szpt); ! 303: a = btokmx(p->p_p0br); ! 304: for (i = 0; i < p->p_szpt; i++) { ! 305: w = get(&Usrptma[a + i]); ! 306: printf(" %x", w & PG_PFNUM); ! 307: } ! 308: printf("\n"); ! 309: for(i = 0; i < p->p_szpt; i++) { ! 310: w = get(&Usrptma[a + i]); ! 311: if (getpt(w, i)) ! 312: count(p, (struct pte *)&w, ZPAGET); ! 313: } ! 314: } else { ! 315: /* i = ctopt(btoc(u.u_exdata.ux_dsize)); */ ! 316: i = clrnd(ctopt(p->p_tsize + p->p_dsize + p->p_ssize)); ! 317: printf("swapped, swaddr %x\n", p->p_swaddr); ! 318: duse(p->p_swaddr, ctod(clrnd(UPAGES)), DUDOT, p - proc); ! 319: duse(p->p_swaddr + ctod(UPAGES), ! 320: ctod(clrnd(i - p->p_tsize / NPTEPG)), ! 321: DPAGET, p - proc); ! 322: /* i, DPAGET, p - proc); */ ! 323: } ! 324: p->p_p0br = (struct pte *)p0br; ! 325: p->p_addr = uaddr(p); ! 326: if (p->p_textp) ! 327: p->p_textp = &text[p->p_textp - atext]; ! 328: if (p->p_pid == 2) ! 329: continue; ! 330: if (getu(p)) ! 331: continue; ! 332: u.u_procp = p; ! 333: pdmap(); ! 334: if ((p->p_flag & SLOAD) == 0) ! 335: continue; ! 336: pid = p->p_pid; ! 337: for (i = 0; i < p->p_tsize; i++) { ! 338: pte = tptopte(p, i); ! 339: if (pte->pg_fod || pte->pg_pfnum == 0) ! 340: continue; ! 341: if (pte->pg_pfnum >= firstfree && pte->pg_pfnum < maxfree && cmap[pgtocm(pte->pg_pfnum)].c_intrans) ! 342: count(p, pte, ZINTRAN); ! 343: else ! 344: count(p, pte, ZTEXT); ! 345: } ! 346: vprintf("\n"); ! 347: for (i = 0; i < p->p_dsize; i++) { ! 348: pte = dptopte(p, i); ! 349: if (pte->pg_fod || pte->pg_pfnum == 0) ! 350: continue; ! 351: if (pte->pg_pfnum >= firstfree && pte->pg_pfnum < maxfree && cmap[pgtocm(pte->pg_pfnum)].c_intrans) ! 352: count(p, pte, ZINTRAN); ! 353: else ! 354: count(p, pte, ZDATA); ! 355: } ! 356: vprintf("\n"); ! 357: for (i = 0; i < p->p_ssize; i++) { ! 358: pte = sptopte(p, i); ! 359: if (pte->pg_fod || pte->pg_pfnum == 0) ! 360: continue; ! 361: if (pte->pg_pfnum >= firstfree && pte->pg_pfnum < maxfree && cmap[pgtocm(pte->pg_pfnum)].c_intrans) ! 362: count(p, pte, ZINTRAN); ! 363: else ! 364: count(p, pte, ZSTACK); ! 365: } ! 366: vprintf("\n"); ! 367: for (i = 0; i < UPAGES; i++) ! 368: count(p, &p->p_addr[i], ZUDOT); ! 369: vprintf("\n"); ! 370: vprintf("\n"); ! 371: } ! 372: for (xp = &text[0]; xp < text+ntext; xp++) ! 373: if (xp->x_iptr) { ! 374: int size = ctod(xp->x_size); ! 375: ! 376: for (i = 0; i < size; i += dmtext) ! 377: duse(xp->x_daddr[i], ! 378: (size - i) > dmtext ! 379: ? dmtext : size - i, ! 380: DTEXT, xp - text); ! 381: if (xp->x_flag & XPAGI) ! 382: duse(xp->x_ptdaddr, ! 383: ctod(clrnd(ctopt(xp->x_size))), ! 384: DTEXT, xp - text); ! 385: } ! 386: dmcheck(); ! 387: fixfree(); ! 388: summary(); ! 389: exit(0); ! 390: } ! 391: ! 392: pdmap() ! 393: { ! 394: register struct text *xp; ! 395: ! 396: if (fswap == -1 && (u.u_procp->p_flag & SLOAD) == 0) ! 397: return; ! 398: if (Dflg) ! 399: printf("disk for pid %d", u.u_procp->p_pid); ! 400: if ((xp = u.u_procp->p_textp) && Dflg) ! 401: ptdmap(xp->x_daddr, xp->x_size); ! 402: pdmseg("data", &u.u_dmap, DDATA); ! 403: pdmseg("stack", &u.u_smap, DSTACK); ! 404: if (Dflg) ! 405: printf("\n"); ! 406: } ! 407: ! 408: ptdmap(dp, size) ! 409: register daddr_t *dp; ! 410: int size; ! 411: { ! 412: register int i; ! 413: int rem; ! 414: ! 415: if (Dflg) ! 416: printf(" text:"); ! 417: for (i = 0, rem = size; rem > 0; i++) { ! 418: if (Dflg) ! 419: printf(" %x<%x>", dp[i], rem < dmtext ? rem : dmtext); ! 420: rem -= rem < dmtext ? rem : dmtext; ! 421: } ! 422: } ! 423: ! 424: pdmseg(cp, dmp, type) ! 425: char *cp; ! 426: struct dmap *dmp; ! 427: { ! 428: register int i; ! 429: int b, rem; ! 430: ! 431: if (Dflg) ! 432: printf(", %s:", cp); ! 433: b = dmmin; ! 434: for (i = 0, rem = dmp->dm_size; rem > 0; i++) { ! 435: if (Dflg) ! 436: printf(" %x<%x>", dmp->dm_map[i], rem < b ? rem : b); ! 437: duse(dmp->dm_map[i], b, type, u.u_procp - proc); ! 438: rem -= b; ! 439: if (b < dmmax) ! 440: b *= 2; ! 441: } ! 442: } ! 443: ! 444: duse(first, size, type, index) ! 445: { ! 446: register struct dblks *dp; ! 447: ! 448: if (fswap == -1) ! 449: return; ! 450: dp = &dblks[ndblks]; ! 451: if (++ndblks > 2*nswapmap) { ! 452: fprintf(stderr, "too many disk blocks\n"); ! 453: exit(1); ! 454: } ! 455: dp->d_first = first; ! 456: dp->d_size = size; ! 457: dp->d_type = type; ! 458: dp->d_index = index; ! 459: } ! 460: ! 461: dsort(d, e) ! 462: register struct dblks *d, *e; ! 463: { ! 464: ! 465: return (e->d_first - d->d_first); ! 466: } ! 467: ! 468: dmcheck() ! 469: { ! 470: register struct mapent *smp; ! 471: register struct dblks *d, *e; ! 472: ! 473: for (smp = swapmap; smp->m_size; smp++) ! 474: duse(smp->m_addr, smp->m_size, DFREE, 0); ! 475: duse(ctod(CLSIZE), dmtext - ctod(CLSIZE), DFREE, 0); ! 476: qsort(dblks, ndblks, sizeof (struct dblks), dsort); ! 477: d = &dblks[ndblks - 1]; ! 478: if (d->d_first > 1) ! 479: printf("lost swap map: start %x size %x\n", 1, d->d_first); ! 480: for (; d > dblks; d--) { ! 481: if (dflg) ! 482: dprint(d); ! 483: e = d - 1; ! 484: if (d->d_first + d->d_size > e->d_first) { ! 485: printf("overlap in swap mappings:\n"); ! 486: dprint(d); ! 487: dprint(e); ! 488: } else if (d->d_first + d->d_size < e->d_first) { ! 489: printf("lost swap map: start %x size %x\n", ! 490: d->d_first + d->d_size, ! 491: e->d_first - (d->d_first + d->d_size)); ! 492: } ! 493: } ! 494: if (dflg) ! 495: dprint(dblks); ! 496: if (sflg) ! 497: printf("swap space ends at %x\n", d->d_first + d->d_size); ! 498: } ! 499: ! 500: char *dnames[] = { ! 501: "DFREE", ! 502: "DDATA", ! 503: "DSTACK", ! 504: "DTEXT", ! 505: "DUDOT", ! 506: "DPAGET", ! 507: }; ! 508: ! 509: dprint(d) ! 510: register struct dblks *d; ! 511: { ! 512: ! 513: printf("at %4x size %4x type %s", d->d_first, d->d_size, ! 514: dnames[d->d_type]); ! 515: switch (d->d_type) { ! 516: ! 517: case DSTACK: ! 518: case DDATA: ! 519: printf(" pid %d", proc[d->d_index].p_pid); ! 520: break; ! 521: } ! 522: printf("\n"); ! 523: } ! 524: ! 525: getpt(x, i) ! 526: int x, i; ! 527: { ! 528: ! 529: lseek(fcore, (long)ctob((x & PG_PFNUM)), 0); ! 530: if (read(fcore, (char *)(p0br[i]), NBPG) != NBPG) { ! 531: perror("read"); ! 532: fprintf(stderr, "getpt error reading frame %x\n", clear(x)); ! 533: return (0); ! 534: } ! 535: return (1); ! 536: } ! 537: ! 538: checkpg(p, pte, type) ! 539: register struct pte *pte; ! 540: register struct proc *p; ! 541: int type; ! 542: { ! 543: char corepg[NBPG], swapg[NBPG]; ! 544: register int i, count, dblock; ! 545: register int pfnum = pte->pg_pfnum; ! 546: ! 547: if (type == ZPAGET || type == ZUDOT) ! 548: return (0); ! 549: lseek(fcore, (long)(NBPG * pfnum), 0); ! 550: if (read(fcore, corepg, NBPG) != NBPG){ ! 551: perror("read"); ! 552: fprintf(stderr, "Error reading core page %x\n", pfnum); ! 553: return (0); ! 554: } ! 555: switch (type) { ! 556: ! 557: case ZDATA: ! 558: if (ptetodp(p, pte) >= u.u_dmap.dm_size) ! 559: return (0); ! 560: break; ! 561: ! 562: case ZTEXT: ! 563: break; ! 564: ! 565: case ZSTACK: ! 566: if (ptetosp(p, pte) >= u.u_smap.dm_size) ! 567: return (0); ! 568: break; ! 569: ! 570: default: ! 571: return(0); ! 572: break; ! 573: } ! 574: dblock = vtod(p, ptetov(p, pte), &u.u_dmap, &u.u_smap); ! 575: vprintf(" %x", dblock); ! 576: if (pte->pg_fod || pte->pg_pfnum == 0) ! 577: return (0); ! 578: if (cmap[pgtocm(pte->pg_pfnum)].c_intrans || pte->pg_m || pte->pg_swapm) ! 579: return (0); ! 580: lseek(fswap, (long)(DEV_BSIZE * dblock), 0); ! 581: if (read(fswap, swapg, NBPG) != NBPG) { ! 582: fprintf(stderr,"swap page %x: ", dblock); ! 583: perror("read"); ! 584: } ! 585: count = 0; ! 586: for (i = 0; i < NBPG; i++) ! 587: if (corepg[i] != swapg[i]) ! 588: count++; ! 589: if (count == 0) ! 590: vprintf("\tsame"); ! 591: return (count); ! 592: } ! 593: ! 594: getu(p) ! 595: register struct proc *p; ! 596: { ! 597: int i, w, cc, errs = 0; ! 598: ! 599: if (uflg && (p->p_flag & SLOAD)) ! 600: printf("pid %d u. pages:", p->p_pid); ! 601: for (i = 0; i < UPAGES; i++) { ! 602: if (p->p_flag & SLOAD) { ! 603: if (uflg) ! 604: printf(" %x", p->p_addr[i].pg_pfnum); ! 605: lseek(fcore, ctob(p->p_addr[i].pg_pfnum), 0); ! 606: if (read(fcore, u_area.buf[i], NBPG) != NBPG) ! 607: perror("core u. read"), errs++; ! 608: } else if (fswap >= 0) { ! 609: lseek(fswap, (long)(NBPG * (p->p_swaddr+i)), 0); ! 610: if (read(fswap, u_area.buf[i], NBPG) != NBPG) ! 611: perror("swap u. read"), errs++; ! 612: } ! 613: } ! 614: if (uflg && (p->p_flag & SLOAD)) ! 615: printf("\n"); ! 616: return (errs); ! 617: } ! 618: ! 619: char *typepg[] = { ! 620: "lost", ! 621: "data", ! 622: "stack", ! 623: "udot", ! 624: "paget", ! 625: "text", ! 626: "free", ! 627: "intransit", ! 628: }; ! 629: ! 630: count(p, pte, type) ! 631: struct proc *p; ! 632: register struct pte *pte; ! 633: int type; ! 634: { ! 635: register int pfnum = pte->pg_pfnum; ! 636: register struct paginfo *zp = &paginfo[pfnum]; ! 637: int ndif; ! 638: #define zprintf if (type==ZINTRAN || vflg) printf ! 639: ! 640: if (type == ZINTRAN && pfnum == 0) ! 641: return; ! 642: zprintf("page %x %s", pfnum, typepg[type]); ! 643: if (sflg == 0 || (ndif = checkpg(p, pte, type)) == 0) { ! 644: zprintf("\n"); ! 645: } else { ! 646: if (vflg == 0 && type != ZINTRAN) ! 647: printf("page %x %s,", pfnum, typepg[type]); ! 648: printf(" %d bytes differ\n",ndif); ! 649: } ! 650: if (pfnum < firstfree || pfnum > maxfree) { ! 651: printf("page number out of range:\n"); ! 652: printf("\tpage %x type %s pid %d\n", pfnum, typepg[type], pid); ! 653: return; ! 654: } ! 655: if (bad(zp, type)) { ! 656: printf("dup page pte %x", *(int *)pte); ! 657: dumpcm("", pte->pg_pfnum); ! 658: dump(zp); ! 659: printf("pte %x and as %s in pid %d\n", zp->z_pte, typepg[type], pid); ! 660: return; ! 661: } ! 662: zp->z_type = type; ! 663: zp->z_count++; ! 664: zp->z_pid = pid; ! 665: zp->z_pte = *pte; ! 666: } ! 667: ! 668: bad(zp, type) ! 669: struct paginfo *zp; ! 670: { ! 671: if (type == ZTEXT) { ! 672: if (zp->z_type != 0 && zp->z_type != ZTEXT) ! 673: return (1); ! 674: return (0); ! 675: } ! 676: return (zp->z_count); ! 677: } ! 678: ! 679: dump(zp) ! 680: struct paginfo *zp; ! 681: { ! 682: ! 683: printf("page %x type %s pid %d ", zp - paginfo, typepg[zp->z_type], zp->z_pid); ! 684: } ! 685: ! 686: summary() ! 687: { ! 688: register int i; ! 689: register struct paginfo *zp; ! 690: register int pfnum; ! 691: ! 692: for (i = firstfree + UPAGES; i < maxfree; i+= CLSIZE) { ! 693: zp = &paginfo[i]; ! 694: if (zp->z_type == ZLOST) ! 695: dumpcm("lost", i); ! 696: pfnum = pgtocm(i); ! 697: if (cmap[pfnum].c_lock && cmap[pfnum].c_type != CSYS) ! 698: dumpcm("locked", i); ! 699: if (mflg) ! 700: dumpcm("mem", i); ! 701: } ! 702: } ! 703: ! 704: char *tynames[] = { ! 705: "sys", ! 706: "text", ! 707: "data", ! 708: "stack" ! 709: }; ! 710: dumpcm(cp, pg) ! 711: char *cp; ! 712: int pg; ! 713: { ! 714: int pslot; ! 715: int cm; ! 716: register struct cmap *c; ! 717: ! 718: cm = pgtocm(pg); ! 719: printf("cm %x %s page %x ", cm, cp, pg); ! 720: c = &cmap[cm]; ! 721: printf("\t[%x, %x", c->c_page, c->c_ndx); ! 722: if (c->c_type == CSYS) ! 723: goto skip; ! 724: if (c->c_type != CTEXT) { ! 725: if (c->c_ndx >= nproc) { ! 726: printf(" [text c->c_ndx %d?]", c->c_ndx); ! 727: goto skip; ! 728: } ! 729: printf(" (=pid %d)", proc[c->c_ndx].p_pid); ! 730: } else { ! 731: if (c->c_ndx >= ntext) { ! 732: printf(" [text c->c_ndx %d?]", c->c_ndx); ! 733: goto skip; ! 734: } ! 735: pslot= (text[c->c_ndx].x_caddr - aproc); ! 736: printf(" (=pid"); ! 737: for(;;) { ! 738: printf(" %d", proc[pslot].p_pid); ! 739: if (proc[pslot].p_xlink == 0) ! 740: break; ! 741: pslot= (proc[pslot].p_xlink - aproc); ! 742: } ! 743: printf(")"); ! 744: } ! 745: skip: ! 746: printf("] "); ! 747: printf(tynames[c->c_type]); ! 748: if (c->c_free) ! 749: printf(" free"); ! 750: if (c->c_gone) ! 751: printf(" gone"); ! 752: if (c->c_lock) ! 753: printf(" lock"); ! 754: if (c->c_want) ! 755: printf(" want"); ! 756: if (c->c_intrans) ! 757: printf(" intrans"); ! 758: if (c->c_blkno) ! 759: printf(" blkno %x mdev %d", c->c_blkno, c->c_mdev); ! 760: if (c->c_hlink) { ! 761: printf(" hlink %x page %x", c->c_hlink, cmtopg(c->c_hlink)); ! 762: if (c->c_hlink > ecmx) ! 763: printf(" <<<"); ! 764: } ! 765: printf("\n"); ! 766: } ! 767: ! 768: fixfree() ! 769: { ! 770: register int i, next, prev; ! 771: ! 772: next = CMHEAD; ! 773: for (i=freemem/CLSIZE; --i >=0; ) { ! 774: prev = next; ! 775: next = cmap[next].c_next; ! 776: if (cmap[next].c_free == 0) { ! 777: printf("link to non free block: in %x to %x\n", cmtopg(prev), cmtopg(next)); ! 778: dumpcm("bad free link in", cmtopg(prev)); ! 779: dumpcm("to non free block", cmtopg(next)); ! 780: } ! 781: if (cmtopg(next) > maxfree) { ! 782: printf("free list link out of range: in %x to %x\n", cmtopg(prev), cmtopg(next)); ! 783: dumpcm("bad link in", cmtopg(prev)); ! 784: } ! 785: paginfo[cmtopg(next)].z_type = ZFREE; ! 786: if (fflg) ! 787: dumpcm("free", cmtopg(next)); ! 788: paginfo[cmtopg(next)+1].z_type = ZFREE; ! 789: if (fflg) ! 790: dumpcm("free", cmtopg(next)+1); ! 791: } ! 792: } ! 793: ! 794: get(loc) ! 795: unsigned loc; ! 796: { ! 797: int x; ! 798: ! 799: lseek(fcore, (long)clear(loc), 0); ! 800: if (read(fcore, (char *)&x, sizeof (int)) != sizeof (int)) { ! 801: perror("read"); ! 802: fprintf(stderr, "get failed on %x\n", clear(loc)); ! 803: return (0); ! 804: } ! 805: return (x); ! 806: } ! 807: /* ! 808: * Convert a virtual page number ! 809: * to its corresponding disk block number. ! 810: * Used in pagein/pageout to initiate single page transfers. ! 811: */ ! 812: vtod(p, v, dmap, smap) ! 813: register struct proc *p; ! 814: register struct dmap *dmap, *smap; ! 815: { ! 816: struct dblock db; ! 817: ! 818: if (isatsv(p, v)) { ! 819: v = ctod(vtotp(p, v)); ! 820: return(p->p_textp->x_daddr[v / dmtext] + v % dmtext); ! 821: } ! 822: if (isassv(p, v)) ! 823: vstodb(ctod(vtosp(p, v)), ctod(1), smap, &db, 1); ! 824: else ! 825: vstodb(ctod(vtodp(p, v)), ctod(1), dmap, &db, 0); ! 826: return (db.db_base); ! 827: } ! 828: ! 829: /* ! 830: * Convert a pte pointer to ! 831: * a virtual page number. ! 832: */ ! 833: ptetov(p, pte) ! 834: register struct proc *p; ! 835: register struct pte *pte; ! 836: { ! 837: ! 838: if (isatpte(p, pte)) ! 839: return (tptov(p, ptetotp(p, pte))); ! 840: else if (isadpte(p, pte)) ! 841: return (dptov(p, ptetodp(p, pte))); ! 842: else ! 843: return (sptov(p, ptetosp(p, pte))); ! 844: } ! 845: ! 846: /* ! 847: * Given a base/size pair in virtual swap area, ! 848: * return a physical base/size pair which is the ! 849: * (largest) initial, physically contiguous block. ! 850: */ ! 851: vstodb(vsbase, vssize, dmp, dbp, rev) ! 852: register int vsbase; ! 853: int vssize; ! 854: register struct dmap *dmp; ! 855: register struct dblock *dbp; ! 856: { ! 857: register int blk = dmmin; ! 858: register swblk_t *ip = dmp->dm_map; ! 859: ! 860: if (vsbase < 0 || vsbase + vssize > dmp->dm_size) ! 861: panic("vstodb"); ! 862: while (vsbase >= blk) { ! 863: vsbase -= blk; ! 864: if (blk < dmmax) ! 865: blk *= 2; ! 866: ip++; ! 867: } ! 868: dbp->db_size = min(vssize, blk - vsbase); ! 869: dbp->db_base = *ip + (rev ? blk - (vsbase + vssize) : vsbase); ! 870: } ! 871: ! 872: panic(cp) ! 873: char *cp; ! 874: { ! 875: printf("panic!: %s\n", cp); ! 876: } ! 877: ! 878: min(a, b) ! 879: { ! 880: return (a < b ? a : b); ! 881: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.