4.3BSD - /usr/src/old/analyze.c

   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: }

Defined functions

Defined variables

Defined struct's

Defined macros