![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pstat.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / etc|
Return to pstat.c CVS log | Up to [CSRG BSD Unix] / 43BSD / etc |
1.1 root 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[] = "@(#)pstat.c 5.8 (Berkeley) 5/5/86";
15: #endif not lint
16:
17: /*
18: * Print system stuff
19: */
20:
21: #define mask(x) (x&0377)
22: #define clear(x) ((int)x&0x7fffffff)
23:
24: #include <sys/param.h>
25: #include <sys/dir.h>
26: #define KERNEL
27: #include <sys/file.h>
28: #undef KERNEL
29: #include <sys/user.h>
30: #include <sys/proc.h>
31: #include <sys/text.h>
32: #include <sys/inode.h>
33: #include <sys/map.h>
34: #include <sys/ioctl.h>
35: #include <sys/tty.h>
36: #include <sys/conf.h>
37: #include <sys/vm.h>
38: #include <nlist.h>
39: #include <machine/pte.h>
40: #include <stdio.h>
41:
42: char *fcore = "/dev/kmem";
43: char *fmem = "/dev/mem";
44: char *fnlist = "/vmunix";
45: int fc, fm;
46:
47: struct nlist nl[] = {
48: #define SINODE 0
49: { "_inode" },
50: #define STEXT 1
51: { "_text" },
52: #define SPROC 2
53: { "_proc" },
54: #define SDZ 3
55: { "_dz_tty" },
56: #define SNDZ 4
57: { "_dz_cnt" },
58: #define SKL 5
59: { "_cons" },
60: #define SFIL 6
61: { "_file" },
62: #define USRPTMA 7
63: { "_Usrptmap" },
64: #define USRPT 8
65: { "_usrpt" },
66: #define SWAPMAP 9
67: { "_swapmap" },
68: #define SDH 10
69: { "_dh11" },
70: #define SNDH 11
71: { "_ndh11" },
72: #define SNPROC 12
73: { "_nproc" },
74: #define SNTEXT 13
75: { "_ntext" },
76: #define SNFILE 14
77: { "_nfile" },
78: #define SNINODE 15
79: { "_ninode" },
80: #define SNSWAPMAP 16
81: { "_nswapmap" },
82: #define SPTY 17
83: { "_pt_tty" },
84: #define SDMMIN 18
85: { "_dmmin" },
86: #define SDMMAX 19
87: { "_dmmax" },
88: #define SNSWDEV 20
89: { "_nswdev" },
90: #define SSWDEVT 21
91: { "_swdevt" },
92: #define SDMF 22
93: { "_dmf_tty" },
94: #define SNDMF 23
95: { "_ndmf" },
96: #define SNPTY 24
97: { "_npty" },
98: #define SDHU 25
99: { "_dhu_tty" },
100: #define SNDHU 26
101: { "_ndhu" },
102: #define SYSMAP 27
103: { "_Sysmap" },
104: #define SDMZ 28
105: { "_dmz_tty" },
106: #define SNDMZ 29
107: { "_ndmz" },
108: { "" }
109: };
110:
111: int inof;
112: int txtf;
113: int prcf;
114: int ttyf;
115: int usrf;
116: long ubase;
117: int filf;
118: int swpf;
119: int totflg;
120: char partab[1];
121: struct cdevsw cdevsw[1];
122: struct bdevsw bdevsw[1];
123: int allflg;
124: int kflg;
125: struct pte *Usrptma;
126: struct pte *usrpt;
127: u_long getw();
128: off_t mkphys();
129:
130: main(argc, argv)
131: char **argv;
132: {
133: register char *argp;
134: int allflags;
135:
136: argc--, argv++;
137: while (argc > 0 && **argv == '-') {
138: argp = *argv++;
139: argp++;
140: argc--;
141: while (*argp++)
142: switch (argp[-1]) {
143:
144: case 'T':
145: totflg++;
146: break;
147:
148: case 'a':
149: allflg++;
150: break;
151:
152: case 'i':
153: inof++;
154: break;
155:
156: case 'k':
157: kflg++;
158: fcore = fmem = "/vmcore";
159: break;
160:
161: case 'x':
162: txtf++;
163: break;
164:
165: case 'p':
166: prcf++;
167: break;
168:
169: case 't':
170: ttyf++;
171: break;
172:
173: case 'u':
174: if (argc == 0)
175: break;
176: argc--;
177: usrf++;
178: sscanf( *argv++, "%x", &ubase);
179: break;
180:
181: case 'f':
182: filf++;
183: break;
184: case 's':
185: swpf++;
186: break;
187: default:
188: usage();
189: exit(1);
190: }
191: }
192: if (argc>1) {
193: fcore = fmem = argv[1];
194: kflg++;
195: }
196: if ((fc = open(fcore, 0)) < 0) {
197: printf("Can't find %s\n", fcore);
198: exit(1);
199: }
200: if ((fm = open(fmem, 0)) < 0) {
201: printf("Can't find %s\n", fmem);
202: exit(1);
203: }
204: if (argc>0)
205: fnlist = argv[0];
206: nlist(fnlist, nl);
207: usrpt = (struct pte *)nl[USRPT].n_value;
208: Usrptma = (struct pte *)nl[USRPTMA].n_value;
209: if (nl[0].n_type == 0) {
210: printf("no namelist\n");
211: exit(1);
212: }
213: allflags = filf | totflg | inof | prcf | txtf | ttyf | usrf | swpf;
214: if (allflags == 0) {
215: printf("pstat: one or more of -[aixptfsu] is required\n");
216: exit(1);
217: }
218: if (filf||totflg)
219: dofile();
220: if (inof||totflg)
221: doinode();
222: if (prcf||totflg)
223: doproc();
224: if (txtf||totflg)
225: dotext();
226: if (ttyf)
227: dotty();
228: if (usrf)
229: dousr();
230: if (swpf||totflg)
231: doswap();
232: }
233:
234: usage()
235: {
236:
237: printf("usage: pstat -[aixptfs] [-u [ubase]] [system] [core]\n");
238: }
239:
240: doinode()
241: {
242: register struct inode *ip;
243: struct inode *xinode, *ainode;
244: register int nin;
245: int ninode;
246:
247: nin = 0;
248: ninode = getw(nl[SNINODE].n_value);
249: xinode = (struct inode *)calloc(ninode, sizeof (struct inode));
250: ainode = (struct inode *)getw(nl[SINODE].n_value);
251: if (ninode < 0 || ninode > 10000) {
252: fprintf(stderr, "number of inodes is preposterous (%d)\n",
253: ninode);
254: return;
255: }
256: if (xinode == NULL) {
257: fprintf(stderr, "can't allocate memory for inode table\n");
258: return;
259: }
260: lseek(fc, mkphys((off_t)ainode), 0);
261: read(fc, xinode, ninode * sizeof(struct inode));
262: for (ip = xinode; ip < &xinode[ninode]; ip++)
263: if (ip->i_count)
264: nin++;
265: if (totflg) {
266: printf("%3d/%3d inodes\n", nin, ninode);
267: return;
268: }
269: printf("%d/%d active inodes\n", nin, ninode);
270: printf(" LOC FLAGS CNT DEVICE RDC WRC INO MODE NLK UID SIZE/DEV\n");
271: for (ip = xinode; ip < &xinode[ninode]; ip++) {
272: if (ip->i_count == 0)
273: continue;
274: printf("%8.1x ", ainode + (ip - xinode));
275: putf(ip->i_flag&ILOCKED, 'L');
276: putf(ip->i_flag&IUPD, 'U');
277: putf(ip->i_flag&IACC, 'A');
278: putf(ip->i_flag&IMOUNT, 'M');
279: putf(ip->i_flag&IWANT, 'W');
280: putf(ip->i_flag&ITEXT, 'T');
281: putf(ip->i_flag&ICHG, 'C');
282: putf(ip->i_flag&ISHLOCK, 'S');
283: putf(ip->i_flag&IEXLOCK, 'E');
284: putf(ip->i_flag&ILWAIT, 'Z');
285: printf("%4d", ip->i_count&0377);
286: printf("%4d,%3d", major(ip->i_dev), minor(ip->i_dev));
287: printf("%4d", ip->i_shlockc&0377);
288: printf("%4d", ip->i_exlockc&0377);
289: printf("%6d", ip->i_number);
290: printf("%6x", ip->i_mode & 0xffff);
291: printf("%4d", ip->i_nlink);
292: printf("%4d", ip->i_uid);
293: if ((ip->i_mode&IFMT)==IFBLK || (ip->i_mode&IFMT)==IFCHR)
294: printf("%6d,%3d", major(ip->i_rdev), minor(ip->i_rdev));
295: else
296: printf("%10ld", ip->i_size);
297: printf("\n");
298: }
299: free(xinode);
300: }
301:
302: u_long
303: getw(loc)
304: off_t loc;
305: {
306: u_long word;
307:
308: if (kflg)
309: loc &= 0x7fffffff;
310: lseek(fc, loc, 0);
311: read(fc, &word, sizeof (word));
312: return (word);
313: }
314:
315: putf(v, n)
316: {
317: if (v)
318: printf("%c", n);
319: else
320: printf(" ");
321: }
322:
323: dotext()
324: {
325: register struct text *xp;
326: int ntext;
327: struct text *xtext, *atext;
328: int ntx, ntxca;
329:
330: ntx = ntxca = 0;
331: ntext = getw(nl[SNTEXT].n_value);
332: xtext = (struct text *)calloc(ntext, sizeof (struct text));
333: atext = (struct text *)getw(nl[STEXT].n_value);
334: if (ntext < 0 || ntext > 10000) {
335: fprintf(stderr, "number of texts is preposterous (%d)\n",
336: ntext);
337: return;
338: }
339: if (xtext == NULL) {
340: fprintf(stderr, "can't allocate memory for text table\n");
341: return;
342: }
343: lseek(fc, mkphys((off_t)atext), 0);
344: read(fc, xtext, ntext * sizeof (struct text));
345: for (xp = xtext; xp < &xtext[ntext]; xp++) {
346: if (xp->x_iptr != NULL)
347: ntxca++;
348: if (xp->x_count != 0)
349: ntx++;
350: }
351: if (totflg) {
352: printf("%3d/%3d texts active, %3d used\n", ntx, ntext, ntxca);
353: return;
354: }
355: printf("%d/%d active texts, %d used\n", ntx, ntext, ntxca);
356: printf("\
357: LOC FLAGS DADDR CADDR RSS SIZE IPTR CNT CCNT FORW BACK\n");
358: for (xp = xtext; xp < &xtext[ntext]; xp++) {
359: if (xp->x_iptr == NULL)
360: continue;
361: printf("%8.1x", atext + (xp - xtext));
362: printf(" ");
363: putf(xp->x_flag&XPAGI, 'P');
364: putf(xp->x_flag&XTRC, 'T');
365: putf(xp->x_flag&XWRIT, 'W');
366: putf(xp->x_flag&XLOAD, 'L');
367: putf(xp->x_flag&XLOCK, 'K');
368: putf(xp->x_flag&XWANT, 'w');
369: printf("%5x", xp->x_daddr[0]);
370: printf("%10x", xp->x_caddr);
371: printf("%5d", xp->x_rssize);
372: printf("%5d", xp->x_size);
373: printf("%10.1x", xp->x_iptr);
374: printf("%5d", xp->x_count&0377);
375: printf("%5d", xp->x_ccount);
376: printf("%10x", xp->x_forw);
377: printf("%9x", xp->x_back);
378: printf("\n");
379: }
380: free(xtext);
381: }
382:
383: doproc()
384: {
385: struct proc *xproc, *aproc;
386: int nproc;
387: register struct proc *pp;
388: register loc, np;
389: struct pte apte;
390:
391: nproc = getw(nl[SNPROC].n_value);
392: xproc = (struct proc *)calloc(nproc, sizeof (struct proc));
393: aproc = (struct proc *)getw(nl[SPROC].n_value);
394: if (nproc < 0 || nproc > 10000) {
395: fprintf(stderr, "number of procs is preposterous (%d)\n",
396: nproc);
397: return;
398: }
399: if (xproc == NULL) {
400: fprintf(stderr, "can't allocate memory for proc table\n");
401: return;
402: }
403: lseek(fc, mkphys((off_t)aproc), 0);
404: read(fc, xproc, nproc * sizeof (struct proc));
405: np = 0;
406: for (pp=xproc; pp < &xproc[nproc]; pp++)
407: if (pp->p_stat)
408: np++;
409: if (totflg) {
410: printf("%3d/%3d processes\n", np, nproc);
411: return;
412: }
413: printf("%d/%d processes\n", np, nproc);
414: printf(" LOC S F POIP PRI SIG UID SLP TIM CPU NI PGRP PID PPID ADDR RSS SRSS SIZE WCHAN LINK TEXTP\n");
415: for (pp=xproc; pp<&xproc[nproc]; pp++) {
416: if (pp->p_stat==0 && allflg==0)
417: continue;
418: printf("%8x", aproc + (pp - xproc));
419: printf(" %2d", pp->p_stat);
420: printf(" %4x", pp->p_flag & 0xffff);
421: printf(" %4d", pp->p_poip);
422: printf(" %3d", pp->p_pri);
423: printf(" %8x", pp->p_sig);
424: printf(" %4d", pp->p_uid);
425: printf(" %3d", pp->p_slptime);
426: printf(" %3d", pp->p_time);
427: printf(" %4d", pp->p_cpu&0377);
428: printf(" %3d", pp->p_nice);
429: printf(" %6d", pp->p_pgrp);
430: printf(" %6d", pp->p_pid);
431: printf(" %6d", pp->p_ppid);
432: if (kflg)
433: pp->p_addr = (struct pte *)clear((int)pp->p_addr);
434: if (pp->p_flag & SLOAD) {
435: lseek(fc, (long)pp->p_addr, 0);
436: read(fc, &apte, sizeof(apte));
437: printf(" %8x", apte.pg_pfnum);
438: } else
439: printf(" %8x", pp->p_swaddr);
440: printf(" %4x", pp->p_rssize);
441: printf(" %4x", pp->p_swrss);
442: printf(" %5x", pp->p_dsize+pp->p_ssize);
443: printf(" %7x", clear(pp->p_wchan));
444: printf(" %7x", clear(pp->p_link));
445: printf(" %7x", clear(pp->p_textp));
446: printf("\n");
447: }
448: free(xproc);
449: }
450:
451: static char mesg[] =
452: " # RAW CAN OUT MODE ADDR DEL COL STATE PGRP DISC\n";
453: static int ttyspace = 128;
454: static struct tty *tty;
455:
456: dotty()
457: {
458: extern char *malloc();
459:
460: if ((tty = (struct tty *)malloc(ttyspace * sizeof(*tty))) == 0) {
461: printf("pstat: out of memory\n");
462: return;
463: }
464: printf("1 cons\n");
465: if (kflg)
466: nl[SKL].n_value = clear(nl[SKL].n_value);
467: lseek(fc, (long)nl[SKL].n_value, 0);
468: read(fc, tty, sizeof(*tty));
469: printf(mesg);
470: ttyprt(&tty[0], 0);
471: if (nl[SNDZ].n_type != 0)
472: dottytype("dz", SDZ, SNDZ);
473: if (nl[SNDH].n_type != 0)
474: dottytype("dh", SDH, SNDH);
475: if (nl[SNDMF].n_type != 0)
476: dottytype("dmf", SDMF, SNDMF);
477: if (nl[SNDHU].n_type != 0)
478: dottytype("dhu", SDHU, SNDHU);
479: if (nl[SNDMZ].n_type != 0)
480: dottytype("dmz", SDMZ, SNDMZ);
481: if (nl[SNPTY].n_type != 0)
482: dottytype("pty", SPTY, SNPTY);
483: }
484:
485: dottytype(name, type, number)
486: char *name;
487: {
488: int ntty;
489: register struct tty *tp;
490: extern char *realloc();
491:
492: if (tty == (struct tty *)0)
493: return;
494: if (kflg) {
495: nl[number].n_value = clear(nl[number].n_value);
496: nl[type].n_value = clear(nl[type].n_value);
497: }
498: lseek(fc, (long)nl[number].n_value, 0);
499: read(fc, &ntty, sizeof(ntty));
500: printf("%d %s lines\n", ntty, name);
501: if (ntty > ttyspace) {
502: ttyspace = ntty;
503: if ((tty = (struct tty *)realloc(tty, ttyspace * sizeof(*tty))) == 0) {
504: printf("pstat: out of memory\n");
505: return;
506: }
507: }
508: lseek(fc, (long)nl[type].n_value, 0);
509: read(fc, tty, ntty * sizeof(struct tty));
510: printf(mesg);
511: for (tp = tty; tp < &tty[ntty]; tp++)
512: ttyprt(tp, tp - tty);
513: }
514:
515: ttyprt(atp, line)
516: struct tty *atp;
517: {
518: register struct tty *tp;
519:
520: printf("%2d", line);
521: tp = atp;
522: switch (tp->t_line) {
523:
524: /*
525: case NETLDISC:
526: if (tp->t_rec)
527: printf("%4d%4d", 0, tp->t_inbuf);
528: else
529: printf("%4d%4d", tp->t_inbuf, 0);
530: break;
531: */
532:
533: default:
534: printf("%4d%4d", tp->t_rawq.c_cc, tp->t_canq.c_cc);
535: }
536: printf("%4d %8x %8x%4d%4d", tp->t_outq.c_cc, tp->t_flags,
537: tp->t_addr, tp->t_delct, tp->t_col);
538: putf(tp->t_state&TS_TIMEOUT, 'T');
539: putf(tp->t_state&TS_WOPEN, 'W');
540: putf(tp->t_state&TS_ISOPEN, 'O');
541: putf(tp->t_state&TS_FLUSH, 'F');
542: putf(tp->t_state&TS_CARR_ON, 'C');
543: putf(tp->t_state&TS_BUSY, 'B');
544: putf(tp->t_state&TS_ASLEEP, 'A');
545: putf(tp->t_state&TS_XCLUDE, 'X');
546: putf(tp->t_state&TS_TTSTOP, 'S');
547: putf(tp->t_state&TS_HUPCLS, 'H');
548: printf("%6d", tp->t_pgrp);
549: switch (tp->t_line) {
550:
551: case OTTYDISC:
552: printf("\n");
553: break;
554:
555: case NTTYDISC:
556: printf(" ntty\n");
557: break;
558:
559: case NETLDISC:
560: printf(" berknet\n");
561: break;
562:
563: case TABLDISC:
564: printf(" tab\n");
565: break;
566:
567: default:
568: printf(" %d\n", tp->t_line);
569: }
570: }
571:
572: dousr()
573: {
574: struct user U;
575: register i, j, *ip;
576: register struct nameidata *nd = &U.u_nd;
577:
578: /* This wins only if CLBYTES >= sizeof (struct user) */
579: lseek(fm, ubase * NBPG, 0);
580: read(fm, &U, sizeof(U));
581: printf("pcb");
582: ip = (int *)&U.u_pcb;
583: while (ip < &U.u_arg[0]) {
584: if ((ip - (int *)&U.u_pcb) % 4 == 0)
585: printf("\t");
586: printf("%x ", *ip++);
587: if ((ip - (int *)&U.u_pcb) % 4 == 0)
588: printf("\n");
589: }
590: if ((ip - (int *)&U.u_pcb) % 4 != 0)
591: printf("\n");
592: printf("arg");
593: for (i=0; i<sizeof(U.u_arg)/sizeof(U.u_arg[0]); i++) {
594: if (i%5==0)
595: printf("\t");
596: printf(" %.1x", U.u_arg[i]);
597: if (i%5==4)
598: printf("\n");
599: }
600: if (i%5)
601: printf("\n");
602: printf("segflg\t%d\nerror %d\n", nd->ni_segflg, U.u_error);
603: printf("uids\t%d,%d,%d,%d\n", U.u_uid,U.u_gid,U.u_ruid,U.u_rgid);
604: printf("procp\t%.1x\n", U.u_procp);
605: printf("ap\t%.1x\n", U.u_ap);
606: printf("r_val?\t%.1x %.1x\n", U.u_r.r_val1, U.u_r.r_val2);
607: printf("base, count, offset %.1x %.1x %ld\n", nd->ni_base,
608: nd->ni_count, nd->ni_offset);
609: printf("cdir rdir %.1x %.1x\n", U.u_cdir, U.u_rdir);
610: printf("dirp %.1x\n", nd->ni_dirp);
611: printf("dent %d %.14s\n", nd->ni_dent.d_ino, nd->ni_dent.d_name);
612: printf("pdir %.1o\n", nd->ni_pdir);
613: printf("file");
614: for (i=0; i<NOFILE; i++) {
615: if (i % 8 == 0)
616: printf("\t");
617: printf("%9.1x", U.u_ofile[i]);
618: if (i % 8 == 7)
619: printf("\n");
620: }
621: if (i % 8)
622: printf("\n");
623: printf("pofile");
624: for (i=0; i<NOFILE; i++) {
625: if (i % 8 == 0)
626: printf("\t");
627: printf("%9.1x", U.u_pofile[i]);
628: if (i % 8 == 7)
629: printf("\n");
630: }
631: if (i % 8)
632: printf("\n");
633: printf("ssave");
634: for (i=0; i<sizeof(label_t)/sizeof(int); i++) {
635: if (i%5==0)
636: printf("\t");
637: printf("%9.1x", U.u_ssave.val[i]);
638: if (i%5==4)
639: printf("\n");
640: }
641: if (i%5)
642: printf("\n");
643: printf("sigs");
644: for (i=0; i<NSIG; i++) {
645: if (i % 8 == 0)
646: printf("\t");
647: printf("%.1x ", U.u_signal[i]);
648: if (i % 8 == 7)
649: printf("\n");
650: }
651: if (i % 8)
652: printf("\n");
653: printf("code\t%.1x\n", U.u_code);
654: printf("ar0\t%.1x\n", U.u_ar0);
655: printf("prof\t%X %X %X %X\n", U.u_prof.pr_base, U.u_prof.pr_size,
656: U.u_prof.pr_off, U.u_prof.pr_scale);
657: printf("\neosys\t%d\n", U.u_eosys);
658: printf("ttyp\t%.1x\n", U.u_ttyp);
659: printf("ttyd\t%d,%d\n", major(U.u_ttyd), minor(U.u_ttyd));
660: printf("comm %.14s\n", U.u_comm);
661: printf("start\t%D\n", U.u_start);
662: printf("acflag\t%D\n", U.u_acflag);
663: printf("cmask\t%D\n", U.u_cmask);
664: printf("sizes\t%.1x %.1x %.1x\n", U.u_tsize, U.u_dsize, U.u_ssize);
665: printf("ru\t");
666: ip = (int *)&U.u_ru;
667: for (i = 0; i < sizeof(U.u_ru)/sizeof(int); i++)
668: printf("%D ", ip[i]);
669: printf("\n");
670: ip = (int *)&U.u_cru;
671: printf("cru\t");
672: for (i = 0; i < sizeof(U.u_cru)/sizeof(int); i++)
673: printf("%D ", ip[i]);
674: printf("\n");
675: /*
676: i = U.u_stack - &U;
677: while (U[++i] == 0);
678: i &= ~07;
679: while (i < 512) {
680: printf("%x ", 0140000+2*i);
681: for (j=0; j<8; j++)
682: printf("%9x", U[i++]);
683: printf("\n");
684: }
685: */
686: }
687:
688: oatoi(s)
689: char *s;
690: {
691: register v;
692:
693: v = 0;
694: while (*s)
695: v = (v<<3) + *s++ - '0';
696: return(v);
697: }
698:
699: dofile()
700: {
701: int nfile;
702: struct file *xfile, *afile;
703: register struct file *fp;
704: register nf;
705: int loc;
706: static char *dtypes[] = { "???", "inode", "socket" };
707:
708: nf = 0;
709: nfile = getw(nl[SNFILE].n_value);
710: xfile = (struct file *)calloc(nfile, sizeof (struct file));
711: afile = (struct file *)getw(nl[SFIL].n_value);
712: if (nfile < 0 || nfile > 10000) {
713: fprintf(stderr, "number of files is preposterous (%d)\n",
714: nfile);
715: return;
716: }
717: if (xfile == NULL) {
718: fprintf(stderr, "can't allocate memory for file table\n");
719: return;
720: }
721: lseek(fc, mkphys((off_t)afile), 0);
722: read(fc, xfile, nfile * sizeof (struct file));
723: for (fp=xfile; fp < &xfile[nfile]; fp++)
724: if (fp->f_count)
725: nf++;
726: if (totflg) {
727: printf("%3d/%3d files\n", nf, nfile);
728: return;
729: }
730: printf("%d/%d open files\n", nf, nfile);
731: printf(" LOC TYPE FLG CNT MSG DATA OFFSET\n");
732: for (fp=xfile,loc=(int)afile; fp < &xfile[nfile]; fp++,loc+=sizeof(xfile[0])) {
733: if (fp->f_count==0)
734: continue;
735: printf("%8x ", loc);
736: if (fp->f_type <= DTYPE_SOCKET)
737: printf("%-8.8s", dtypes[fp->f_type]);
738: else
739: printf("8d", fp->f_type);
740: putf(fp->f_flag&FREAD, 'R');
741: putf(fp->f_flag&FWRITE, 'W');
742: putf(fp->f_flag&FAPPEND, 'A');
743: putf(fp->f_flag&FSHLOCK, 'S');
744: putf(fp->f_flag&FEXLOCK, 'X');
745: putf(fp->f_flag&FASYNC, 'I');
746: printf(" %3d", mask(fp->f_count));
747: printf(" %3d", mask(fp->f_msgcount));
748: printf(" %8.1x", fp->f_data);
749: if (fp->f_offset < 0)
750: printf(" %x\n", fp->f_offset);
751: else
752: printf(" %ld\n", fp->f_offset);
753: }
754: free(xfile);
755: }
756:
757: int dmmin, dmmax, nswdev;
758:
759: doswap()
760: {
761: struct proc *proc;
762: int nproc;
763: struct text *xtext;
764: int ntext;
765: struct map *swapmap;
766: int nswapmap;
767: struct swdevt *swdevt, *sw;
768: register struct proc *pp;
769: int nswap, used, tused, free, waste;
770: int db, sb;
771: register struct mapent *me;
772: register struct text *xp;
773: int i, j;
774:
775: nproc = getw(nl[SNPROC].n_value);
776: ntext = getw(nl[SNTEXT].n_value);
777: if (nproc < 0 || nproc > 10000 || ntext < 0 || ntext > 10000) {
778: fprintf(stderr, "number of procs/texts is preposterous (%d, %d)\n",
779: nproc, ntext);
780: return;
781: }
782: proc = (struct proc *)calloc(nproc, sizeof (struct proc));
783: if (proc == NULL) {
784: fprintf(stderr, "can't allocate memory for proc table\n");
785: exit(1);
786: }
787: xtext = (struct text *)calloc(ntext, sizeof (struct text));
788: if (xtext == NULL) {
789: fprintf(stderr, "can't allocate memory for text table\n");
790: exit(1);
791: }
792: nswapmap = getw(nl[SNSWAPMAP].n_value);
793: swapmap = (struct map *)calloc(nswapmap, sizeof (struct map));
794: if (swapmap == NULL) {
795: fprintf(stderr, "can't allocate memory for swapmap\n");
796: exit(1);
797: }
798: nswdev = getw(nl[SNSWDEV].n_value);
799: swdevt = (struct swdevt *)calloc(nswdev, sizeof (struct swdevt));
800: if (swdevt == NULL) {
801: fprintf(stderr, "can't allocate memory for swdevt table\n");
802: exit(1);
803: }
804: lseek(fc, mkphys((off_t)nl[SSWDEVT].n_value), L_SET);
805: read(fc, swdevt, nswdev * sizeof (struct swdevt));
806: lseek(fc, mkphys((off_t)getw(nl[SPROC].n_value)), 0);
807: read(fc, proc, nproc * sizeof (struct proc));
808: lseek(fc, mkphys((off_t)getw(nl[STEXT].n_value)), 0);
809: read(fc, xtext, ntext * sizeof (struct text));
810: lseek(fc, mkphys((off_t)getw(nl[SWAPMAP].n_value)), 0);
811: read(fc, swapmap, nswapmap * sizeof (struct map));
812: swapmap->m_name = "swap";
813: swapmap->m_limit = (struct mapent *)&swapmap[nswapmap];
814: dmmin = getw(nl[SDMMIN].n_value);
815: dmmax = getw(nl[SDMMAX].n_value);
816: nswap = 0;
817: for (sw = swdevt; sw < &swdevt[nswdev]; sw++)
818: if (sw->sw_freed)
819: nswap += sw->sw_nblks;
820: free = 0;
821: for (me = (struct mapent *)(swapmap+1);
822: me < (struct mapent *)&swapmap[nswapmap]; me++)
823: free += me->m_size;
824: tused = 0;
825: for (xp = xtext; xp < &xtext[ntext]; xp++)
826: if (xp->x_iptr!=NULL) {
827: tused += ctod(clrnd(xp->x_size));
828: if (xp->x_flag & XPAGI)
829: tused += ctod(clrnd(ctopt(xp->x_size)));
830: }
831: used = tused;
832: waste = 0;
833: for (pp = proc; pp < &proc[nproc]; pp++) {
834: if (pp->p_stat == 0 || pp->p_stat == SZOMB)
835: continue;
836: if (pp->p_flag & SSYS)
837: continue;
838: db = ctod(pp->p_dsize), sb = up(db);
839: used += sb;
840: waste += sb - db;
841: db = ctod(pp->p_ssize), sb = up(db);
842: used += sb;
843: waste += sb - db;
844: if ((pp->p_flag&SLOAD) == 0)
845: used += ctod(vusize(pp));
846: }
847: if (totflg) {
848: #define btok(x) ((x) / (1024 / DEV_BSIZE))
849: printf("%3d/%3d 00k swap\n",
850: btok(used/100), btok((used+free)/100));
851: return;
852: }
853: printf("%dk used (%dk text), %dk free, %dk wasted, %dk missing\n",
854: btok(used), btok(tused), btok(free), btok(waste),
855: /* a dmmax/2 block goes to argmap */
856: btok(nswap - dmmax/2 - (used + free)));
857: printf("avail: ");
858: for (i = dmmax; i >= dmmin; i /= 2) {
859: j = 0;
860: while (rmalloc(swapmap, i) != 0)
861: j++;
862: if (j) printf("%d*%dk ", j, btok(i));
863: }
864: free = 0;
865: for (me = (struct mapent *)(swapmap+1);
866: me < (struct mapent *)&swapmap[nswapmap]; me++)
867: free += me->m_size;
868: printf("%d*1k\n", btok(free));
869: }
870:
871: up(size)
872: register int size;
873: {
874: register int i, block;
875:
876: i = 0;
877: block = dmmin;
878: while (i < size) {
879: i += block;
880: if (block < dmmax)
881: block *= 2;
882: }
883: return (i);
884: }
885:
886: /*
887: * Compute number of pages to be allocated to the u. area
888: * and data and stack area page tables, which are stored on the
889: * disk immediately after the u. area.
890: */
891: vusize(p)
892: register struct proc *p;
893: {
894: register int tsz = p->p_tsize / NPTEPG;
895:
896: /*
897: * We do not need page table space on the disk for page
898: * table pages wholly containing text.
899: */
900: return (clrnd(UPAGES +
901: clrnd(ctopt(p->p_tsize+p->p_dsize+p->p_ssize+UPAGES)) - tsz));
902: }
903:
904: /*
905: * Allocate 'size' units from the given
906: * map. Return the base of the allocated space.
907: * In a map, the addresses are increasing and the
908: * list is terminated by a 0 size.
909: *
910: * Algorithm is first-fit.
911: *
912: * This routine knows about the interleaving of the swapmap
913: * and handles that.
914: */
915: long
916: rmalloc(mp, size)
917: register struct map *mp;
918: long size;
919: {
920: register struct mapent *ep = (struct mapent *)(mp+1);
921: register int addr;
922: register struct mapent *bp;
923: swblk_t first, rest;
924:
925: if (size <= 0 || size > dmmax)
926: return (0);
927: /*
928: * Search for a piece of the resource map which has enough
929: * free space to accomodate the request.
930: */
931: for (bp = ep; bp->m_size; bp++) {
932: if (bp->m_size >= size) {
933: /*
934: * If allocating from swapmap,
935: * then have to respect interleaving
936: * boundaries.
937: */
938: if (nswdev > 1 &&
939: (first = dmmax - bp->m_addr%dmmax) < bp->m_size) {
940: if (bp->m_size - first < size)
941: continue;
942: addr = bp->m_addr + first;
943: rest = bp->m_size - first - size;
944: bp->m_size = first;
945: if (rest)
946: rmfree(mp, rest, addr+size);
947: return (addr);
948: }
949: /*
950: * Allocate from the map.
951: * If there is no space left of the piece
952: * we allocated from, move the rest of
953: * the pieces to the left.
954: */
955: addr = bp->m_addr;
956: bp->m_addr += size;
957: if ((bp->m_size -= size) == 0) {
958: do {
959: bp++;
960: (bp-1)->m_addr = bp->m_addr;
961: } while ((bp-1)->m_size = bp->m_size);
962: }
963: if (addr % CLSIZE)
964: return (0);
965: return (addr);
966: }
967: }
968: return (0);
969: }
970:
971: /*
972: * Free the previously allocated space at addr
973: * of size units into the specified map.
974: * Sort addr into map and combine on
975: * one or both ends if possible.
976: */
977: rmfree(mp, size, addr)
978: struct map *mp;
979: long size, addr;
980: {
981: struct mapent *firstbp;
982: register struct mapent *bp;
983: register int t;
984:
985: /*
986: * Both address and size must be
987: * positive, or the protocol has broken down.
988: */
989: if (addr <= 0 || size <= 0)
990: goto badrmfree;
991: /*
992: * Locate the piece of the map which starts after the
993: * returned space (or the end of the map).
994: */
995: firstbp = bp = (struct mapent *)(mp + 1);
996: for (; bp->m_addr <= addr && bp->m_size != 0; bp++)
997: continue;
998: /*
999: * If the piece on the left abuts us,
1000: * then we should combine with it.
1001: */
1002: if (bp > firstbp && (bp-1)->m_addr+(bp-1)->m_size >= addr) {
1003: /*
1004: * Check no overlap (internal error).
1005: */
1006: if ((bp-1)->m_addr+(bp-1)->m_size > addr)
1007: goto badrmfree;
1008: /*
1009: * Add into piece on the left by increasing its size.
1010: */
1011: (bp-1)->m_size += size;
1012: /*
1013: * If the combined piece abuts the piece on
1014: * the right now, compress it in also,
1015: * by shifting the remaining pieces of the map over.
1016: */
1017: if (bp->m_addr && addr+size >= bp->m_addr) {
1018: if (addr+size > bp->m_addr)
1019: goto badrmfree;
1020: (bp-1)->m_size += bp->m_size;
1021: while (bp->m_size) {
1022: bp++;
1023: (bp-1)->m_addr = bp->m_addr;
1024: (bp-1)->m_size = bp->m_size;
1025: }
1026: }
1027: goto done;
1028: }
1029: /*
1030: * Don't abut on the left, check for abutting on
1031: * the right.
1032: */
1033: if (addr+size >= bp->m_addr && bp->m_size) {
1034: if (addr+size > bp->m_addr)
1035: goto badrmfree;
1036: bp->m_addr -= size;
1037: bp->m_size += size;
1038: goto done;
1039: }
1040: /*
1041: * Don't abut at all. Make a new entry
1042: * and check for map overflow.
1043: */
1044: do {
1045: t = bp->m_addr;
1046: bp->m_addr = addr;
1047: addr = t;
1048: t = bp->m_size;
1049: bp->m_size = size;
1050: bp++;
1051: } while (size = t);
1052: /*
1053: * Segment at bp is to be the delimiter;
1054: * If there is not room for it
1055: * then the table is too full
1056: * and we must discard something.
1057: */
1058: if (bp+1 > mp->m_limit) {
1059: /*
1060: * Back bp up to last available segment.
1061: * which contains a segment already and must
1062: * be made into the delimiter.
1063: * Discard second to last entry,
1064: * since it is presumably smaller than the last
1065: * and move the last entry back one.
1066: */
1067: bp--;
1068: printf("%s: rmap ovflo, lost [%d,%d)\n", mp->m_name,
1069: (bp-1)->m_addr, (bp-1)->m_addr+(bp-1)->m_size);
1070: bp[-1] = bp[0];
1071: bp[0].m_size = bp[0].m_addr = 0;
1072: }
1073: done:
1074: return;
1075: badrmfree:
1076: printf("bad rmfree\n");
1077: }
1078: /*
1079: * "addr" is a kern virt addr and does not correspond
1080: * To a phys addr after zipping out the high bit..
1081: * since it was valloc'd in the kernel.
1082: *
1083: * We return the phys addr by simulating kernel vm (/dev/kmem)
1084: * when we are reading a crash dump.
1085: */
1086: off_t
1087: mkphys(addr)
1088: off_t addr;
1089: {
1090: register off_t o;
1091:
1092: if (!kflg)
1093: return(addr);
1094: o = addr & PGOFSET;
1095: addr >>= PGSHIFT;
1096: addr &= PG_PFNUM;
1097: addr *= NBPW;
1098: addr = getw(nl[SYSMAP].n_value + addr);
1099: addr = ((addr & PG_PFNUM) << PGSHIFT) | o;
1100: return(addr);
1101: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.