X-Git-Url: https://git.subgeniuskitty.com/unix-history/.git/blobdiff_plain/60519de645c9bc4bf2f50478ad6fe46550c12510..7579356b76362e1454ed7a22dff69fbe0cd9ea6b:/usr/src/usr.bin/vmstat/vmstat.c diff --git a/usr/src/usr.bin/vmstat/vmstat.c b/usr/src/usr.bin/vmstat/vmstat.c index 7fb6bb96a9..b3cba17833 100644 --- a/usr/src/usr.bin/vmstat/vmstat.c +++ b/usr/src/usr.bin/vmstat/vmstat.c @@ -1,20 +1,32 @@ +/* + * Copyright (c) 1980 The Regents of the University of California. + * All rights reserved. + * + * %sccs.include.redist.c% + */ + #ifndef lint -static char *sccsid = "@(#)vmstat.c 4.10 (Berkeley) %G%"; -#endif +char copyright[] = +"@(#) Copyright (c) 1980 The Regents of the University of California.\n\ + All rights reserved.\n"; +#endif /* not lint */ + +#ifndef lint +static char sccsid[] = "@(#)vmstat.c 5.21 (Berkeley) %G%"; +#endif /* not lint */ -#include #include +#include #include -#include -#include +#include #include -#ifdef vax -#include -#include -#endif -#ifdef sun -#include -#endif +#include +#include +#include +#include +#include +#include +#include struct nlist nl[] = { #define X_CPTIME 0 @@ -43,29 +55,71 @@ struct nlist nl[] = { { "_pgintime" }, #define X_HZ 12 { "_hz" }, +#define X_PHZ 13 + { "_phz" }, +#define X_NCHSTATS 14 + { "_nchstats" }, +#define X_INTRNAMES 15 + { "_intrnames" }, +#define X_EINTRNAMES 16 + { "_eintrnames" }, +#define X_INTRCNT 17 + { "_intrcnt" }, +#define X_EINTRCNT 18 + { "_eintrcnt" }, +#define X_DK_NDRIVE 19 + { "_dk_ndrive" }, +#define X_XSTATS 20 + { "_xstats" }, +#define X_KMEMSTAT 21 + { "_kmemstats" }, +#define X_KMEMBUCKETS 22 + { "_bucket" }, +#define X_END 22 #ifdef vax -#define X_MBDINIT 13 +#define X_MBDINIT (X_END+1) { "_mbdinit" }, -#define X_UBDINIT 14 +#define X_UBDINIT (X_END+2) { "_ubdinit" }, #endif -#ifdef sun -#define X_MBDINIT 13 - { "_mbdinit" }, +#ifdef tahoe +#define X_VBDINIT (X_END+1) + { "_vbdinit" }, +#define X_CKEYSTATS (X_END+2) + { "_ckeystats" }, +#define X_DKEYSTATS (X_END+3) + { "_dkeystats" }, +#endif +#ifdef hp300 +#define X_HPDINIT (X_END+1) + { "_hp_dinit" }, #endif { "" }, }; -char dr_name[DK_NDRIVE][10]; -char dr_unit[DK_NDRIVE]; +char **dr_name; +int *dr_select; +int dk_ndrive; +int ndrives = 0; +#ifdef vax +char *defdrives[] = { "hp0", "hp1", "hp2", 0 }; +#else +#ifdef hp300 +char *defdrives[] = { "rd0", "rd1", "rd2", 0 }; +#else +char *defdrives[] = { 0 }; +#endif +#endif double stat1(); int firstfree, maxfree; int hz; -struct -{ +int phz; +int HZ; + +struct { int busy; long time[CPUSTATES]; - long xfer[DK_NDRIVE]; + long *xfer; struct vmmeter Rate; struct vmtotal Total; struct vmmeter Sum; @@ -79,38 +133,33 @@ struct #define forkstat s.Forkstat struct vmmeter osum; -int zero; int deficit; double etime; int mf; -int swflag; +time_t now, boottime; +int printhdr(); +int lines = 1; + +#define INTS(x) ((x) - (hz + phz)) main(argc, argv) int argc; char **argv; { - time_t now; - int lines; extern char *ctime(); - register i,j; - int iter, nintv; - time_t boottime; - double f1, f2; + register i; + int iter, nintv, iflag = 0; long t; - extern char _sobuf[]; + char *arg, **cp, buf[BUFSIZ]; -#ifdef sun - swflag = 1; -#endif - setbuf(stdout, _sobuf); - nlist("/vmunix", nl); + nlist(_PATH_UNIX, nl); if(nl[0].n_type == 0) { - printf("no /vmunix namelist\n"); + fprintf(stderr, "vmstat: no %s namelist\n", _PATH_UNIX); exit(1); } - mf = open("/dev/kmem", 0); + mf = open(_PATH_KMEM, 0); if(mf < 0) { - printf("cannot open /dev/kmem\n"); + fprintf(stderr, "vmstat: cannot open %s\n", _PATH_KMEM); exit(1); } iter = 0; @@ -120,19 +169,14 @@ main(argc, argv) argc--; while (*++cp) switch (*cp) { - case 'S': - swflag = 1 - swflag; - break; - - case 't': dotimes(); exit(0); case 'z': close(mf); - mf = open("/dev/kmem", 2); - lseek(mf, (long)nl[X_SUM].n_value, 0); + mf = open(_PATH_KMEM, 2); + lseek(mf, (long)nl[X_SUM].n_value, L_SET); write(mf, &z.Sum, sizeof z.Sum); exit(0); @@ -140,65 +184,127 @@ main(argc, argv) doforkst(); exit(0); + case 'm': + domem(); + exit(0); + case 's': dosum(); exit(0); + case 'i': + iflag++; + break; + default: - fprintf(stderr, "usage: vmstat [ -fs ] [ interval ] [ count]\n"); + fprintf(stderr, + "usage: vmstat [ -fsim ] [ interval ] [ count]\n"); exit(1); } } - if(argc > 1) - iter = atoi(argv[1]); - lseek(mf, (long)nl[X_FIRSTFREE].n_value, 0); + lseek(mf, (long)nl[X_FIRSTFREE].n_value, L_SET); read(mf, &firstfree, sizeof firstfree); - lseek(mf, (long)nl[X_MAXFREE].n_value, 0); + lseek(mf, (long)nl[X_MAXFREE].n_value, L_SET); read(mf, &maxfree, sizeof maxfree); - lseek(mf, (long)nl[X_BOOTTIME].n_value, 0); + lseek(mf, (long)nl[X_BOOTTIME].n_value, L_SET); read(mf, &boottime, sizeof boottime); - lseek(mf, (long)nl[X_HZ].n_value, 0); + lseek(mf, (long)nl[X_HZ].n_value, L_SET); read(mf, &hz, sizeof hz); - for (i = 0; i < DK_NDRIVE; i++) { - strcpy(dr_name[i], "xx"); - dr_unit[i] = i; + if (nl[X_PHZ].n_value != 0) { + lseek(mf, (long)nl[X_PHZ].n_value, L_SET); + read(mf, &phz, sizeof phz); + } + HZ = phz ? phz : hz; + if (nl[X_DK_NDRIVE].n_value == 0) { + fprintf(stderr, "dk_ndrive undefined in system\n"); + exit(1); + } + lseek(mf, nl[X_DK_NDRIVE].n_value, L_SET); + read(mf, &dk_ndrive, sizeof (dk_ndrive)); + if (dk_ndrive <= 0) { + fprintf(stderr, "dk_ndrive %d\n", dk_ndrive); + exit(1); + } + dr_select = (int *)calloc(dk_ndrive, sizeof (int)); + dr_name = (char **)calloc(dk_ndrive, sizeof (char *)); +#define allocate(e, t) \ + s./**/e = (t *)calloc(dk_ndrive, sizeof (t)); \ + s1./**/e = (t *)calloc(dk_ndrive, sizeof (t)); + allocate(xfer, long); + for (arg = buf, i = 0; i < dk_ndrive; i++) { + dr_name[i] = arg; + sprintf(dr_name[i], "dk%d", i); + arg += strlen(dr_name[i]) + 1; } read_names(); time(&now); nintv = now - boottime; if (nintv <= 0 || nintv > 60*60*24*365*10) { - printf("Time makes no sense... namelist must be wrong.\n"); + fprintf(stderr, + "Time makes no sense... namelist must be wrong.\n"); exit(1); } -reprint: - lines = 20; - /* s1 = z; */ -printf("\ - procs memory page disk faults cpu\n\ - r b w avm fre %5s pi po fr de sr %c%d %c%d %c%d %c%d in sy cs us sy id\n\ -", swflag ? "si so" : "re at", - dr_name[0][0], dr_unit[0], dr_name[1][0], dr_unit[1], dr_name[2][0], dr_unit[2], dr_name[3][0], dr_unit[3]); + if (iflag) { + dointr(nintv); + exit(0); + } + /* + * Choose drives to be displayed. Priority + * goes to (in order) drives supplied as arguments, + * default drives. If everything isn't filled + * in and there are drives not taken care of, + * display the first few that fit. + */ + ndrives = 0; + while (argc > 0 && !isdigit(argv[0][0])) { + for (i = 0; i < dk_ndrive; i++) { + if (strcmp(dr_name[i], argv[0])) + continue; + dr_select[i] = 1; + ndrives++; + } + argc--, argv++; + } + for (i = 0; i < dk_ndrive && ndrives < 4; i++) { + if (dr_select[i]) + continue; + for (cp = defdrives; *cp; cp++) + if (strcmp(dr_name[i], *cp) == 0) { + dr_select[i] = 1; + ndrives++; + break; + } + } + for (i = 0; i < dk_ndrive && ndrives < 4; i++) { + if (dr_select[i]) + continue; + dr_select[i] = 1; + ndrives++; + } + if (argc > 1) + iter = atoi(argv[1]); + signal(SIGCONT, printhdr); loop: - lseek(mf, (long)nl[X_CPTIME].n_value, 0); + if (--lines == 0) + printhdr(); + lseek(mf, (long)nl[X_CPTIME].n_value, L_SET); read(mf, s.time, sizeof s.time); - lseek(mf, (long)nl[X_DKXFER].n_value, 0); - read(mf, s.xfer, sizeof s.xfer); - if (nintv != 1) { - lseek(mf, (long)nl[X_SUM].n_value, 0); - read(mf, &rate, sizeof rate); - } else { - lseek(mf, (long)nl[X_RATE].n_value, 0); - read(mf, &rate, sizeof rate); - } - lseek(mf, (long)nl[X_TOTAL].n_value, 0); + lseek(mf, (long)nl[X_DKXFER].n_value, L_SET); + read(mf, s.xfer, dk_ndrive * sizeof (long)); + if (nintv != 1) + lseek(mf, (long)nl[X_SUM].n_value, L_SET); + else + lseek(mf, (long)nl[X_RATE].n_value, L_SET); + read(mf, &rate, sizeof rate); + lseek(mf, (long)nl[X_TOTAL].n_value, L_SET); read(mf, &total, sizeof total); osum = sum; - lseek(mf, (long)nl[X_SUM].n_value, 0); + lseek(mf, (long)nl[X_SUM].n_value, L_SET); read(mf, &sum, sizeof sum); - lseek(mf, (long)nl[X_DEFICIT].n_value, 0); + lseek(mf, (long)nl[X_DEFICIT].n_value, L_SET); read(mf, &deficit, sizeof deficit); etime = 0; - for (i=0; i < DK_NDRIVE; i++) { + for (i=0; i < dk_ndrive; i++) { t = s.xfer[i]; s.xfer[i] -= s1.xfer[i]; s1.xfer[i] = t; @@ -213,27 +319,18 @@ loop: etime = 1.; printf("%2d%2d%2d", total.t_rq, total.t_dw+total.t_pw, total.t_sw); #define pgtok(a) ((a)*NBPG/1024) - printf("%6d%5d", pgtok(total.t_avm), pgtok(total.t_free)); - printf("%4d%3d", - swflag ? - sum.v_swpin-osum.v_swpin : - (rate.v_pgrec - (rate.v_xsfrec+rate.v_xifrec))/nintv, - swflag ? - sum.v_swpout-osum.v_swpout : - (rate.v_xsfrec+rate.v_xifrec)/nintv); + printf("%6d%6d", pgtok(total.t_avm), pgtok(total.t_free)); + printf("%4d%3d", (rate.v_pgrec - (rate.v_xsfrec+rate.v_xifrec))/nintv, + (rate.v_xsfrec+rate.v_xifrec)/nintv); printf("%4d", pgtok(rate.v_pgpgin)/nintv); printf("%4d%4d%4d%4d", pgtok(rate.v_pgpgout)/nintv, pgtok(rate.v_dfree)/nintv, pgtok(deficit), rate.v_scan/nintv); - etime /= 60.; - for(i=0; i<4; i++) - stats(i); -#ifdef sun - printf("%4d%4d", (rate.v_intr/nintv), rate.v_syscall/nintv); -#endif -#ifdef vax - printf("%4d%4d", (rate.v_intr/nintv) - hz, rate.v_syscall/nintv); -#endif - printf("%4d", rate.v_swtch/nintv); + etime /= (float)HZ; + for (i = 0; i < dk_ndrive; i++) + if (dr_select[i]) + stats(i); + printf("%4d%4d%4d", INTS(rate.v_intr/nintv), rate.v_syscall/nintv, + rate.v_swtch/nintv); for(i=0; i 0) { + if (--iter &&argc > 0) { sleep(atoi(argv[0])); - if (--lines <= 0) - goto reprint; goto loop; } } +printhdr() +{ + register int i, j; + + printf(" procs memory page "); + i = (ndrives * 3 - 6) / 2; + if (i < 0) + i = 0; + for (j = 0; j < i; j++) + putchar(' '); + printf("faults"); + i = ndrives * 3 - 6 - i; + for (j = 0; j < i; j++) + putchar(' '); + printf(" cpu\n"); + printf(" r b w avm fre re at pi po fr de sr "); + for (i = 0; i < dk_ndrive; i++) + if (dr_select[i]) + printf("%c%c ", dr_name[i][0], dr_name[i][2]); + printf(" in sy cs us sy id\n"); + lines = 19; +} + dotimes() { - lseek(mf, (long)nl[X_REC].n_value, 0); + lseek(mf, (long)nl[X_REC].n_value, L_SET); read(mf, &s.rectime, sizeof s.rectime); - lseek(mf, (long)nl[X_PGIN].n_value, 0); + lseek(mf, (long)nl[X_PGIN].n_value, L_SET); read(mf, &s.pgintime, sizeof s.pgintime); - lseek(mf, (long)nl[X_SUM].n_value, 0); + lseek(mf, (long)nl[X_SUM].n_value, L_SET); read(mf, &sum, sizeof sum); printf("%d reclaims, %d total time (usec)\n", sum.v_pgrec, s.rectime); printf("average: %d usec / reclaim\n", s.rectime/sum.v_pgrec); @@ -272,10 +387,20 @@ dotimes() printf("average: %8.1f msec / page in\n", s.pgintime/(sum.v_pgin*10.0)); } +#if defined(tahoe) +#include +#endif + dosum() { + struct nchstats nchstats; + struct xstats xstats; + long nchtotal; +#if defined(tahoe) + struct keystats keystats; +#endif - lseek(mf, (long)nl[X_SUM].n_value, 0); + lseek(mf, (long)nl[X_SUM].n_value, L_SET); read(mf, &sum, sizeof sum); printf("%9d swap ins\n", sum.v_swpin); printf("%9d swap outs\n", sum.v_swpout); @@ -287,7 +412,8 @@ dosum() printf("%9d pages paged in\n", sum.v_pgpgin); printf("%9d pages paged out\n", sum.v_pgpgout); printf("%9d sequential process pages freed\n", sum.v_seqfree); - printf("%9d total reclaims\n", sum.v_pgrec); + printf("%9d total reclaims (%d%% fast)\n", sum.v_pgrec, + pct(sum.v_fastpgrec, sum.v_pgrec)); printf("%9d reclaims from free list\n", sum.v_pgfrec); printf("%9d intransit blocking page faults\n", sum.v_intrans); printf("%9d zero fill pages created\n", sum.v_nzfod / CLSIZE); @@ -303,15 +429,59 @@ dosum() printf("%9d pages freed by the clock daemon\n", sum.v_dfree / CLSIZE); printf("%9d cpu context switches\n", sum.v_swtch); printf("%9d device interrupts\n", sum.v_intr); - printf("%9d pseduo-dma dz interrupts\n", sum.v_pdma); + printf("%9d software interrupts\n", sum.v_soft); +#ifdef vax + printf("%9d pseudo-dma dz interrupts\n", sum.v_pdma); +#endif printf("%9d traps\n", sum.v_trap); printf("%9d system calls\n", sum.v_syscall); + lseek(mf, (long)nl[X_NCHSTATS].n_value, 0); + read(mf, &nchstats, sizeof nchstats); + nchtotal = nchstats.ncs_goodhits + nchstats.ncs_neghits + + nchstats.ncs_badhits + nchstats.ncs_falsehits + + nchstats.ncs_miss + nchstats.ncs_long; + printf("%9d total name lookups\n", nchtotal); + printf("%9s cache hits (%d%% pos + %d%% neg) system %d%% per-process\n", + "", pct(nchstats.ncs_goodhits, nchtotal), + pct(nchstats.ncs_neghits, nchtotal), + pct(nchstats.ncs_pass2, nchtotal)); + printf("%9s deletions %d%%, falsehits %d%%, toolong %d%%\n", "", + pct(nchstats.ncs_badhits, nchtotal), + pct(nchstats.ncs_falsehits, nchtotal), + pct(nchstats.ncs_long, nchtotal)); + lseek(mf, (long)nl[X_XSTATS].n_value, 0); + read(mf, &xstats, sizeof xstats); + printf("%9d total calls to xalloc (cache hits %d%%)\n", + xstats.alloc, pct(xstats.alloc_cachehit, xstats.alloc)); + printf("%9s sticky %d flushed %d unused %d\n", "", + xstats.alloc_inuse, xstats.alloc_cacheflush, xstats.alloc_unused); + printf("%9d total calls to xfree", xstats.free); + printf(" (sticky %d cached %d swapped %d)\n", + xstats.free_inuse, xstats.free_cache, xstats.free_cacheswap); +#if defined(tahoe) + lseek(mf, (long)nl[X_CKEYSTATS].n_value, 0); + read(mf, &keystats, sizeof keystats); + printf("%9d %s (free %d%% norefs %d%% taken %d%% shared %d%%)\n", + keystats.ks_allocs, "code cache keys allocated", + pct(keystats.ks_allocfree, keystats.ks_allocs), + pct(keystats.ks_norefs, keystats.ks_allocs), + pct(keystats.ks_taken, keystats.ks_allocs), + pct(keystats.ks_shared, keystats.ks_allocs)); + lseek(mf, (long)nl[X_DKEYSTATS].n_value, 0); + read(mf, &keystats, sizeof keystats); + printf("%9d %s (free %d%% norefs %d%% taken %d%% shared %d%%)\n", + keystats.ks_allocs, "data cache keys allocated", + pct(keystats.ks_allocfree, keystats.ks_allocs), + pct(keystats.ks_norefs, keystats.ks_allocs), + pct(keystats.ks_taken, keystats.ks_allocs), + pct(keystats.ks_shared, keystats.ks_allocs)); +#endif } doforkst() { - lseek(mf, (long)nl[X_FORKSTAT].n_value, 0); + lseek(mf, (long)nl[X_FORKSTAT].n_value, L_SET); read(mf, &forkstat, sizeof forkstat); printf("%d forks, %d pages, average=%.2f\n", forkstat.cntfork, forkstat.sizfork, @@ -324,7 +494,7 @@ doforkst() stats(dn) { - if (dn >= DK_NDRIVE) { + if (dn >= dk_ndrive) { printf(" 0"); return; } @@ -353,11 +523,125 @@ pct(top, bot) return ((top * 100) / bot); } -#define steal(where, var) lseek(mf, where, 0); read(mf, &var, sizeof var); +dointr(nintv) +{ + int nintr, inttotal; + long *intrcnt; + char *intrname, *malloc(); + + nintr = (nl[X_EINTRCNT].n_value - nl[X_INTRCNT].n_value) / sizeof(long); + intrcnt = (long *) malloc(nl[X_EINTRCNT].n_value - + nl[X_INTRCNT].n_value); + intrname = malloc(nl[X_EINTRNAMES].n_value - nl[X_INTRNAMES].n_value); + if (intrcnt == NULL || intrname == NULL) { + fprintf(stderr, "vmstat: out of memory\n"); + exit(9); + } + lseek(mf, (long)nl[X_INTRCNT].n_value, L_SET); + read(mf, intrcnt, nintr * sizeof (long)); + lseek(mf, (long)nl[X_INTRNAMES].n_value, L_SET); + read(mf, intrname, nl[X_EINTRNAMES].n_value - nl[X_INTRNAMES].n_value); + printf("interrupt total rate\n"); + inttotal = 0; + while (nintr--) { + if (*intrcnt) + printf("%-12s %8ld %8ld\n", intrname, + *intrcnt, *intrcnt / nintv); + intrname += strlen(intrname) + 1; + inttotal += *intrcnt++; + } + printf("Total %8ld %8ld\n", inttotal, inttotal / nintv); +} + +/* + * These names must be kept in sync with + * the types defined in . + */ +char *kmemnames[] = { + "free", /* 0 M_FREE */ + "mbuf", /* 1 M_MBUF */ + "devbuf", /* 2 M_DEVBUF */ + "socket", /* 3 M_SOCKET */ + "pcb", /* 4 M_PCB */ + "routetbl", /* 5 M_RTABLE */ + "hosttbl", /* 6 M_HTABLE */ + "fragtbl", /* 7 M_FTABLE */ + "zombie", /* 8 M_ZOMBIE */ + "ifaddr", /* 9 M_IFADDR */ + "soopts", /* 10 M_SOOPTS */ + "soname", /* 11 M_SONAME */ + "namei", /* 12 M_NAMEI */ + "gprof", /* 13 M_GPROF */ + "ioctlops", /* 14 M_IOCTLOPS */ + "superblk", /* 15 M_SUPERBLK */ + "cred", /* 16 M_CRED */ + "pgrp", /* 17 M_PGRP */ + "session", /* 18 M_SESSION */ + "iov", /* 19 M_IOV */ + "mount", /* 20 M_MOUNT */ + "fhandle", /* 21 M_FHANDLE */ + "NFS req", /* 22 M_NFSREQ */ + "NFS mount", /* 23 M_NFSMNT */ + "vnodes", /* 24 M_VNODE */ + "namecache", /* 25 M_CACHE */ + "UFS quota", /* 26 M_DQUOT */ + "UFS mount", /* 27 M_UFSMNT */ + "mapmem", /* 28 M_MAPMEM */ + "shm", /* 29 M_SHM */ + 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, + "temp", /* 49 M_TEMP */ +}; + +domem() +{ + struct kmemstats kmemstats[M_LAST]; + struct kmembuckets buckets[MINBUCKET + 16]; + register struct kmembuckets *kp; + register struct kmemstats *ks; + int i; + + lseek(mf, (long)nl[X_KMEMBUCKETS].n_value, L_SET); + read(mf, buckets, sizeof buckets); + printf("Memory statistics by bucket size\n"); + printf(" Size In Use Free Requests HighWater Couldfree\n"); + for (i = MINBUCKET, kp = &buckets[i]; i < MINBUCKET + 16; i++, kp++) { + if (kp->kb_calls == 0) + continue; + printf("%8d%9d%7d%11d%8d%11d\n", 1 << i, + kp->kb_total - kp->kb_totalfree, + kp->kb_totalfree, kp->kb_calls, + kp->kb_highwat, kp->kb_couldfree); + + } + lseek(mf, (long)nl[X_KMEMSTAT].n_value, L_SET); + read(mf, kmemstats, sizeof kmemstats); + printf("Memory statistics by type\n"); + printf(" Type In Use MemUse HighUse Limit Requests %s\n", + "TypeLimit KernLimit"); + for (i = 0, ks = &kmemstats[0]; i < M_LAST; i++, ks++) { + if (ks->ks_calls == 0) + continue; + printf("%10s%7d%8dK%9dK%6dK%9d%7d%10d\n", + kmemnames[i] ? kmemnames[i] : "undefined", + ks->ks_inuse, (ks->ks_memuse + 1023) / 1024, + (ks->ks_maxused + 1023) / 1024, + (ks->ks_limit + 1023) / 1024, ks->ks_calls, + ks->ks_limblocks, ks->ks_mapblocks); + } +} + +#define steal(where, var) \ + lseek(mf, where, L_SET); read(mf, &var, sizeof var); /* * Read the drive names out of kmem. */ #ifdef vax +#include +#include + read_names() { struct mba_device mdev; @@ -382,8 +666,8 @@ read_names() continue; steal(mdev.mi_driver, mdrv); steal(mdrv.md_dname, two_char); - sprintf(dr_name[mdev.mi_dk], "%c%c", cp[0], cp[1]); - dr_unit[mdev.mi_dk] = mdev.mi_unit; + sprintf(dr_name[mdev.mi_dk], "%c%c%d", + cp[0], cp[1], mdev.mi_unit); } for (;;) { steal(up++, udev); @@ -393,36 +677,78 @@ read_names() continue; steal(udev.ui_driver, udrv); steal(udrv.ud_dname, two_char); - sprintf(dr_name[udev.ui_dk], "%c%c", cp[0], cp[1]); - dr_unit[udev.ui_dk] = udev.ui_unit; + sprintf(dr_name[udev.ui_dk], "%c%c%d", + cp[0], cp[1], udev.ui_unit); } } #endif -#ifdef sun +#ifdef tahoe +#include + +/* + * Read the drive names out of kmem. + */ read_names() { - struct mb_device mdev; - register struct mb_device *mp; - struct mb_driver mdrv; + struct vba_device udev, *up; + struct vba_driver udrv; + short two_char; + char *cp = (char *)&two_char; + + up = (struct vba_device *) nl[X_VBDINIT].n_value; + if (up == 0) { + fprintf(stderr, "vmstat: Disk init info not in namelist\n"); + exit(1); + } + for (;;) { + steal(up++, udev); + if (udev.ui_driver == 0) + break; + if (udev.ui_dk < 0 || udev.ui_alive == 0) + continue; + steal(udev.ui_driver, udrv); + steal(udrv.ud_dname, two_char); + sprintf(dr_name[udev.ui_dk], "%c%c%d", + cp[0], cp[1], udev.ui_unit); + } +} +#endif + +#ifdef hp300 +#include + +#define validdisk(cp) ((cp)[1] == 'd' && ((cp)[0] == 'r' || (cp)[0] == 's')) + +read_names() +{ + struct hp_device hdev; + register struct hp_device *hp; + struct driver hdrv; short two_char; char *cp = (char *) &two_char; + register char *dp; - mp = (struct mb_device *) nl[X_MBDINIT].n_value; - if (mp == 0) { - fprintf(stderr, "iostat: Disk init info not in namelist\n"); + hp = (struct hp_device *) nl[X_HPDINIT].n_value; + if (hp == 0) { + fprintf(stderr, "vmstat: Disk init info not in namelist\n"); exit(1); } for (;;) { - steal(mp++, mdev); - if (mdev.md_driver == 0) + steal(hp++, hdev); + if (hdev.hp_driver == 0) break; - if (mdev.md_dk < 0 || mdev.md_alive == 0) + steal(hdev.hp_driver, hdrv); + steal(hdrv.d_name, two_char); + /* + * hp_dk is meaningless if the device isn't a disk + * (d_name not valid) or the disk was not found when + * booting (hp_alive == 0). + */ + if (!validdisk(cp) || hdev.hp_alive == 0) continue; - steal(mdev.md_driver, mdrv); - steal(mdrv.mdr_dname, two_char); - sprintf(dr_name[mdev.md_dk], "%c%c%d", cp[0], cp[1]); - dr_unit[mdev.md_dk] = mdev.md_unit; + dp = dr_name[hdev.hp_dk]; + sprintf(dp, "%c%c%d", cp[0], cp[1], hdev.hp_unit); } } #endif