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