1 /* $NetBSD: vmstat.c,v 1.82 2001/06/13 08:18:30 lukem Exp $ */ 2 3 /*- 4 * Copyright (c) 1998, 2000 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility, 9 * NASA Ames Research Center. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions and the following disclaimer. 16 * 2. Redistributions in binary form must reproduce the above copyright 17 * notice, this list of conditions and the following disclaimer in the 18 * documentation and/or other materials provided with the distribution. 19 * 3. All advertising materials mentioning features or use of this software 20 * must display the following acknowledgement: 21 * This product includes software developed by the NetBSD 22 * Foundation, Inc. and its contributors. 23 * 4. Neither the name of The NetBSD Foundation nor the names of its 24 * contributors may be used to endorse or promote products derived 25 * from this software without specific prior written permission. 26 * 27 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 28 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 29 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 31 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 37 * POSSIBILITY OF SUCH DAMAGE. 38 */ 39 40 /* 41 * Copyright (c) 1980, 1986, 1991, 1993 42 * The Regents of the University of California. All rights reserved. 43 * 44 * Redistribution and use in source and binary forms, with or without 45 * modification, are permitted provided that the following conditions 46 * are met: 47 * 1. Redistributions of source code must retain the above copyright 48 * notice, this list of conditions and the following disclaimer. 49 * 2. Redistributions in binary form must reproduce the above copyright 50 * notice, this list of conditions and the following disclaimer in the 51 * documentation and/or other materials provided with the distribution. 52 * 3. All advertising materials mentioning features or use of this software 53 * must display the following acknowledgement: 54 * This product includes software developed by the University of 55 * California, Berkeley and its contributors. 56 * 4. Neither the name of the University nor the names of its contributors 57 * may be used to endorse or promote products derived from this software 58 * without specific prior written permission. 59 * 60 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 61 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 62 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 63 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 64 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 65 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 66 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 67 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 68 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 69 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 70 * SUCH DAMAGE. 71 */ 72 73 #include <sys/cdefs.h> 74 #ifndef lint 75 __COPYRIGHT("@(#) Copyright (c) 1980, 1986, 1991, 1993\n\ 76 The Regents of the University of California. All rights reserved.\n"); 77 #endif /* not lint */ 78 79 #ifndef lint 80 #if 0 81 static char sccsid[] = "@(#)vmstat.c 8.2 (Berkeley) 3/1/95"; 82 #else 83 __RCSID("$NetBSD: vmstat.c,v 1.82 2001/06/13 08:18:30 lukem Exp $"); 84 #endif 85 #endif /* not lint */ 86 87 #define __POOL_EXPOSE 88 89 #include <sys/param.h> 90 #include <sys/time.h> 91 #include <sys/proc.h> 92 #include <sys/user.h> 93 #include <sys/dkstat.h> 94 #include <sys/buf.h> 95 #include <sys/namei.h> 96 #include <sys/malloc.h> 97 #include <sys/ioctl.h> 98 #include <sys/sched.h> 99 #include <sys/sysctl.h> 100 #include <sys/device.h> 101 #include <sys/pool.h> 102 103 #include <uvm/uvm_extern.h> 104 #include <uvm/uvm_stat.h> 105 106 #include <err.h> 107 #include <fcntl.h> 108 #include <time.h> 109 #include <nlist.h> 110 #include <kvm.h> 111 #include <errno.h> 112 #include <unistd.h> 113 #include <signal.h> 114 #include <stdio.h> 115 #include <ctype.h> 116 #include <stdlib.h> 117 #include <string.h> 118 #include <paths.h> 119 #include <limits.h> 120 #include "dkstats.h" 121 122 struct nlist namelist[] = { 123 #define X_BOOTTIME 0 124 { "_boottime" }, 125 #define X_HZ 1 126 { "_hz" }, 127 #define X_STATHZ 2 128 { "_stathz" }, 129 #define X_NCHSTATS 3 130 { "_nchstats" }, 131 #define X_INTRNAMES 4 132 { "_intrnames" }, 133 #define X_EINTRNAMES 5 134 { "_eintrnames" }, 135 #define X_INTRCNT 6 136 { "_intrcnt" }, 137 #define X_EINTRCNT 7 138 { "_eintrcnt" }, 139 #define X_KMEMSTAT 8 140 { "_kmemstats" }, 141 #define X_KMEMBUCKETS 9 142 { "_bucket" }, 143 #define X_ALLEVENTS 10 144 { "_allevents" }, 145 #define X_POOLHEAD 11 146 { "_pool_head" }, 147 #define X_UVMEXP 12 148 { "_uvmexp" }, 149 #define X_END 13 150 #if defined(pc532) 151 #define X_IVT (X_END) 152 { "_ivt" }, 153 #endif 154 { "" }, 155 }; 156 157 struct uvmexp uvmexp, ouvmexp; 158 int ndrives; 159 160 int winlines = 20; 161 162 kvm_t *kd; 163 164 #define FORKSTAT 0x01 165 #define INTRSTAT 0x02 166 #define MEMSTAT 0x04 167 #define SUMSTAT 0x08 168 #define EVCNTSTAT 0x10 169 #define VMSTAT 0x20 170 #define HISTLIST 0x40 171 #define HISTDUMP 0x80 172 173 void cpustats(void); 174 void dkstats(void); 175 void doevcnt(int verbose); 176 void dointr(int verbose); 177 void domem(void); 178 void dopool(void); 179 void dosum(void); 180 void dovmstat(u_int, int); 181 void kread(int, void *, size_t); 182 void needhdr(int); 183 long getuptime(void); 184 void printhdr(void); 185 long pct(long, long); 186 void usage(void); 187 void doforkst(void); 188 189 void hist_traverse(int, const char *); 190 void hist_dodump(struct uvm_history *); 191 192 int main(int, char **); 193 char **choosedrives(char **); 194 195 /* Namelist and memory file names. */ 196 char *nlistf, *memf; 197 198 /* allow old usage [vmstat 1] */ 199 #define BACKWARD_COMPATIBILITY 200 201 int 202 main(int argc, char *argv[]) 203 { 204 int c, todo, verbose; 205 u_int interval; 206 int reps; 207 char errbuf[_POSIX2_LINE_MAX]; 208 gid_t egid = getegid(); 209 const char *histname = NULL; 210 211 (void)setegid(getgid()); 212 memf = nlistf = NULL; 213 interval = reps = todo = verbose = 0; 214 while ((c = getopt(argc, argv, "c:efh:HilM:mN:svw:")) != -1) { 215 switch (c) { 216 case 'c': 217 reps = atoi(optarg); 218 break; 219 case 'e': 220 todo |= EVCNTSTAT; 221 break; 222 case 'f': 223 todo |= FORKSTAT; 224 break; 225 case 'h': 226 histname = optarg; 227 /* FALLTHROUGH */ 228 case 'H': 229 todo |= HISTDUMP; 230 break; 231 case 'i': 232 todo |= INTRSTAT; 233 break; 234 case 'l': 235 todo |= HISTLIST; 236 break; 237 case 'M': 238 memf = optarg; 239 break; 240 case 'm': 241 todo |= MEMSTAT; 242 break; 243 case 'N': 244 nlistf = optarg; 245 break; 246 case 's': 247 todo |= SUMSTAT; 248 break; 249 case 'v': 250 verbose = 1; 251 break; 252 case 'w': 253 interval = atoi(optarg); 254 break; 255 case '?': 256 default: 257 usage(); 258 } 259 } 260 argc -= optind; 261 argv += optind; 262 263 if (todo == 0) 264 todo = VMSTAT; 265 266 /* 267 * Discard setgid privileges. If not the running kernel, we toss 268 * them away totally so that bad guys can't print interesting stuff 269 * from kernel memory, otherwise switch back to kmem for the 270 * duration of the kvm_openfiles() call. 271 */ 272 if (nlistf != NULL || memf != NULL) 273 (void)setgid(getgid()); 274 else 275 (void)setegid(egid); 276 277 kd = kvm_openfiles(nlistf, memf, NULL, O_RDONLY, errbuf); 278 if (kd == NULL) 279 errx(1, "kvm_openfiles: %s\n", errbuf); 280 281 if (nlistf == NULL && memf == NULL) { 282 if (todo & VMSTAT) 283 (void)setegid(getgid()); /* XXX: dkinit */ 284 else 285 (void)setgid(getgid()); 286 } 287 288 if ((c = kvm_nlist(kd, namelist)) != 0) { 289 if (c > 0) { 290 (void)fprintf(stderr, 291 "vmstat: undefined symbols:"); 292 for (c = 0; 293 c < sizeof(namelist) / sizeof(namelist[0]); c++) 294 if (namelist[c].n_type == 0) 295 fprintf(stderr, " %s", 296 namelist[c].n_name); 297 (void)fputc('\n', stderr); 298 } else 299 (void)fprintf(stderr, "vmstat: kvm_nlist: %s\n", 300 kvm_geterr(kd)); 301 exit(1); 302 } 303 304 if (todo & VMSTAT) { 305 struct winsize winsize; 306 307 dkinit(0, egid); /* Initialize disk stats, no disks selected. */ 308 309 (void)setgid(getgid()); /* don't need privs anymore */ 310 311 argv = choosedrives(argv); /* Select disks. */ 312 winsize.ws_row = 0; 313 (void)ioctl(STDOUT_FILENO, TIOCGWINSZ, (char *)&winsize); 314 if (winsize.ws_row > 0) 315 winlines = winsize.ws_row; 316 317 } 318 319 #ifdef BACKWARD_COMPATIBILITY 320 if (*argv) { 321 interval = atoi(*argv); 322 if (*++argv) 323 reps = atoi(*argv); 324 } 325 #endif 326 327 if (interval) { 328 if (!reps) 329 reps = -1; 330 } else if (reps) 331 interval = 1; 332 333 334 /* 335 * Statistics dumping is incompatible with the default 336 * VMSTAT/dovmstat() output. So perform the interval/reps handling 337 * for it here. 338 */ 339 if ((todo & VMSTAT) == 0) 340 for (;;) { 341 if (todo & (HISTLIST|HISTDUMP)) { 342 if ((todo & (HISTLIST|HISTDUMP)) == 343 (HISTLIST|HISTDUMP)) 344 errx(1, "you may list or dump, but not both!"); 345 hist_traverse(todo, histname); 346 } 347 if (todo & FORKSTAT) 348 doforkst(); 349 if (todo & MEMSTAT) { 350 domem(); 351 dopool(); 352 } 353 if (todo & SUMSTAT) 354 dosum(); 355 if (todo & INTRSTAT) 356 dointr(verbose); 357 if (todo & EVCNTSTAT) 358 doevcnt(verbose); 359 360 if (reps >= 0 && --reps <=0) 361 break; 362 sleep(interval); 363 puts(""); 364 } 365 else 366 dovmstat(interval, reps); 367 exit(0); 368 } 369 370 char ** 371 choosedrives(char **argv) 372 { 373 int i; 374 375 /* 376 * Choose drives to be displayed. Priority goes to (in order) drives 377 * supplied as arguments, default drives. If everything isn't filled 378 * in and there are drives not taken care of, display the first few 379 * that fit. 380 */ 381 #define BACKWARD_COMPATIBILITY 382 for (ndrives = 0; *argv; ++argv) { 383 #ifdef BACKWARD_COMPATIBILITY 384 if (isdigit(**argv)) 385 break; 386 #endif 387 for (i = 0; i < dk_ndrive; i++) { 388 if (strcmp(dr_name[i], *argv)) 389 continue; 390 dk_select[i] = 1; 391 ++ndrives; 392 break; 393 } 394 } 395 for (i = 0; i < dk_ndrive && ndrives < 4; i++) { 396 if (dk_select[i]) 397 continue; 398 dk_select[i] = 1; 399 ++ndrives; 400 } 401 return (argv); 402 } 403 404 long 405 getuptime(void) 406 { 407 static time_t now; 408 static struct timeval boottime; 409 time_t uptime; 410 411 if (boottime.tv_sec == 0) 412 kread(X_BOOTTIME, &boottime, sizeof(boottime)); 413 (void)time(&now); 414 uptime = now - boottime.tv_sec; 415 if (uptime <= 0 || uptime > 60*60*24*365*10) { 416 (void)fprintf(stderr, 417 "vmstat: time makes no sense; namelist must be wrong.\n"); 418 exit(1); 419 } 420 return (uptime); 421 } 422 423 int hz, hdrcnt; 424 425 void 426 dovmstat(u_int interval, int reps) 427 { 428 struct vmtotal total; 429 time_t uptime, halfuptime; 430 int mib[2]; 431 size_t size; 432 int pagesize = getpagesize(); 433 434 uptime = getuptime(); 435 halfuptime = uptime / 2; 436 (void)signal(SIGCONT, needhdr); 437 438 if (namelist[X_STATHZ].n_type != 0 && namelist[X_STATHZ].n_value != 0) 439 kread(X_STATHZ, &hz, sizeof(hz)); 440 if (!hz) 441 kread(X_HZ, &hz, sizeof(hz)); 442 443 for (hdrcnt = 1;;) { 444 if (!--hdrcnt) 445 printhdr(); 446 /* Read new disk statistics */ 447 dkreadstats(); 448 kread(X_UVMEXP, &uvmexp, sizeof(uvmexp)); 449 if (memf != NULL) { 450 /* 451 * XXX Can't do this if we're reading a crash 452 * XXX dump because they're lazily-calculated. 453 */ 454 printf("Unable to get vmtotals from crash dump.\n"); 455 memset(&total, 0, sizeof(total)); 456 } else { 457 size = sizeof(total); 458 mib[0] = CTL_VM; 459 mib[1] = VM_METER; 460 if (sysctl(mib, 2, &total, &size, NULL, 0) < 0) { 461 printf("Can't get vmtotals: %s\n", 462 strerror(errno)); 463 memset(&total, 0, sizeof(total)); 464 } 465 } 466 (void)printf("%2d%2d%2d", 467 total.t_rq - 1, total.t_dw + total.t_pw, total.t_sw); 468 #define pgtok(a) (long)((a) * (pagesize >> 10)) 469 #define rate(x) (u_long)(((x) + halfuptime) / uptime) /* round */ 470 (void)printf(" %5ld %5ld ", 471 pgtok(total.t_avm), pgtok(total.t_free)); 472 (void)printf("%4lu ", rate(uvmexp.faults - ouvmexp.faults)); 473 (void)printf("%3lu ", rate(uvmexp.pdreact - ouvmexp.pdreact)); 474 (void)printf("%3lu ", rate(uvmexp.pageins - ouvmexp.pageins)); 475 (void)printf("%4lu ", 476 rate(uvmexp.pgswapout - ouvmexp.pgswapout)); 477 (void)printf("%4lu ", rate(uvmexp.pdfreed - ouvmexp.pdfreed)); 478 (void)printf("%4lu ", rate(uvmexp.pdscans - ouvmexp.pdscans)); 479 dkstats(); 480 (void)printf("%4lu %4lu %3lu ", 481 rate(uvmexp.intrs - ouvmexp.intrs), 482 rate(uvmexp.syscalls - ouvmexp.syscalls), 483 rate(uvmexp.swtch - ouvmexp.swtch)); 484 cpustats(); 485 (void)printf("\n"); 486 (void)fflush(stdout); 487 if (reps >= 0 && --reps <= 0) 488 break; 489 ouvmexp = uvmexp; 490 uptime = interval; 491 /* 492 * We round upward to avoid losing low-frequency events 493 * (i.e., >= 1 per interval but < 1 per second). 494 */ 495 halfuptime = uptime == 1 ? 0 : (uptime + 1) / 2; 496 (void)sleep(interval); 497 } 498 } 499 500 void 501 printhdr(void) 502 { 503 int i; 504 505 (void)printf(" procs memory page%*s", 23, ""); 506 if (ndrives > 0) 507 (void)printf("%s %*sfaults cpu\n", 508 ((ndrives > 1) ? "disks" : "disk"), 509 ((ndrives > 1) ? ndrives * 3 - 4 : 0), ""); 510 else 511 (void)printf("%*s faults cpu\n", 512 ndrives * 3, ""); 513 514 (void)printf(" r b w avm fre flt re pi po fr sr "); 515 for (i = 0; i < dk_ndrive; i++) 516 if (dk_select[i]) 517 (void)printf("%c%c ", dr_name[i][0], 518 dr_name[i][strlen(dr_name[i]) - 1]); 519 (void)printf(" in sy cs us sy id\n"); 520 hdrcnt = winlines - 2; 521 } 522 523 /* 524 * Force a header to be prepended to the next output. 525 */ 526 void 527 needhdr(int dummy) 528 { 529 530 hdrcnt = 1; 531 } 532 533 long 534 pct(long top, long bot) 535 { 536 long ans; 537 538 if (bot == 0) 539 return (0); 540 ans = (quad_t)top * 100 / bot; 541 return (ans); 542 } 543 544 #define PCT(top, bot) (int)pct((long)(top), (long)(bot)) 545 546 void 547 dosum(void) 548 { 549 struct nchstats nchstats; 550 long nchtotal; 551 552 kread(X_UVMEXP, &uvmexp, sizeof(uvmexp)); 553 554 (void)printf("%9u bytes per page\n", uvmexp.pagesize); 555 556 (void)printf("%9u page color%s\n", 557 uvmexp.ncolors, uvmexp.ncolors == 1 ? "" : "s"); 558 559 (void)printf("%9u pages managed\n", uvmexp.npages); 560 (void)printf("%9u pages free\n", uvmexp.free); 561 (void)printf("%9u pages active\n", uvmexp.active); 562 (void)printf("%9u pages inactive\n", uvmexp.inactive); 563 (void)printf("%9u pages paging\n", uvmexp.paging); 564 (void)printf("%9u pages wired\n", uvmexp.wired); 565 (void)printf("%9u zero pages\n", uvmexp.zeropages); 566 (void)printf("%9u reserve pagedaemon pages\n", 567 uvmexp.reserve_pagedaemon); 568 (void)printf("%9u reserve kernel pages\n", uvmexp.reserve_kernel); 569 (void)printf("%9u anon pager pages\n", uvmexp.anonpages); 570 (void)printf("%9u vnode page cache pages\n", uvmexp.vnodepages); 571 (void)printf("%9u executable pages\n", uvmexp.vtextpages); 572 573 (void)printf("%9u minimum free pages\n", uvmexp.freemin); 574 (void)printf("%9u target free pages\n", uvmexp.freetarg); 575 (void)printf("%9u target inactive pages\n", uvmexp.inactarg); 576 (void)printf("%9u maximum wired pages\n", uvmexp.wiredmax); 577 578 (void)printf("%9u swap devices\n", uvmexp.nswapdev); 579 (void)printf("%9u swap pages\n", uvmexp.swpages); 580 (void)printf("%9u swap pages in use\n", uvmexp.swpginuse); 581 (void)printf("%9u swap allocations\n", uvmexp.nswget); 582 (void)printf("%9u anons\n", uvmexp.nanon); 583 (void)printf("%9u free anons\n", uvmexp.nfreeanon); 584 585 (void)printf("%9u total faults taken\n", uvmexp.faults); 586 (void)printf("%9u traps\n", uvmexp.traps); 587 (void)printf("%9u device interrupts\n", uvmexp.intrs); 588 (void)printf("%9u cpu context switches\n", uvmexp.swtch); 589 (void)printf("%9u software interrupts\n", uvmexp.softs); 590 (void)printf("%9u system calls\n", uvmexp.syscalls); 591 (void)printf("%9u pagein requests\n", uvmexp.pageins); 592 (void)printf("%9u pageout requests\n", uvmexp.pdpageouts); 593 (void)printf("%9u swap ins\n", uvmexp.swapins); 594 (void)printf("%9u swap outs\n", uvmexp.swapouts); 595 (void)printf("%9u pages swapped in\n", uvmexp.pgswapin); 596 (void)printf("%9u pages swapped out\n", uvmexp.pgswapout); 597 (void)printf("%9u forks total\n", uvmexp.forks); 598 (void)printf("%9u forks blocked parent\n", uvmexp.forks_ppwait); 599 (void)printf("%9u forks shared address space with parent\n", 600 uvmexp.forks_sharevm); 601 (void)printf("%9u pagealloc zero wanted and avail\n", 602 uvmexp.pga_zerohit); 603 (void)printf("%9u pagealloc zero wanted and not avail\n", 604 uvmexp.pga_zeromiss); 605 (void)printf("%9u aborts of idle page zeroing\n", 606 uvmexp.zeroaborts); 607 (void)printf("%9u pagealloc desired color avail\n", 608 uvmexp.colorhit); 609 (void)printf("%9u pagealloc desired color not avail\n", 610 uvmexp.colormiss); 611 612 (void)printf("%9u faults with no memory\n", uvmexp.fltnoram); 613 (void)printf("%9u faults with no anons\n", uvmexp.fltnoanon); 614 (void)printf("%9u faults had to wait on pages\n", uvmexp.fltpgwait); 615 (void)printf("%9u faults found released page\n", uvmexp.fltpgrele); 616 (void)printf("%9u faults relock (%u ok)\n", uvmexp.fltrelck, 617 uvmexp.fltrelckok); 618 (void)printf("%9u anon page faults\n", uvmexp.fltanget); 619 (void)printf("%9u anon retry faults\n", uvmexp.fltanretry); 620 (void)printf("%9u amap copy faults\n", uvmexp.fltamcopy); 621 (void)printf("%9u neighbour anon page faults\n", uvmexp.fltnamap); 622 (void)printf("%9u neighbour object page faults\n", uvmexp.fltnomap); 623 (void)printf("%9u locked pager get faults\n", uvmexp.fltlget); 624 (void)printf("%9u unlocked pager get faults\n", uvmexp.fltget); 625 (void)printf("%9u anon faults\n", uvmexp.flt_anon); 626 (void)printf("%9u anon copy on write faults\n", uvmexp.flt_acow); 627 (void)printf("%9u object faults\n", uvmexp.flt_obj); 628 (void)printf("%9u promote copy faults\n", uvmexp.flt_prcopy); 629 (void)printf("%9u promote zero fill faults\n", uvmexp.flt_przero); 630 631 (void)printf("%9u times daemon wokeup\n",uvmexp.pdwoke); 632 (void)printf("%9u revolutions of the clock hand\n", uvmexp.pdrevs); 633 (void)printf("%9u times daemon attempted swapout\n", uvmexp.pdswout); 634 (void)printf("%9u pages freed by daemon\n", uvmexp.pdfreed); 635 (void)printf("%9u pages scanned by daemon\n", uvmexp.pdscans); 636 (void)printf("%9u anonymous pages scanned by daemon\n", 637 uvmexp.pdanscan); 638 (void)printf("%9u object pages scanned by daemon\n", uvmexp.pdobscan); 639 (void)printf("%9u pages reactivated\n", uvmexp.pdreact); 640 (void)printf("%9u pages found busy by daemon\n", uvmexp.pdbusy); 641 (void)printf("%9u total pending pageouts\n", uvmexp.pdpending); 642 (void)printf("%9u pages deactivated\n", uvmexp.pddeact); 643 kread(X_NCHSTATS, &nchstats, sizeof(nchstats)); 644 nchtotal = nchstats.ncs_goodhits + nchstats.ncs_neghits + 645 nchstats.ncs_badhits + nchstats.ncs_falsehits + 646 nchstats.ncs_miss + nchstats.ncs_long; 647 (void)printf("%9ld total name lookups\n", nchtotal); 648 (void)printf( 649 "%9s cache hits (%d%% pos + %d%% neg) system %d%% per-process\n", 650 "", PCT(nchstats.ncs_goodhits, nchtotal), 651 PCT(nchstats.ncs_neghits, nchtotal), 652 PCT(nchstats.ncs_pass2, nchtotal)); 653 (void)printf("%9s deletions %d%%, falsehits %d%%, toolong %d%%\n", "", 654 PCT(nchstats.ncs_badhits, nchtotal), 655 PCT(nchstats.ncs_falsehits, nchtotal), 656 PCT(nchstats.ncs_long, nchtotal)); 657 } 658 659 void 660 doforkst(void) 661 { 662 663 kread(X_UVMEXP, &uvmexp, sizeof(uvmexp)); 664 665 (void)printf("%u forks total\n", uvmexp.forks); 666 (void)printf("%u forks blocked parent\n", uvmexp.forks_ppwait); 667 (void)printf("%u forks shared address space with parent\n", 668 uvmexp.forks_sharevm); 669 } 670 671 void 672 dkstats(void) 673 { 674 int dn, state; 675 double etime; 676 677 /* Calculate disk stat deltas. */ 678 dkswap(); 679 etime = 0; 680 for (state = 0; state < CPUSTATES; ++state) { 681 etime += cur.cp_time[state]; 682 } 683 if (etime == 0) 684 etime = 1; 685 etime /= hz; 686 for (dn = 0; dn < dk_ndrive; ++dn) { 687 if (!dk_select[dn]) 688 continue; 689 (void)printf("%2.0f ", cur.dk_xfer[dn] / etime); 690 } 691 } 692 693 void 694 cpustats(void) 695 { 696 int state; 697 double pct, total; 698 699 total = 0; 700 for (state = 0; state < CPUSTATES; ++state) 701 total += cur.cp_time[state]; 702 if (total) 703 pct = 100 / total; 704 else 705 pct = 0; 706 (void)printf("%2.0f ", 707 (cur.cp_time[CP_USER] + cur.cp_time[CP_NICE]) * pct); 708 (void)printf("%2.0f ", 709 (cur.cp_time[CP_SYS] + cur.cp_time[CP_INTR]) * pct); 710 (void)printf("%2.0f", cur.cp_time[CP_IDLE] * pct); 711 } 712 713 #if defined(pc532) 714 /* To get struct iv ...*/ 715 #define _KERNEL 716 #include <machine/psl.h> 717 #undef _KERNEL 718 void 719 dointr(int verbose) 720 { 721 long i, j, inttotal, uptime; 722 static char iname[64]; 723 struct iv ivt[32], *ivp = ivt; 724 725 iname[63] = '\0'; 726 uptime = getuptime(); 727 kread(X_IVT, ivp, sizeof(ivt)); 728 729 for (i = 0; i < 2; i++) { 730 (void)printf("%sware interrupts:\n", i ? "\nsoft" : "hard"); 731 (void)printf("interrupt total rate\n"); 732 inttotal = 0; 733 for (j = 0; j < 16; j++, ivp++) { 734 if (ivp->iv_vec && ivp->iv_use && 735 (ivp->iv_cnt || verbose)) { 736 if (kvm_read(kd, (u_long)ivp->iv_use, iname, 737 63) != 63) { 738 (void)fprintf(stderr, 739 "vmstat: iv_use: %s\n", 740 kvm_geterr(kd)); 741 exit(1); 742 } 743 (void)printf("%-12s %8ld %8ld\n", iname, 744 ivp->iv_cnt, ivp->iv_cnt / uptime); 745 inttotal += ivp->iv_cnt; 746 } 747 } 748 (void)printf("Total %8ld %8ld\n", 749 inttotal, inttotal / uptime); 750 } 751 } 752 #else 753 void 754 dointr(int verbose) 755 { 756 long *intrcnt; 757 long long inttotal, uptime; 758 int nintr, inamlen; 759 char *intrname; 760 struct evcntlist allevents; 761 struct evcnt evcnt, *evptr; 762 char evgroup[EVCNT_STRING_MAX], evname[EVCNT_STRING_MAX]; 763 764 uptime = getuptime(); 765 nintr = namelist[X_EINTRCNT].n_value - namelist[X_INTRCNT].n_value; 766 inamlen = 767 namelist[X_EINTRNAMES].n_value - namelist[X_INTRNAMES].n_value; 768 intrcnt = malloc((size_t)nintr); 769 intrname = malloc((size_t)inamlen); 770 if (intrcnt == NULL || intrname == NULL) { 771 (void)fprintf(stderr, "vmstat: %s.\n", strerror(errno)); 772 exit(1); 773 } 774 kread(X_INTRCNT, intrcnt, (size_t)nintr); 775 kread(X_INTRNAMES, intrname, (size_t)inamlen); 776 (void)printf("%-24s %16s %8s\n", "interrupt", "total", "rate"); 777 inttotal = 0; 778 nintr /= sizeof(long); 779 while (--nintr >= 0) { 780 if (*intrcnt || verbose) 781 (void)printf("%-24s %16lld %8lld\n", intrname, 782 (long long)*intrcnt, 783 (long long)(*intrcnt / uptime)); 784 intrname += strlen(intrname) + 1; 785 inttotal += *intrcnt++; 786 } 787 kread(X_ALLEVENTS, &allevents, sizeof allevents); 788 evptr = allevents.tqh_first; 789 while (evptr) { 790 if (kvm_read(kd, (long)evptr, &evcnt, sizeof evcnt) != 791 sizeof(evcnt)) { 792 event_chain_trashed: 793 (void)fprintf(stderr, 794 "vmstat: event chain trashed: %s\n", 795 kvm_geterr(kd)); 796 exit(1); 797 } 798 799 evptr = evcnt.ev_list.tqe_next; 800 if (evcnt.ev_type != EVCNT_TYPE_INTR) 801 continue; 802 803 if (evcnt.ev_count == 0 && !verbose) 804 continue; 805 806 if (kvm_read(kd, (long)evcnt.ev_group, evgroup, 807 evcnt.ev_grouplen + 1) != evcnt.ev_grouplen + 1) 808 goto event_chain_trashed; 809 if (kvm_read(kd, (long)evcnt.ev_name, evname, 810 evcnt.ev_namelen + 1) != evcnt.ev_namelen + 1) 811 goto event_chain_trashed; 812 813 (void)printf("%s %s%*s %16lld %8lld\n", evgroup, evname, 814 24 - (evcnt.ev_grouplen + 1 + evcnt.ev_namelen), "", 815 (long long)evcnt.ev_count, 816 (long long)(evcnt.ev_count / uptime)); 817 818 inttotal += evcnt.ev_count++; 819 } 820 (void)printf("%-24s %16lld %8lld\n", "Total", inttotal, 821 (long long)(inttotal / uptime)); 822 } 823 #endif 824 825 void 826 doevcnt(int verbose) 827 { 828 long long uptime; 829 struct evcntlist allevents; 830 struct evcnt evcnt, *evptr; 831 char evgroup[EVCNT_STRING_MAX], evname[EVCNT_STRING_MAX]; 832 833 /* XXX should print type! */ 834 835 uptime = getuptime(); 836 (void)printf("%-24s %16s %8s %s\n", "event", "total", "rate", "type"); 837 kread(X_ALLEVENTS, &allevents, sizeof allevents); 838 evptr = allevents.tqh_first; 839 while (evptr) { 840 if (kvm_read(kd, (long)evptr, &evcnt, sizeof evcnt) != 841 sizeof(evcnt)) { 842 event_chain_trashed: 843 (void)fprintf(stderr, 844 "vmstat: event chain trashed: %s\n", 845 kvm_geterr(kd)); 846 exit(1); 847 } 848 849 evptr = evcnt.ev_list.tqe_next; 850 if (evcnt.ev_count == 0 && !verbose) 851 continue; 852 853 if (kvm_read(kd, (long)evcnt.ev_group, evgroup, 854 evcnt.ev_grouplen + 1) != evcnt.ev_grouplen + 1) 855 goto event_chain_trashed; 856 if (kvm_read(kd, (long)evcnt.ev_name, evname, 857 evcnt.ev_namelen + 1) != evcnt.ev_namelen + 1) 858 goto event_chain_trashed; 859 860 (void)printf("%s %s%*s %16lld %8lld %s\n", evgroup, evname, 861 24 - (evcnt.ev_grouplen + 1 + evcnt.ev_namelen), "", 862 (long long)evcnt.ev_count, 863 (long long)(evcnt.ev_count / uptime), 864 /* XXX do the following with an array lookup XXX */ 865 (evcnt.ev_type == EVCNT_TYPE_MISC) ? "misc" : 866 ((evcnt.ev_type == EVCNT_TYPE_INTR) ? "intr" : "?")); 867 } 868 } 869 870 /* 871 * These names are defined in <sys/malloc.h>. 872 */ 873 char *kmemnames[] = INITKMEMNAMES; 874 875 void 876 domem(void) 877 { 878 struct kmembuckets *kp; 879 struct kmemstats *ks; 880 int i, j; 881 int len, size, first; 882 long totuse = 0, totfree = 0, totreq = 0; 883 char *name; 884 struct kmemstats kmemstats[M_LAST]; 885 struct kmembuckets buckets[MINBUCKET + 16]; 886 887 kread(X_KMEMBUCKETS, buckets, sizeof(buckets)); 888 for (first = 1, i = MINBUCKET, kp = &buckets[i]; i < MINBUCKET + 16; 889 i++, kp++) { 890 if (kp->kb_calls == 0) 891 continue; 892 if (first) { 893 (void)printf("Memory statistics by bucket size\n"); 894 (void)printf( 895 " Size In Use Free Requests HighWater Couldfree\n"); 896 first = 0; 897 } 898 size = 1 << i; 899 (void)printf("%8d %8ld %6ld %10ld %7ld %10ld\n", size, 900 kp->kb_total - kp->kb_totalfree, 901 kp->kb_totalfree, kp->kb_calls, 902 kp->kb_highwat, kp->kb_couldfree); 903 totfree += size * kp->kb_totalfree; 904 } 905 906 /* 907 * If kmem statistics are not being gathered by the kernel, 908 * first will still be 1. 909 */ 910 if (first) { 911 printf( 912 "Kmem statistics are not being gathered by the kernel.\n"); 913 return; 914 } 915 916 kread(X_KMEMSTAT, kmemstats, sizeof(kmemstats)); 917 (void)printf("\nMemory usage type by bucket size\n"); 918 (void)printf(" Size Type(s)\n"); 919 kp = &buckets[MINBUCKET]; 920 for (j = 1 << MINBUCKET; j < 1 << (MINBUCKET + 16); j <<= 1, kp++) { 921 if (kp->kb_calls == 0) 922 continue; 923 first = 1; 924 len = 8; 925 for (i = 0, ks = &kmemstats[0]; i < M_LAST; i++, ks++) { 926 if (ks->ks_calls == 0) 927 continue; 928 if ((ks->ks_size & j) == 0) 929 continue; 930 if (kmemnames[i] == 0) { 931 kmemnames[i] = malloc(10); 932 /* strlen("undef/")+3+1);*/ 933 snprintf(kmemnames[i], 10, "undef/%d", i); 934 /* same 10 as above!!! */ 935 } 936 name = kmemnames[i]; 937 len += 2 + strlen(name); 938 if (first) 939 printf("%8d %s", j, name); 940 else 941 printf(","); 942 if (len >= 80) { 943 printf("\n\t "); 944 len = 10 + strlen(name); 945 } 946 if (!first) 947 printf(" %s", name); 948 first = 0; 949 } 950 printf("\n"); 951 } 952 953 (void)printf( 954 "\nMemory statistics by type Type Kern\n"); 955 (void)printf( 956 " Type InUse MemUse HighUse Limit Requests Limit Limit Size(s)\n"); 957 for (i = 0, ks = &kmemstats[0]; i < M_LAST; i++, ks++) { 958 if (ks->ks_calls == 0) 959 continue; 960 (void)printf("%14s%6ld%6ldK%7ldK%6ldK%9ld%5u%6u", 961 kmemnames[i] ? kmemnames[i] : "undefined", 962 ks->ks_inuse, (ks->ks_memuse + 1023) / 1024, 963 (ks->ks_maxused + 1023) / 1024, 964 (ks->ks_limit + 1023) / 1024, ks->ks_calls, 965 ks->ks_limblocks, ks->ks_mapblocks); 966 first = 1; 967 for (j = 1 << MINBUCKET; j < 1 << (MINBUCKET + 16); j <<= 1) { 968 if ((ks->ks_size & j) == 0) 969 continue; 970 if (first) 971 printf(" %d", j); 972 else 973 printf(",%d", j); 974 first = 0; 975 } 976 printf("\n"); 977 totuse += ks->ks_memuse; 978 totreq += ks->ks_calls; 979 } 980 (void)printf("\nMemory Totals: In Use Free Requests\n"); 981 (void)printf(" %7ldK %6ldK %8ld\n", 982 (totuse + 1023) / 1024, (totfree + 1023) / 1024, totreq); 983 } 984 985 void 986 dopool(void) 987 { 988 int first, ovflw; 989 long addr; 990 long total = 0, inuse = 0; 991 TAILQ_HEAD(,pool) pool_head; 992 struct pool pool, *pp = &pool; 993 994 kread(X_POOLHEAD, &pool_head, sizeof(pool_head)); 995 addr = (long)TAILQ_FIRST(&pool_head); 996 997 for (first = 1; addr != 0; ) { 998 char name[32], maxp[32]; 999 if (kvm_read(kd, addr, (void *)pp, sizeof *pp) != sizeof *pp) { 1000 (void)fprintf(stderr, 1001 "vmstat: pool chain trashed: %s\n", 1002 kvm_geterr(kd)); 1003 exit(1); 1004 } 1005 if (kvm_read(kd, (long)pp->pr_wchan, name, sizeof name) < 0) { 1006 (void)fprintf(stderr, 1007 "vmstat: pool name trashed: %s\n", 1008 kvm_geterr(kd)); 1009 exit(1); 1010 } 1011 name[31] = '\0'; 1012 1013 if (first) { 1014 (void)printf("Memory resource pool statistics\n"); 1015 (void)printf( 1016 "%-11s%5s%9s%5s%9s%6s%6s%6s%6s%6s%6s%5s\n", 1017 "Name", 1018 "Size", 1019 "Requests", 1020 "Fail", 1021 "Releases", 1022 "Pgreq", 1023 "Pgrel", 1024 "Npage", 1025 "Hiwat", 1026 "Minpg", 1027 "Maxpg", 1028 "Idle"); 1029 first = 0; 1030 } 1031 if (pp->pr_maxpages == UINT_MAX) 1032 sprintf(maxp, "inf"); 1033 else 1034 sprintf(maxp, "%u", pp->pr_maxpages); 1035 /* 1036 * Print single word. `ovflow' is number of characters didn't fit 1037 * on the last word. `fmt' is a format string to print this word. 1038 * It must contain asterisk for field width. `width' is a width 1039 * occupied by this word. `fixed' is a number of constant chars in 1040 * `fmt'. `val' is a value to be printed using format string `fmt'. 1041 */ 1042 #define PRWORD(ovflw, fmt, width, fixed, val) do { \ 1043 (ovflw) += printf((fmt), \ 1044 (width) - (fixed) - (ovflw) > 0 ? \ 1045 (width) - (fixed) - (ovflw) : 0, \ 1046 (val)) - (width); \ 1047 if ((ovflw) < 0) \ 1048 (ovflw) = 0; \ 1049 } while (/* CONSTCOND */0) 1050 ovflw = 0; 1051 PRWORD(ovflw, "%-*s", 11, 0, name); 1052 PRWORD(ovflw, " %*u", 5, 1, pp->pr_size); 1053 PRWORD(ovflw, " %*lu", 9, 1, pp->pr_nget); 1054 PRWORD(ovflw, " %*lu", 5, 1, pp->pr_nfail); 1055 PRWORD(ovflw, " %*lu", 9, 1, pp->pr_nput); 1056 PRWORD(ovflw, " %*lu", 6, 1, pp->pr_npagealloc); 1057 PRWORD(ovflw, " %*lu", 6, 1, pp->pr_npagefree); 1058 PRWORD(ovflw, " %*d", 6, 1, pp->pr_npages); 1059 PRWORD(ovflw, " %*d", 6, 1, pp->pr_hiwat); 1060 PRWORD(ovflw, " %*d", 6, 1, pp->pr_minpages); 1061 PRWORD(ovflw, " %*s", 6, 1, maxp); 1062 PRWORD(ovflw, " %*lu\n", 5, 1, pp->pr_nidle); 1063 1064 inuse += (pp->pr_nget - pp->pr_nput) * pp->pr_size; 1065 total += pp->pr_npages * pp->pr_pagesz; 1066 addr = (long)TAILQ_NEXT(pp, pr_poollist); 1067 } 1068 1069 inuse /= 1024; 1070 total /= 1024; 1071 printf("\nIn use %ldK, total allocated %ldK; utilization %.1f%%\n", 1072 inuse, total, (double)(100 * inuse) / total); 1073 } 1074 1075 /* 1076 * kread reads something from the kernel, given its nlist index. 1077 */ 1078 void 1079 kread(int nlx, void *addr, size_t size) 1080 { 1081 const char *sym; 1082 1083 if (namelist[nlx].n_type == 0 || namelist[nlx].n_value == 0) { 1084 sym = namelist[nlx].n_name; 1085 if (*sym == '_') 1086 ++sym; 1087 (void)fprintf(stderr, 1088 "vmstat: symbol %s not defined\n", sym); 1089 exit(1); 1090 } 1091 if (kvm_read(kd, namelist[nlx].n_value, addr, size) != size) { 1092 sym = namelist[nlx].n_name; 1093 if (*sym == '_') 1094 ++sym; 1095 (void)fprintf(stderr, "vmstat: %s: %s\n", sym, kvm_geterr(kd)); 1096 exit(1); 1097 } 1098 } 1099 1100 struct nlist histnl[] = { 1101 { "_uvm_histories" }, 1102 #define X_UVM_HISTORIES 0 1103 { NULL }, 1104 }; 1105 1106 /* 1107 * Traverse the UVM history buffers, performing the requested action. 1108 * 1109 * Note, we assume that if we're not listing, we're dumping. 1110 */ 1111 void 1112 hist_traverse(int todo, const char *histname) 1113 { 1114 struct uvm_history_head histhead; 1115 struct uvm_history hist, *histkva; 1116 char *name = NULL; 1117 size_t namelen = 0; 1118 1119 if (kvm_nlist(kd, histnl) != 0) { 1120 printf("UVM history is not compiled into the kernel.\n"); 1121 return; 1122 } 1123 1124 if (kvm_read(kd, histnl[X_UVM_HISTORIES].n_value, &histhead, 1125 sizeof(histhead)) != sizeof(histhead)) { 1126 warnx("unable to read %s: %s", 1127 histnl[X_UVM_HISTORIES].n_name, kvm_geterr(kd)); 1128 return; 1129 } 1130 1131 if (histhead.lh_first == NULL) { 1132 printf("No active UVM history logs.\n"); 1133 return; 1134 } 1135 1136 if (todo & HISTLIST) 1137 printf("Active UVM histories:"); 1138 1139 for (histkva = LIST_FIRST(&histhead); histkva != NULL; 1140 histkva = LIST_NEXT(&hist, list)) { 1141 if (kvm_read(kd, (u_long)histkva, &hist, sizeof(hist)) != 1142 sizeof(hist)) { 1143 warnx("unable to read history at %p: %s", 1144 histkva, kvm_geterr(kd)); 1145 goto out; 1146 } 1147 1148 if (hist.namelen > namelen) { 1149 if (name != NULL) 1150 free(name); 1151 namelen = hist.namelen; 1152 if ((name = malloc(namelen + 1)) == NULL) 1153 err(1, "malloc history name"); 1154 } 1155 1156 if (kvm_read(kd, (u_long)hist.name, name, namelen) != 1157 namelen) { 1158 warnx("unable to read history name at %p: %s", 1159 hist.name, kvm_geterr(kd)); 1160 goto out; 1161 } 1162 name[namelen] = '\0'; 1163 if (todo & HISTLIST) 1164 printf(" %s", name); 1165 else { 1166 /* 1167 * If we're dumping all histories, do it, else 1168 * check to see if this is the one we want. 1169 */ 1170 if (histname == NULL || strcmp(histname, name) == 0) { 1171 if (histname == NULL) 1172 printf("\nUVM history `%s':\n", name); 1173 hist_dodump(&hist); 1174 } 1175 } 1176 } 1177 1178 if (todo & HISTLIST) 1179 printf("\n"); 1180 1181 out: 1182 if (name != NULL) 1183 free(name); 1184 } 1185 1186 /* 1187 * Actually dump the history buffer at the specified KVA. 1188 */ 1189 void 1190 hist_dodump(struct uvm_history *histp) 1191 { 1192 struct uvm_history_ent *histents, *e; 1193 size_t histsize; 1194 char *fmt = NULL, *fn = NULL; 1195 size_t fmtlen = 0, fnlen = 0; 1196 int i; 1197 1198 histsize = sizeof(struct uvm_history_ent) * histp->n; 1199 1200 if ((histents = malloc(histsize)) == NULL) 1201 err(1, "malloc history entries"); 1202 1203 memset(histents, 0, histsize); 1204 1205 if (kvm_read(kd, (u_long)histp->e, histents, histsize) != histsize) { 1206 warnx("unable to read history entries at %p: %s", 1207 histp->e, kvm_geterr(kd)); 1208 goto out; 1209 } 1210 1211 i = histp->f; 1212 do { 1213 e = &histents[i]; 1214 if (e->fmt != NULL) { 1215 if (e->fmtlen > fmtlen) { 1216 if (fmt != NULL) 1217 free(fmt); 1218 fmtlen = e->fmtlen; 1219 if ((fmt = malloc(fmtlen + 1)) == NULL) 1220 err(1, "malloc printf format"); 1221 } 1222 if (e->fnlen > fnlen) { 1223 if (fn != NULL) 1224 free(fn); 1225 fnlen = e->fnlen; 1226 if ((fn = malloc(fnlen + 1)) == NULL) 1227 err(1, "malloc function name"); 1228 } 1229 1230 if (kvm_read(kd, (u_long)e->fmt, fmt, fmtlen) != 1231 fmtlen) { 1232 warnx("unable to read printf format " 1233 "at %p: %s", e->fmt, kvm_geterr(kd)); 1234 goto out; 1235 } 1236 fmt[fmtlen] = '\0'; 1237 1238 if (kvm_read(kd, (u_long)e->fn, fn, fnlen) != fnlen) { 1239 warnx("unable to read function name " 1240 "at %p: %s", e->fn, kvm_geterr(kd)); 1241 goto out; 1242 } 1243 fn[fnlen] = '\0'; 1244 1245 printf("%06ld.%06ld ", (long int)e->tv.tv_sec, 1246 (long int)e->tv.tv_usec); 1247 printf("%s#%ld: ", fn, e->call); 1248 printf(fmt, e->v[0], e->v[1], e->v[2], e->v[3]); 1249 printf("\n"); 1250 } 1251 i = (i + 1) % histp->n; 1252 } while (i != histp->f); 1253 1254 out: 1255 free(histents); 1256 if (fmt != NULL) 1257 free(fmt); 1258 if (fn != NULL) 1259 free(fn); 1260 } 1261 1262 void 1263 usage(void) 1264 { 1265 1266 (void)fprintf(stderr, 1267 "usage: vmstat [-efHilmsv] [-h histname] [-c count] [-M core] " 1268 "[-N system] [-w wait] [disks]\n"); 1269 exit(1); 1270 } 1271