projects / unix-history / blame
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
set WOPEN on first open
[unix-history] / usr / src / usr.bin / vmstat / vmstat.c
CommitLineData
f42904bc 1/*
01c8685d
KB		 2 * Copyright (c) 1980 The Regents of the University of California.
3 * All rights reserved.
4 *
32ce521f 5 * %sccs.include.redist.c%
f42904bc
DF		 6 */
7
8#ifndef lint
9char copyright[] =
01c8685d 10"@(#) Copyright (c) 1980 The Regents of the University of California.\n\
f42904bc 11 All rights reserved.\n";
01c8685d 12#endif /* not lint */
f42904bc 13
338c4a5d 14#ifndef lint
32ce521f 15static char sccsid[] = "@(#)vmstat.c 5.20 (Berkeley) %G%";
01c8685d 16#endif /* not lint */
338c4a5d 17
7f02df2f 18#include <sys/param.h>
a448353a 19#include <sys/file.h>
7f02df2f 20#include <sys/vm.h>
920a4346 21#include <sys/dkstat.h>
61d7d2b3 22#include <sys/buf.h>
4b894a2c 23#include <sys/namei.h>
242684ee 24#include <sys/text.h>
0c429495 25#include <sys/malloc.h>
f5506e0f
KB		 26#include <stdio.h>
27#include <ctype.h>
28#include <nlist.h>
29#include <paths.h>
7f02df2f
BJ		 30
31struct nlist nl[] = {
682f1dcb
BJ		 32#define X_CPTIME 0
33 { "_cp_time" },
34#define X_RATE 1
7f02df2f 35 { "_rate" },
682f1dcb 36#define X_TOTAL 2
7f02df2f 37 { "_total" },
682f1dcb 38#define X_DEFICIT 3
7f02df2f 39 { "_deficit" },
682f1dcb 40#define X_FORKSTAT 4
7f02df2f 41 { "_forkstat" },
682f1dcb 42#define X_SUM 5
7f02df2f 43 { "_sum" },
682f1dcb 44#define X_FIRSTFREE 6
7f02df2f 45 { "_firstfree" },
682f1dcb 46#define X_MAXFREE 7
7f02df2f 47 { "_maxfree" },
a43be079
SL		 48#define X_BOOTTIME 8
49 { "_boottime" },
682f1dcb
BJ		 50#define X_DKXFER 9
51 { "_dk_xfer" },
338c4a5d 52#define X_REC 10
7f02df2f 53 { "_rectime" },
338c4a5d 54#define X_PGIN 11
7f02df2f 55 { "_pgintime" },
338c4a5d 56#define X_HZ 12
61d7d2b3 57 { "_hz" },
a448353a 58#define X_PHZ 13
b3a37270 59 { "_phz" },
dfdfb4c8
KM		 60#define X_NCHSTATS 14
61 { "_nchstats" },
4b894a2c
KM		 62#define X_INTRNAMES 15
63 { "_intrnames" },
64#define X_EINTRNAMES 16
65 { "_eintrnames" },
66#define X_INTRCNT 17
67 { "_intrcnt" },
68#define X_EINTRCNT 18
69 { "_eintrcnt" },
a448353a
SL		 70#define X_DK_NDRIVE 19
71 { "_dk_ndrive" },
b6b10463
SL		 72#define X_XSTATS 20
73 { "_xstats" },
0c429495
KM		 74#define X_KMEMSTAT 21
75 { "_kmemstats" },
76#define X_KMEMBUCKETS 22
77 { "_bucket" },
338c4a5d 78#ifdef vax
242684ee 79#define X_MBDINIT (X_XSTATS+1)
338c4a5d 80 { "_mbdinit" },
242684ee 81#define X_UBDINIT (X_XSTATS+2)
338c4a5d 82 { "_ubdinit" },
242684ee 83#endif
242684ee
SL		 84#ifdef tahoe
85#define X_VBDINIT (X_XSTATS+1)
86 { "_vbdinit" },
7aa7d88f
SL		 87#define X_CKEYSTATS (X_XSTATS+2)
88 { "_ckeystats" },
89#define X_DKEYSTATS (X_XSTATS+3)
90 { "_dkeystats" },
338c4a5d
SL		 91#endif
92 { "" },
7f02df2f
BJ		 93};
94
a448353a
SL		 95char **dr_name;
96int *dr_select;
97int dk_ndrive;
98int ndrives = 0;
99#ifdef vax
100char *defdrives[] = { "hp0", "hp1", "hp2", 0 };
101#else
102char *defdrives[] = { 0 };
103#endif
7f02df2f
BJ		 104double stat1();
105int firstfree, maxfree;
61d7d2b3 106int hz;
b3a37270
SL		 107int phz;
108int HZ;
a448353a 109
a448353a 110struct {
7f02df2f 111 int busy;
682f1dcb 112 long time[CPUSTATES];
a448353a 113 long *xfer;
7f02df2f
BJ		 114 struct vmmeter Rate;
115 struct vmtotal Total;
116 struct vmmeter Sum;
117 struct forkstat Forkstat;
7f02df2f
BJ		 118 unsigned rectime;
119 unsigned pgintime;
7f02df2f
BJ		 120} s, s1, z;
121#define rate s.Rate
122#define total s.Total
123#define sum s.Sum
124#define forkstat s.Forkstat
125
338c4a5d 126struct vmmeter osum;
7f02df2f
BJ		 127int deficit;
128double etime;
129int mf;
4b894a2c
KM		 130time_t now, boottime;
131int printhdr();
196ccf10 132int lines = 1;
7f02df2f 133
920a4346
SL		 134#define INTS(x) ((x) - (hz + phz))
135
7f02df2f 136main(argc, argv)
338c4a5d
SL		 137 int argc;
138 char **argv;
7f02df2f 139{
7f02df2f 140 extern char *ctime();
920a4346 141 register i;
4b894a2c 142 int iter, nintv, iflag = 0;
7f02df2f 143 long t;
920a4346 144 char *arg, **cp, buf[BUFSIZ];
7f02df2f 145
f5506e0f 146 nlist(_PATH_UNIX, nl);
7f02df2f 147 if(nl[0].n_type == 0) {
f5506e0f 148 fprintf(stderr, "vmstat: no %s namelist\n", _PATH_UNIX);
7f02df2f
BJ		 149 exit(1);
150 }
f5506e0f 151 mf = open(_PATH_KMEM, 0);
7f02df2f 152 if(mf < 0) {
f5506e0f 153 fprintf(stderr, "vmstat: cannot open %s\n", _PATH_KMEM);
7f02df2f
BJ		 154 exit(1);
155 }
156 iter = 0;
157 argc--, argv++;
158 while (argc>0 && argv[0][0]=='-') {
159 char *cp = *argv++;
160 argc--;
161 while (*++cp) switch (*cp) {
162
7f02df2f
BJ		 163 case 't':
164 dotimes();
165 exit(0);
338c4a5d 166
7f02df2f
BJ		 167 case 'z':
168 close(mf);
f5506e0f 169 mf = open(_PATH_KMEM, 2);
a448353a 170 lseek(mf, (long)nl[X_SUM].n_value, L_SET);
7f02df2f
BJ		 171 write(mf, &z.Sum, sizeof z.Sum);
172 exit(0);
173
174 case 'f':
175 doforkst();
176 exit(0);
177
0c429495
KM		 178 case 'm':
179 domem();
180 exit(0);
181
7f02df2f
BJ		 182 case 's':
183 dosum();
184 exit(0);
185
4b894a2c
KM		 186 case 'i':
187 iflag++;
188 break;
189
7f02df2f 190 default:
a448353a 191 fprintf(stderr,
0c429495 192 "usage: vmstat [ -fsim ] [ interval ] [ count]\n");
7f02df2f
BJ		 193 exit(1);
194 }
195 }
a448353a 196 lseek(mf, (long)nl[X_FIRSTFREE].n_value, L_SET);
7f02df2f 197 read(mf, &firstfree, sizeof firstfree);
a448353a 198 lseek(mf, (long)nl[X_MAXFREE].n_value, L_SET);
7f02df2f 199 read(mf, &maxfree, sizeof maxfree);
a448353a 200 lseek(mf, (long)nl[X_BOOTTIME].n_value, L_SET);
a43be079 201 read(mf, &boottime, sizeof boottime);
a448353a 202 lseek(mf, (long)nl[X_HZ].n_value, L_SET);
61d7d2b3 203 read(mf, &hz, sizeof hz);
a448353a
SL		 204 if (nl[X_PHZ].n_value != 0) {
205 lseek(mf, (long)nl[X_PHZ].n_value, L_SET);
206 read(mf, &phz, sizeof phz);
207 }
b3a37270 208 HZ = phz ? phz : hz;
9a122ff6 209 if (nl[X_DK_NDRIVE].n_value == 0) {
920a4346 210 fprintf(stderr, "dk_ndrive undefined in system\n");
a448353a
SL		 211 exit(1);
212 }
213 lseek(mf, nl[X_DK_NDRIVE].n_value, L_SET);
214 read(mf, &dk_ndrive, sizeof (dk_ndrive));
215 if (dk_ndrive <= 0) {
920a4346 216 fprintf(stderr, "dk_ndrive %d\n", dk_ndrive);
a448353a
SL		 217 exit(1);
218 }
219 dr_select = (int *)calloc(dk_ndrive, sizeof (int));
220 dr_name = (char **)calloc(dk_ndrive, sizeof (char *));
221#define allocate(e, t) \
222 s./**/e = (t *)calloc(dk_ndrive, sizeof (t)); \
223 s1./**/e = (t *)calloc(dk_ndrive, sizeof (t));
224 allocate(xfer, long);
225 for (arg = buf, i = 0; i < dk_ndrive; i++) {
226 dr_name[i] = arg;
227 sprintf(dr_name[i], "dk%d", i);
228 arg += strlen(dr_name[i]) + 1;
61d7d2b3
MT		 229 }
230 read_names();
7f02df2f 231 time(&now);
a43be079 232 nintv = now - boottime;
7f02df2f 233 if (nintv <= 0 || nintv > 60*60*24*365*10) {
920a4346
SL		 234 fprintf(stderr,
235 "Time makes no sense... namelist must be wrong.\n");
7f02df2f
BJ		 236 exit(1);
237 }
4b894a2c
KM		 238 if (iflag) {
239 dointr(nintv);
240 exit(0);
241 }
a448353a
SL		 242 /*
243 * Choose drives to be displayed. Priority
244 * goes to (in order) drives supplied as arguments,
245 * default drives. If everything isn't filled
246 * in and there are drives not taken care of,
247 * display the first few that fit.
248 */
249 ndrives = 0;
250 while (argc > 0 && !isdigit(argv[0][0])) {
251 for (i = 0; i < dk_ndrive; i++) {
252 if (strcmp(dr_name[i], argv[0]))
253 continue;
254 dr_select[i] = 1;
255 ndrives++;
256 }
257 argc--, argv++;
258 }
259 for (i = 0; i < dk_ndrive && ndrives < 4; i++) {
260 if (dr_select[i])
261 continue;
262 for (cp = defdrives; *cp; cp++)
263 if (strcmp(dr_name[i], *cp) == 0) {
264 dr_select[i] = 1;
265 ndrives++;
266 break;
267 }
268 }
269 for (i = 0; i < dk_ndrive && ndrives < 4; i++) {
270 if (dr_select[i])
271 continue;
272 dr_select[i] = 1;
273 ndrives++;
274 }
275 if (argc > 1)
276 iter = atoi(argv[1]);
4b894a2c 277 signal(SIGCONT, printhdr);
7f02df2f 278loop:
196ccf10
SL		 279 if (--lines == 0)
280 printhdr();
a448353a 281 lseek(mf, (long)nl[X_CPTIME].n_value, L_SET);
682f1dcb 282 read(mf, s.time, sizeof s.time);
a448353a
SL		 283 lseek(mf, (long)nl[X_DKXFER].n_value, L_SET);
284 read(mf, s.xfer, dk_ndrive * sizeof (long));
285 if (nintv != 1)
286 lseek(mf, (long)nl[X_SUM].n_value, L_SET);
287 else
288 lseek(mf, (long)nl[X_RATE].n_value, L_SET);
289 read(mf, &rate, sizeof rate);
290 lseek(mf, (long)nl[X_TOTAL].n_value, L_SET);
7f02df2f 291 read(mf, &total, sizeof total);
338c4a5d 292 osum = sum;
a448353a 293 lseek(mf, (long)nl[X_SUM].n_value, L_SET);
338c4a5d 294 read(mf, &sum, sizeof sum);
a448353a 295 lseek(mf, (long)nl[X_DEFICIT].n_value, L_SET);
7f02df2f 296 read(mf, &deficit, sizeof deficit);
682f1dcb 297 etime = 0;
a448353a 298 for (i=0; i < dk_ndrive; i++) {
682f1dcb
BJ		 299 t = s.xfer[i];
300 s.xfer[i] -= s1.xfer[i];
301 s1.xfer[i] = t;
7f02df2f
BJ		 302 }
303 for (i=0; i < CPUSTATES; i++) {
682f1dcb
BJ		 304 t = s.time[i];
305 s.time[i] -= s1.time[i];
306 s1.time[i] = t;
307 etime += s.time[i];
7f02df2f 308 }
7f02df2f
BJ		 309 if(etime == 0.)
310 etime = 1.;
61d7d2b3 311 printf("%2d%2d%2d", total.t_rq, total.t_dw+total.t_pw, total.t_sw);
338c4a5d 312#define pgtok(a) ((a)*NBPG/1024)
920a4346 313 printf("%6d%6d", pgtok(total.t_avm), pgtok(total.t_free));
b3a37270
SL		 314 printf("%4d%3d", (rate.v_pgrec - (rate.v_xsfrec+rate.v_xifrec))/nintv,
315 (rate.v_xsfrec+rate.v_xifrec)/nintv);
338c4a5d
SL		 316 printf("%4d", pgtok(rate.v_pgpgin)/nintv);
317 printf("%4d%4d%4d%4d", pgtok(rate.v_pgpgout)/nintv,
318 pgtok(rate.v_dfree)/nintv, pgtok(deficit), rate.v_scan/nintv);
a448353a
SL		 319 etime /= (float)HZ;
320 for (i = 0; i < dk_ndrive; i++)
321 if (dr_select[i])
322 stats(i);
b3a37270
SL		 323 printf("%4d%4d%4d", INTS(rate.v_intr/nintv), rate.v_syscall/nintv,
324 rate.v_swtch/nintv);
7f02df2f
BJ		 325 for(i=0; i<CPUSTATES; i++) {
326 float f = stat1(i);
327 if (i == 0) { /* US+NI */
328 i++;
329 f += stat1(i);
330 }
331 printf("%3.0f", f);
332 }
333 printf("\n");
334 fflush(stdout);
7f02df2f 335 nintv = 1;
196ccf10 336 if (--iter &&argc > 0) {
7f02df2f 337 sleep(atoi(argv[0]));
7f02df2f
BJ		 338 goto loop;
339 }
340}
341
4b894a2c
KM		 342printhdr()
343{
a448353a
SL		 344 register int i, j;
345
920a4346 346 printf(" procs memory page ");
a448353a
SL		 347 i = (ndrives * 3 - 6) / 2;
348 if (i < 0)
349 i = 0;
350 for (j = 0; j < i; j++)
351 putchar(' ');
352 printf("faults");
353 i = ndrives * 3 - 6 - i;
354 for (j = 0; j < i; j++)
355 putchar(' ');
356 printf(" cpu\n");
920a4346 357 printf(" r b w avm fre re at pi po fr de sr ");
a448353a
SL		 358 for (i = 0; i < dk_ndrive; i++)
359 if (dr_select[i])
360 printf("%c%c ", dr_name[i][0], dr_name[i][2]);
361 printf(" in sy cs us sy id\n");
196ccf10 362 lines = 19;
4b894a2c
KM		 363}
364
7f02df2f
BJ		 365dotimes()
366{
367
a448353a 368 lseek(mf, (long)nl[X_REC].n_value, L_SET);
7f02df2f 369 read(mf, &s.rectime, sizeof s.rectime);
a448353a 370 lseek(mf, (long)nl[X_PGIN].n_value, L_SET);
7f02df2f 371 read(mf, &s.pgintime, sizeof s.pgintime);
a448353a 372 lseek(mf, (long)nl[X_SUM].n_value, L_SET);
7f02df2f
BJ		 373 read(mf, &sum, sizeof sum);
374 printf("%d reclaims, %d total time (usec)\n", sum.v_pgrec, s.rectime);
375 printf("average: %d usec / reclaim\n", s.rectime/sum.v_pgrec);
376 printf("\n");
377 printf("%d page ins, %d total time (msec)\n",sum.v_pgin, s.pgintime/10);
378 printf("average: %8.1f msec / page in\n", s.pgintime/(sum.v_pgin*10.0));
379}
7f02df2f 380
70b78b6e
SL		 381#if defined(tahoe)
382#include <tahoe/cpu.h>
383#endif
384
7f02df2f
BJ		 385dosum()
386{
a448353a 387 struct nchstats nchstats;
7aa7d88f 388 struct xstats xstats;
dfdfb4c8 389 long nchtotal;
7aa7d88f
SL		 390#if defined(tahoe)
391 struct keystats keystats;
392#endif
7f02df2f 393
a448353a 394 lseek(mf, (long)nl[X_SUM].n_value, L_SET);
7f02df2f
BJ		 395 read(mf, &sum, sizeof sum);
396 printf("%9d swap ins\n", sum.v_swpin);
397 printf("%9d swap outs\n", sum.v_swpout);
398 printf("%9d pages swapped in\n", sum.v_pswpin / CLSIZE);
399 printf("%9d pages swapped out\n", sum.v_pswpout / CLSIZE);
400 printf("%9d total address trans. faults taken\n", sum.v_faults);
401 printf("%9d page ins\n", sum.v_pgin);
402 printf("%9d page outs\n", sum.v_pgout);
513dfff1
BJ		 403 printf("%9d pages paged in\n", sum.v_pgpgin);
404 printf("%9d pages paged out\n", sum.v_pgpgout);
405 printf("%9d sequential process pages freed\n", sum.v_seqfree);
e23f616a 406 printf("%9d total reclaims (%d%% fast)\n", sum.v_pgrec,
920a4346 407 pct(sum.v_fastpgrec, sum.v_pgrec));
7f02df2f
BJ		 408 printf("%9d reclaims from free list\n", sum.v_pgfrec);
409 printf("%9d intransit blocking page faults\n", sum.v_intrans);
410 printf("%9d zero fill pages created\n", sum.v_nzfod / CLSIZE);
411 printf("%9d zero fill page faults\n", sum.v_zfod / CLSIZE);
412 printf("%9d executable fill pages created\n", sum.v_nexfod / CLSIZE);
413 printf("%9d executable fill page faults\n", sum.v_exfod / CLSIZE);
414 printf("%9d swap text pages found in free list\n", sum.v_xsfrec);
415 printf("%9d inode text pages found in free list\n", sum.v_xifrec);
416 printf("%9d file fill pages created\n", sum.v_nvrfod / CLSIZE);
417 printf("%9d file fill page faults\n", sum.v_vrfod / CLSIZE);
418 printf("%9d pages examined by the clock daemon\n", sum.v_scan);
419 printf("%9d revolutions of the clock hand\n", sum.v_rev);
420 printf("%9d pages freed by the clock daemon\n", sum.v_dfree / CLSIZE);
421 printf("%9d cpu context switches\n", sum.v_swtch);
422 printf("%9d device interrupts\n", sum.v_intr);
4b894a2c 423 printf("%9d software interrupts\n", sum.v_soft);
a448353a 424#ifdef vax
3d61d7ac 425 printf("%9d pseudo-dma dz interrupts\n", sum.v_pdma);
a448353a 426#endif
7f02df2f
BJ		 427 printf("%9d traps\n", sum.v_trap);
428 printf("%9d system calls\n", sum.v_syscall);
dfdfb4c8 429 lseek(mf, (long)nl[X_NCHSTATS].n_value, 0);
a448353a 430 read(mf, &nchstats, sizeof nchstats);
3aea8979
KM		 431 nchtotal = nchstats.ncs_goodhits + nchstats.ncs_neghits +
432 nchstats.ncs_badhits + nchstats.ncs_falsehits +
433 nchstats.ncs_miss + nchstats.ncs_long;
434 printf("%9d total name lookups\n", nchtotal);
435 printf("%9s cache hits (%d%% pos + %d%% neg) system %d%% per-process\n",
436 "", pct(nchstats.ncs_goodhits, nchtotal),
437 pct(nchstats.ncs_neghits, nchtotal),
920a4346 438 pct(nchstats.ncs_pass2, nchtotal));
3aea8979
KM		 439 printf("%9s deletions %d%%, falsehits %d%%, toolong %d%%\n", "",
440 pct(nchstats.ncs_badhits, nchtotal),
441 pct(nchstats.ncs_falsehits, nchtotal),
442 pct(nchstats.ncs_long, nchtotal));
b6b10463
SL		 443 lseek(mf, (long)nl[X_XSTATS].n_value, 0);
444 read(mf, &xstats, sizeof xstats);
445 printf("%9d total calls to xalloc (cache hits %d%%)\n",
920a4346 446 xstats.alloc, pct(xstats.alloc_cachehit, xstats.alloc));
b6b10463
SL		 447 printf("%9s sticky %d flushed %d unused %d\n", "",
448 xstats.alloc_inuse, xstats.alloc_cacheflush, xstats.alloc_unused);
449 printf("%9d total calls to xfree", xstats.free);
450 printf(" (sticky %d cached %d swapped %d)\n",
451 xstats.free_inuse, xstats.free_cache, xstats.free_cacheswap);
7aa7d88f
SL		 452#if defined(tahoe)
453 lseek(mf, (long)nl[X_CKEYSTATS].n_value, 0);
454 read(mf, &keystats, sizeof keystats);
455 printf("%9d %s (free %d%% norefs %d%% taken %d%% shared %d%%)\n",
456 keystats.ks_allocs, "code cache keys allocated",
0c429495 457 pct(keystats.ks_allocfree, keystats.ks_allocs),
920a4346
SL		 458 pct(keystats.ks_norefs, keystats.ks_allocs),
459 pct(keystats.ks_taken, keystats.ks_allocs),
460 pct(keystats.ks_shared, keystats.ks_allocs));
7aa7d88f
SL		 461 lseek(mf, (long)nl[X_DKEYSTATS].n_value, 0);
462 read(mf, &keystats, sizeof keystats);
463 printf("%9d %s (free %d%% norefs %d%% taken %d%% shared %d%%)\n",
464 keystats.ks_allocs, "data cache keys allocated",
0c429495 465 pct(keystats.ks_allocfree, keystats.ks_allocs),
920a4346
SL		 466 pct(keystats.ks_norefs, keystats.ks_allocs),
467 pct(keystats.ks_taken, keystats.ks_allocs),
468 pct(keystats.ks_shared, keystats.ks_allocs));
7aa7d88f 469#endif
7f02df2f
BJ		 470}
471
7f02df2f
BJ		 472doforkst()
473{
474
a448353a 475 lseek(mf, (long)nl[X_FORKSTAT].n_value, L_SET);
7f02df2f
BJ		 476 read(mf, &forkstat, sizeof forkstat);
477 printf("%d forks, %d pages, average=%.2f\n",
478 forkstat.cntfork, forkstat.sizfork,
479 (float) forkstat.sizfork / forkstat.cntfork);
480 printf("%d vforks, %d pages, average=%.2f\n",
481 forkstat.cntvfork, forkstat.sizvfork,
482 (float)forkstat.sizvfork / forkstat.cntvfork);
483}
484
485stats(dn)
486{
487
a448353a 488 if (dn >= dk_ndrive) {
7f02df2f
BJ		 489 printf(" 0");
490 return;
491 }
682f1dcb 492 printf("%3.0f", s.xfer[dn]/etime);
7f02df2f
BJ		 493}
494
495double
496stat1(row)
497{
682f1dcb
BJ		 498 double t;
499 register i;
7f02df2f
BJ		 500
501 t = 0;
502 for(i=0; i<CPUSTATES; i++)
682f1dcb
BJ		 503 t += s.time[i];
504 if(t == 0.)
505 t = 1.;
506 return(s.time[row]*100./t);
7f02df2f
BJ		 507}
508
509pct(top, bot)
510{
511
512 if (bot == 0)
513 return (0);
514 return ((top * 100) / bot);
515}
61d7d2b3 516
4b894a2c
KM		 517dointr(nintv)
518{
519 int nintr, inttotal;
520 long *intrcnt;
521 char *intrname, *malloc();
522
523 nintr = (nl[X_EINTRCNT].n_value - nl[X_INTRCNT].n_value) / sizeof(long);
524 intrcnt = (long *) malloc(nl[X_EINTRCNT].n_value -
525 nl[X_INTRCNT].n_value);
526 intrname = malloc(nl[X_EINTRNAMES].n_value - nl[X_INTRNAMES].n_value);
527 if (intrcnt == NULL || intrname == NULL) {
528 fprintf(stderr, "vmstat: out of memory\n");
529 exit(9);
530 }
a448353a 531 lseek(mf, (long)nl[X_INTRCNT].n_value, L_SET);
4b894a2c 532 read(mf, intrcnt, nintr * sizeof (long));
a448353a 533 lseek(mf, (long)nl[X_INTRNAMES].n_value, L_SET);
4b894a2c
KM		 534 read(mf, intrname, nl[X_EINTRNAMES].n_value - nl[X_INTRNAMES].n_value);
535 printf("interrupt total rate\n");
536 inttotal = 0;
537 while (nintr--) {
538 if (*intrcnt)
539 printf("%-12s %8ld %8ld\n", intrname,
540 *intrcnt, *intrcnt / nintv);
541 intrname += strlen(intrname) + 1;
542 inttotal += *intrcnt++;
543 }
544 printf("Total %8ld %8ld\n", inttotal, inttotal / nintv);
545}
546
0c429495
KM		 547/*
548 * These names must be kept in sync with
549 * the types defined in <sys/malloc.h>.
550 */
551char *kmemnames[] = {
e268bd95
MT		 552 "free", /* 0 M_FREE */
553 "mbuf", /* 1 M_MBUF */
554 "devbuf", /* 2 M_DEVBUF */
555 "socket", /* 3 M_SOCKET */
556 "pcb", /* 4 M_PCB */
557 "routetbl", /* 5 M_RTABLE */
558 "hosttbl", /* 6 M_HTABLE */
559 "fragtbl", /* 7 M_FTABLE */
560 "zombie", /* 8 M_ZOMBIE */
561 "ifaddr", /* 9 M_IFADDR */
562 "soopts", /* 10 M_SOOPTS */
563 "soname", /* 11 M_SONAME */
564 "namei", /* 12 M_NAMEI */
565 "gprof", /* 13 M_GPROF */
566 "ioctlops", /* 14 M_IOCTLOPS */
567 "superblk", /* 15 M_SUPERBLK */
568 "cred", /* 16 M_CRED */
569 "pgrp", /* 17 M_PGRP */
570 "session", /* 18 M_SESSION */
d8a6e15a 571 "iov", /* 19 M_IOV */
b567dcea
KM		 572 "mount", /* 20 M_MOUNT */
573 "fhandle", /* 21 M_FHANDLE */
574 "NFS req", /* 22 M_NFSREQ */
575 "NFS mount", /* 23 M_NFSMNT */
9f8ba8ea
KM		 576 "vnodes", /* 24 M_VNODE */
577 "namecache", /* 25 M_CACHE */
fa230d07
KM		 578 "UFS quota", /* 26 M_DQUOT */
579 "UFS mount", /* 27 M_UFSMNT */
580 0,
e268bd95
MT		 581 0, 0, 0, 0, 0,
582 0, 0, 0, 0, 0,
583 0, 0, 0, 0, 0,
584 0, 0, 0, 0, 0,
e268bd95 585 "temp", /* 49 M_TEMP */
0c429495
KM		 586};
587
588domem()
589{
590 struct kmemstats kmemstats[M_LAST];
591 struct kmembuckets buckets[MINBUCKET + 16];
592 register struct kmembuckets *kp;
593 register struct kmemstats *ks;
594 int i;
595
596 lseek(mf, (long)nl[X_KMEMBUCKETS].n_value, L_SET);
597 read(mf, buckets, sizeof buckets);
598 printf("Memory statistics by bucket size\n");
599 printf(" Size In Use Free Requests HighWater Couldfree\n");
600 for (i = MINBUCKET, kp = &buckets[i]; i < MINBUCKET + 16; i++, kp++) {
601 if (kp->kb_calls == 0)
602 continue;
603 printf("%8d%9d%7d%11d%8d%11d\n", 1 << i,
604 kp->kb_total - kp->kb_totalfree,
605 kp->kb_totalfree, kp->kb_calls,
606 kp->kb_highwat, kp->kb_couldfree);
607
608 }
609 lseek(mf, (long)nl[X_KMEMSTAT].n_value, L_SET);
610 read(mf, kmemstats, sizeof kmemstats);
611 printf("Memory statistics by type\n");
612 printf(" Type In Use MemUse HighUse Limit Requests %s\n",
613 "TypeLimit KernLimit");
614 for (i = 0, ks = &kmemstats[0]; i < M_LAST; i++, ks++) {
615 if (ks->ks_calls == 0)
616 continue;
617 printf("%10s%7d%8dK%9dK%6dK%9d%7d%10d\n",
618 kmemnames[i] ? kmemnames[i] : "undefined",
619 ks->ks_inuse, (ks->ks_memuse + 1023) / 1024,
620 (ks->ks_maxused + 1023) / 1024,
621 (ks->ks_limit + 1023) / 1024, ks->ks_calls,
622 ks->ks_limblocks, ks->ks_mapblocks);
623 }
624}
625
a448353a
SL		 626#define steal(where, var) \
627 lseek(mf, where, L_SET); read(mf, &var, sizeof var);
61d7d2b3
MT		 628/*
629 * Read the drive names out of kmem.
61d7d2b3 630 */
338c4a5d 631#ifdef vax
a448353a
SL		 632#include <vaxuba/ubavar.h>
633#include <vaxmba/mbavar.h>
634
61d7d2b3
MT		 635read_names()
636{
637 struct mba_device mdev;
638 register struct mba_device *mp;
639 struct mba_driver mdrv;
640 short two_char;
641 char *cp = (char *) &two_char;
642 struct uba_device udev, *up;
643 struct uba_driver udrv;
644
645 mp = (struct mba_device *) nl[X_MBDINIT].n_value;
646 up = (struct uba_device *) nl[X_UBDINIT].n_value;
93ca0bfe 647 if (up == 0) {
338c4a5d 648 fprintf(stderr, "vmstat: Disk init info not in namelist\n");
61d7d2b3
MT		 649 exit(1);
650 }
93ca0bfe 651 if (mp) for (;;) {
61d7d2b3
MT		 652 steal(mp++, mdev);
653 if (mdev.mi_driver == 0)
654 break;
655 if (mdev.mi_dk < 0 || mdev.mi_alive == 0)
656 continue;
657 steal(mdev.mi_driver, mdrv);
658 steal(mdrv.md_dname, two_char);
a448353a
SL		 659 sprintf(dr_name[mdev.mi_dk], "%c%c%d",
660 cp[0], cp[1], mdev.mi_unit);
61d7d2b3 661 }
93ca0bfe 662 for (;;) {
61d7d2b3
MT		 663 steal(up++, udev);
664 if (udev.ui_driver == 0)
665 break;
666 if (udev.ui_dk < 0 || udev.ui_alive == 0)
667 continue;
668 steal(udev.ui_driver, udrv);
669 steal(udrv.ud_dname, two_char);
a448353a
SL		 670 sprintf(dr_name[udev.ui_dk], "%c%c%d",
671 cp[0], cp[1], udev.ui_unit);
61d7d2b3
MT		 672 }
673}
338c4a5d 674#endif
242684ee 675
242684ee
SL		 676#ifdef tahoe
677#include <tahoevba/vbavar.h>
678
679/*
680 * Read the drive names out of kmem.
681 */
682read_names()
683{
684 struct vba_device udev, *up;
685 struct vba_driver udrv;
686 short two_char;
687 char *cp = (char *)&two_char;
688
689 up = (struct vba_device *) nl[X_VBDINIT].n_value;
690 if (up == 0) {
691 fprintf(stderr, "vmstat: Disk init info not in namelist\n");
692 exit(1);
693 }
694 for (;;) {
695 steal(up++, udev);
696 if (udev.ui_driver == 0)
697 break;
698 if (udev.ui_dk < 0 || udev.ui_alive == 0)
699 continue;
700 steal(udev.ui_driver, udrv);
701 steal(udrv.ud_dname, two_char);
702 sprintf(dr_name[udev.ui_dk], "%c%c%d",
703 cp[0], cp[1], udev.ui_unit);
704 }
705}
706#endif
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.