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