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