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