![[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] / 40BSD / cmd|
Return to pstat.c CVS log | Up to [CSRG BSD Unix] / 40BSD / cmd |
1.1 root 1: static char *sccsid = "@(#)pstat.c 4.3 (Berkeley) 11/15/80";
2: /*
3: * Print system stuff
4: */
5:
6: #define mask(x) (x&0377)
7: #define clear(x) ((int)x&0x7fffffff)
8:
9: #include <sys/param.h>
10: #include <sys/dir.h>
11: #include <sys/file.h>
12: #include <sys/user.h>
13: #include <sys/proc.h>
14: #include <sys/text.h>
15: #include <sys/inode.h>
16: #include <sys/map.h>
17: #include <sys/tty.h>
18: #include <sys/conf.h>
19: #include <sys/vm.h>
20: #include <nlist.h>
21: #include <sys/pte.h>
22:
23: char *fcore = "/dev/kmem";
24: char *fnlist = "/vmunix";
25: int fc;
26:
27: struct nlist nl[] = {
28: #define SINODE 0
29: { "_inode" },
30: #define STEXT 1
31: { "_text" },
32: #define SPROC 2
33: { "_proc" },
34: #define SDZ 3
35: { "_dz_tty" },
36: #define SNDZ 4
37: { "_dz_cnt" },
38: #define SKL 5
39: { "_cons" },
40: #define SFIL 6
41: { "_file" },
42: #define USRPTMA 7
43: { "_Usrptmap" },
44: #define USRPT 8
45: { "_usrpt" },
46: #define SNSWAP 9
47: { "_nswap" },
48: #define SWAPMAP 10
49: { "_swapmap" },
50: #define SDH 11
51: { "_dh11" },
52: #define SNDH 12
53: { "_ndh11" },
54: 0,
55: };
56:
57: int inof;
58: int txtf;
59: int prcf;
60: int ttyf;
61: int usrf;
62: long ubase;
63: int filf;
64: int swpf;
65: int totflg;
66: char partab[1];
67: struct cdevsw cdevsw[1];
68: struct bdevsw bdevsw[1];
69: int allflg;
70: int kflg;
71: struct pte *Usrptma;
72: struct pte *usrpt;
73:
74: main(argc, argv)
75: char **argv;
76: {
77: register char *argp;
78:
79: argc--, argv++;
80: while (argc > 0 && **argv == '-') {
81: argp = *argv++;
82: argp++;
83: argc--;
84: while (*argp++)
85: switch (argp[-1]) {
86:
87: case 'T':
88: totflg++;
89: break;
90:
91: case 'a':
92: allflg++;
93: break;
94:
95: case 'i':
96: inof++;
97: break;
98:
99: case 'k':
100: kflg++;
101: fcore = "/vmcore";
102: break;
103:
104: case 'x':
105: txtf++;
106: break;
107:
108: case 'p':
109: prcf++;
110: break;
111:
112: case 't':
113: ttyf++;
114: break;
115:
116: case 'u':
117: if (argc == 0)
118: break;
119: argc--;
120: usrf++;
121: sscanf( *argv++, "%x", &ubase);
122: break;
123:
124: case 'f':
125: filf++;
126: break;
127: case 's':
128: swpf++;
129: break;
130: }
131: }
132: if (argc>0)
133: fcore = argv[0];
134: if ((fc = open(fcore, 0)) < 0) {
135: printf("Can't find %s\n", fcore);
136: exit(1);
137: }
138: if (argc>1)
139: fnlist = argv[1];
140: nlist(fnlist, nl);
141: if (kflg) {
142: register struct nlist *nlp;
143: for (nlp=nl; nlp < &nl[sizeof (nl)/sizeof(nl[0])]; nlp++)
144: nlp->n_value = clear(nlp->n_value);
145: }
146: usrpt = (struct pte *)nl[USRPT].n_value;
147: Usrptma = (struct pte *)nl[USRPTMA].n_value;
148: if (nl[0].n_type == 0) {
149: printf("no namelist\n");
150: exit(1);
151: }
152: if (filf||totflg)
153: dofil();
154: if (inof||totflg)
155: doinode();
156: if (prcf||totflg)
157: doproc();
158: if (txtf||totflg)
159: dotext();
160: if (ttyf)
161: dotty();
162: if (usrf)
163: dousr();
164: if (swpf||totflg)
165: doswap();
166: }
167:
168: doinode()
169: {
170: register struct inode *ip;
171: struct inode xinode[NINODE];
172: register int nin, loc;
173:
174: nin = 0;
175: lseek(fc, (long)nl[SINODE].n_value, 0);
176: read(fc, xinode, sizeof(xinode));
177: for (ip = xinode; ip < &xinode[NINODE]; ip++)
178: if (ip->i_count)
179: nin++;
180: if (totflg) {
181: printf("%3d/%3d inodes\n", nin, NINODE);
182: return;
183: }
184: printf("%d/%d active xinodes\n", nin, NINODE);
185: printf(" LOC FLAGS CNT DEVICE INO MODE NLK UID SIZE/DEV\n");
186: loc = nl[SINODE].n_value;
187: for (ip = xinode; ip < &xinode[NINODE]; ip++, loc += sizeof(xinode[0])) {
188: if (ip->i_count == 0)
189: continue;
190: printf("%8.1x ", loc);
191: putf(ip->i_flag&ILOCK, 'L');
192: putf(ip->i_flag&IUPD, 'U');
193: putf(ip->i_flag&IACC, 'A');
194: putf(ip->i_flag&IMOUNT, 'M');
195: putf(ip->i_flag&IWANT, 'W');
196: putf(ip->i_flag&ITEXT, 'T');
197: printf("%4d", ip->i_count&0377);
198: printf("%4d,%3d", major(ip->i_dev), minor(ip->i_dev));
199: printf("%6d", ip->i_number);
200: printf("%6x", ip->i_mode & 0xffff);
201: printf("%4d", ip->i_nlink);
202: printf("%4d", ip->i_uid);
203: if ((ip->i_mode&IFMT)==IFBLK || (ip->i_mode&IFMT)==IFCHR)
204: printf("%6d,%3d", major(ip->i_un.i_rdev), minor(ip->i_un.i_rdev));
205: else
206: printf("%10ld", ip->i_size);
207: printf("\n");
208: }
209: }
210:
211: putf(v, n)
212: {
213: if (v)
214: printf("%c", n);
215: else
216: printf(" ");
217: }
218:
219: dotext()
220: {
221: register struct text *xp;
222: struct text xtext[NTEXT];
223: register loc;
224: int ntx;
225:
226: ntx = 0;
227: lseek(fc, (long)nl[STEXT].n_value, 0);
228: read(fc, xtext, sizeof(xtext));
229: for (xp = xtext; xp < &xtext[NTEXT]; xp++)
230: if (xp->x_iptr!=NULL)
231: ntx++;
232: if (totflg) {
233: printf("%3d/%3d texts\n", ntx, NTEXT);
234: return;
235: }
236: printf(" LOC FLAGS DADDR CADDR RSS SIZE IPTR CNT CCNT\n");
237: loc = nl[STEXT].n_value;
238: for (xp = xtext; xp < &xtext[NTEXT]; xp++, loc+=sizeof(xtext[0])) {
239: if (xp->x_iptr == NULL)
240: continue;
241: printf("%8.1x", loc);
242: printf(" ");
243: putf(xp->x_flag&XPAGI, 'P');
244: putf(xp->x_flag&XTRC, 'T');
245: putf(xp->x_flag&XWRIT, 'W');
246: putf(xp->x_flag&XLOAD, 'L');
247: putf(xp->x_flag&XLOCK, 'K');
248: putf(xp->x_flag&XWANT, 'w');
249: printf("%5x", xp->x_daddr[0]);
250: printf("%11x", xp->x_caddr);
251: printf("%5d", xp->x_rssize);
252: printf("%5d", xp->x_size);
253: printf("%10.1x", xp->x_iptr);
254: printf("%5d", xp->x_count&0377);
255: printf("%5d", xp->x_ccount);
256: printf("\n");
257: }
258: }
259:
260: doproc()
261: {
262: struct proc xproc[NPROC];
263: register struct proc *pp;
264: register loc, np;
265: struct pte apte;
266:
267: lseek(fc, (long)nl[SPROC].n_value, 0);
268: read(fc, xproc, sizeof(xproc));
269: np = 0;
270: for (pp=xproc; pp < &xproc[NPROC]; pp++)
271: if (pp->p_stat)
272: np++;
273: if (totflg) {
274: printf("%3d/%3d processes\n", np, NPROC);
275: return;
276: }
277: printf("%d/%d processes\n", np, NPROC);
278: printf(" LOC S F POIP PRI SIG UID SLP TIM CPU NI PGRP PID PPID ADDR RSS SRSS SIZE WCHAN LINK TEXTP CLKT\n");
279: for (loc=nl[SPROC].n_value,pp=xproc; pp<&xproc[NPROC]; pp++,loc+=sizeof(xproc[0])) {
280: if (pp->p_stat==0 && allflg==0)
281: continue;
282: printf("%8x", loc);
283: printf(" %2d", pp->p_stat);
284: printf(" %4x", pp->p_flag & 0xffff);
285: printf(" %4d", pp->p_poip);
286: printf(" %3d", pp->p_pri);
287: printf(" %8x", pp->p_sig);
288: printf(" %4d", pp->p_uid);
289: printf(" %3d", pp->p_slptime);
290: printf(" %3d", pp->p_time);
291: printf(" %4d", pp->p_cpu&0377);
292: printf(" %3d", pp->p_nice);
293: printf(" %6d", pp->p_pgrp);
294: printf(" %6d", pp->p_pid);
295: printf(" %6d", pp->p_ppid);
296: if (kflg)
297: pp->p_addr = (struct pte *)clear((int)pp->p_addr);
298: lseek(fc, (long)(Usrptma+btokmx(pp->p_addr)), 0);
299: read(fc, &apte, sizeof(apte));
300: printf(" %8x", ctob(apte.pg_pfnum+1) - sizeof(struct pte) * UPAGES);
301: printf(" %4x", pp->p_rssize);
302: printf(" %4x", pp->p_swrss);
303: printf(" %5x", pp->p_dsize+pp->p_ssize);
304: printf(" %7x", clear(pp->p_wchan));
305: printf(" %7x", clear(pp->p_link));
306: printf(" %7x", clear(pp->p_textp));
307: printf(" %u", pp->p_clktim);
308: printf("\n");
309: }
310: }
311:
312: dotty()
313: {
314: struct tty dz_tty[64];
315: int ndz;
316: register struct tty *tp;
317: register char *mesg;
318:
319: printf("1 cons\n");
320: lseek(fc, (long)nl[SKL].n_value, 0);
321: read(fc, dz_tty, sizeof(dz_tty[0]));
322: mesg = " # RAW CAN OUT MODE ADDR DEL COL STATE PGRP DISC\n";
323: printf(mesg);
324: ttyprt(&dz_tty[0], 0);
325: if (nl[SNDZ].n_type == 0)
326: goto dh;
327: lseek(fc, (long)nl[SNDZ].n_value, 0);
328: read(fc, &ndz, sizeof(ndz));
329: printf("%d dz lines\n", ndz);
330: lseek(fc, (long)nl[SDZ].n_value, 0);
331: read(fc, dz_tty, sizeof(dz_tty));
332: for (tp = dz_tty; tp < &dz_tty[ndz]; tp++)
333: ttyprt(tp, tp - dz_tty);
334: dh:
335: if (nl[SNDH].n_type == 0)
336: return;
337: lseek(fc, (long)nl[SNDH].n_value, 0);
338: read(fc, &ndz, sizeof(ndz));
339: printf("%d dh lines\n", ndz);
340: lseek(fc, (long)nl[SDH].n_value, 0);
341: read(fc, dz_tty, sizeof(dz_tty));
342: for (tp = dz_tty; tp < &dz_tty[ndz]; tp++)
343: ttyprt(tp, tp - dz_tty);
344: }
345:
346: ttyprt(atp, line)
347: struct tty *atp;
348: {
349: register struct tty *tp;
350:
351: printf("%2d", line);
352: tp = atp;
353: switch (tp->t_line) {
354:
355: case NETLDISC:
356: if (tp->t_rec)
357: printf("%4d%4d", 0, tp->t_inbuf);
358: else
359: printf("%4d%4d", tp->t_inbuf, 0);
360: break;
361:
362: default:
363: printf("%4d", tp->t_rawq.c_cc);
364: printf("%4d", tp->t_canq.c_cc);
365: }
366: printf("%4d", tp->t_outq.c_cc);
367: printf("%8.1o", tp->t_flags);
368: printf(" %8.1x", tp->t_addr);
369: printf("%3d", tp->t_delct);
370: printf("%4d ", tp->t_col);
371: putf(tp->t_state&TIMEOUT, 'T');
372: putf(tp->t_state&WOPEN, 'W');
373: putf(tp->t_state&ISOPEN, 'O');
374: putf(tp->t_state&CARR_ON, 'C');
375: putf(tp->t_state&BUSY, 'B');
376: putf(tp->t_state&ASLEEP, 'A');
377: putf(tp->t_state&XCLUDE, 'X');
378: /*
379: putf(tp->t_state&HUPCLS, 'H');
380: */
381: printf("%6d", tp->t_pgrp);
382: switch (tp->t_line) {
383:
384: case NTTYDISC:
385: printf(" ntty");
386: break;
387:
388: case NETLDISC:
389: printf(" net");
390: break;
391: }
392: printf("\n");
393: }
394:
395: dousr()
396: {
397: struct user U;
398: register i, j, *ip;
399:
400: /* This wins only if PAGSIZ > sizeof (struct user) */
401: lseek(fc, ubase * NBPG, 0);
402: read(fc, &U, sizeof(U));
403: printf("pcb");
404: ip = (int *)&U.u_pcb;
405: while (ip < &U.u_arg[0]) {
406: if ((ip - (int *)&U.u_pcb) % 4 == 0)
407: printf("\t");
408: printf("%x ", *ip++);
409: if ((ip - (int *)&U.u_pcb) % 4 == 0)
410: printf("\n");
411: }
412: if ((ip - (int *)&U.u_pcb) % 4 != 0)
413: printf("\n");
414: printf("arg\t");
415: for (i=0; i<5; i++)
416: printf(" %.1x", U.u_arg[i]);
417: printf("\n");
418: for (i=0; i<sizeof(label_t)/sizeof(int); i++) {
419: if (i%5==0)
420: printf("\t");
421: printf("%9.1x", U.u_ssav[i]);
422: if (i%5==4)
423: printf("\n");
424: }
425: if (i%5)
426: printf("\n");
427: printf("segflg\t%d\nerror %d\n", U.u_segflg, U.u_error);
428: printf("uids\t%d,%d,%d,%d\n", U.u_uid,U.u_gid,U.u_ruid,U.u_rgid);
429: printf("procp\t%.1x\n", U.u_procp);
430: printf("ap\t%.1x\n", U.u_ap);
431: printf("r_val?\t%.1x %.1x\n", U.u_r.r_val1, U.u_r.r_val2);
432: printf("base, count, offset %.1x %.1x %ld\n", U.u_base,
433: U.u_count, U.u_offset);
434: printf("cdir rdir %.1x %.1x\n", U.u_cdir, U.u_rdir);
435: printf("dbuf %.14s\n", U.u_dbuf);
436: printf("dirp %.1x\n", U.u_dirp);
437: printf("dent %d %.14s\n", U.u_dent.d_ino, U.u_dent.d_name);
438: printf("pdir %.1o\n", U.u_pdir);
439: printf("file\t");
440: for (i=0; i<10; i++)
441: printf("%9.1x", U.u_ofile[i]);
442: printf("\n\t");
443: for (i=10; i<NOFILE; i++)
444: printf("%9.1x", U.u_ofile[i]);
445: printf("\n");
446: printf("pofile\t");
447: for (i=0; i<10; i++)
448: printf("%9.1x", U.u_pofile[i]);
449: printf("\n\t");
450: for (i=10; i<NOFILE; i++)
451: printf("%9.1x", U.u_pofile[i]);
452: printf("\n");
453: printf("ssav");
454: for (i=0; i<sizeof(label_t)/sizeof(int); i++) {
455: if (i%5==0)
456: printf("\t");
457: printf("%9.1x", U.u_ssav[i]);
458: if (i%5==4)
459: printf("\n");
460: }
461: if (i%5)
462: printf("\n");
463: printf("sigs\t");
464: for (i=0; i<NSIG; i++)
465: printf("%.1x ", U.u_signal[i]);
466: printf("\n");
467: printf("cfcode\t%.1x\n", U.u_cfcode);
468: printf("ar0\t%.1x\n", U.u_ar0);
469: printf("prof\t%X %X %X %X\n", U.u_prof.pr_base, U.u_prof.pr_size,
470: U.u_prof.pr_off, U.u_prof.pr_scale);
471: printf("\neosys\t%d\n", U.u_eosys);
472: printf("sep\t%d\n", U.u_sep);
473: printf("ttyp\t%.1x\n", U.u_ttyp);
474: printf("ttyd\t%d,%d\n", major(U.u_ttyd), minor(U.u_ttyd));
475: printf("exdata\t");
476: ip = (int *)&U.u_exdata;
477: for (i = 0; i < 8; i++)
478: printf("%.1D ", *ip++);
479: printf("\n");
480: printf("comm %.14s\n", U.u_comm);
481: printf("start\t%D\n", U.u_start);
482: printf("acflag\t%D\n", U.u_acflag);
483: printf("fpflag\t%D\n", U.u_fpflag);
484: printf("cmask\t%D\n", U.u_cmask);
485: printf("sizes\t%.1x %.1x %.1x\n", U.u_tsize, U.u_dsize, U.u_ssize);
486: printf("vm\t");
487: ip = (int *)&U.u_vm;
488: for (i = 0; i < sizeof(U.u_vm)/sizeof(int); i++)
489: printf("%D ", ip[i]);
490: printf("\n");
491: ip = (int *)&U.u_cvm;
492: printf("cvm\t");
493: for (i = 0; i < sizeof(U.u_vm)/sizeof(int); i++)
494: printf("%D ", ip[i]);
495: printf("\n");
496: /*
497: i = U.u_stack - &U;
498: while (U[++i] == 0);
499: i &= ~07;
500: while (i < 512) {
501: printf("%x ", 0140000+2*i);
502: for (j=0; j<8; j++)
503: printf("%9x", U[i++]);
504: printf("\n");
505: }
506: */
507: }
508:
509: oatoi(s)
510: char *s;
511: {
512: register v;
513:
514: v = 0;
515: while (*s)
516: v = (v<<3) + *s++ - '0';
517: return(v);
518: }
519:
520: dofil()
521: {
522: struct file xfile[NFILE];
523: register struct file *fp;
524: register nf;
525: int loc;
526:
527: nf = 0;
528: lseek(fc, (long)nl[SFIL].n_value, 0);
529: read(fc, xfile, sizeof(xfile));
530: for (fp=xfile; fp < &xfile[NFILE]; fp++)
531: if (fp->f_count)
532: nf++;
533: if (totflg) {
534: printf("%3d/%3d files\n", nf, NFILE);
535: return;
536: }
537: printf("%d/%d open files\n", nf, NFILE);
538: printf(" LOC FLG CNT INO OFFS\n");
539: for (fp=xfile,loc=nl[SFIL].n_value; fp < &xfile[NFILE]; fp++,loc+=sizeof(xfile[0])) {
540: if (fp->f_count==0)
541: continue;
542: printf("%8x ", loc);
543: putf(fp->f_flag&FREAD, 'R');
544: putf(fp->f_flag&FWRITE, 'W');
545: putf(fp->f_flag&FPIPE, 'P');
546: printf("%4d", mask(fp->f_count));
547: printf("%9.1x", fp->f_inode);
548: printf(" %ld\n", fp->f_un.f_offset);
549: }
550: }
551:
552: doswap()
553: {
554: struct proc proc[NPROC];
555: struct text xtext[NTEXT];
556: struct map swapmap[SMAPSIZ];
557: register struct proc *pp;
558: int nswap, used, tused, free;
559: register struct map *mp;
560: register struct text *xp;
561:
562: lseek(fc, (long)nl[SPROC].n_value, 0);
563: read(fc, proc, sizeof(proc));
564: lseek(fc, (long)nl[SWAPMAP].n_value, 0);
565: read(fc, swapmap, sizeof(swapmap));
566: lseek(fc, (long)nl[SNSWAP].n_value, 0);
567: read(fc, &nswap, sizeof(nswap));
568: free = 0;
569: for (mp = swapmap; mp < &swapmap[SMAPSIZ]; mp++)
570: free += mp->m_size;
571: lseek(fc, (long)nl[STEXT].n_value, 0);
572: read(fc, xtext, sizeof(xtext));
573: tused = 0;
574: for (xp = xtext; xp < &xtext[NTEXT]; xp++)
575: if (xp->x_iptr!=NULL)
576: tused += xdsize(xp);
577: used = tused;
578: for (pp = proc; pp < &proc[NPROC]; pp++) {
579: if (pp->p_stat == 0 || pp->p_stat == SZOMB)
580: continue;
581: if (pp->p_flag & SSYS)
582: continue;
583: used += up(pp->p_dsize) + up(pp->p_ssize);
584: if ((pp->p_flag&SLOAD) == 0)
585: used += vusize(pp);
586: }
587: /* a DMMAX block goes to argmap */
588: if (totflg) {
589: printf("%3d/%3d 00k swap\n", used/2/100, (used+free)/2/100);
590: return;
591: }
592: printf("%d used (%d text), %d free, %d missing\n",
593: used/2, tused/2, free/2, (nswap - DMMAX - (used + free))/2);
594: }
595:
596: up(size)
597: register int size;
598: {
599: register int i, block;
600:
601: i = 0;
602: block = DMMIN;
603: while (i < size) {
604: i += block;
605: if (block < DMMAX)
606: block *= 2;
607: }
608: return (i);
609: }
610:
611: vusize(p)
612: struct proc *p;
613: {
614: register int tsz = p->p_tsize / NPTEPG;
615:
616: return (clrnd(UPAGES + clrnd(ctopt(p->p_tsize+p->p_dsize+p->p_ssize+UPAGES)) - tsz));
617: }
618:
619: xdsize(xp)
620: struct text *xp;
621: {
622:
623: if (xp->x_flag & XPAGI)
624: return (clrnd(xp->x_size + ctopt(xp->x_size)));
625: return (xp->x_size);
626: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.