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