X-Git-Url: https://git.subgeniuskitty.com/unix-history/.git/blobdiff_plain/dfdfb4c8406107ea8066af416b1d047514aef804..2088f2bf3517adb0c786379afd5ec28b17dfe27e:/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 b802b02a72..202e855a87 100644 --- a/usr/src/usr.bin/vmstat/vmstat.c +++ b/usr/src/usr.bin/vmstat/vmstat.c @@ -1,22 +1,33 @@ +/* + * Copyright (c) 1980 Regents of the University of California. + * All rights reserved. The Berkeley software License Agreement + * specifies the terms and conditions for redistribution. + */ + #ifndef lint -static char *sccsid = "@(#)vmstat.c 4.13 (Berkeley) %G%"; -#endif +char copyright[] = +"@(#) Copyright (c) 1980 Regents of the University of California.\n\ + All rights reserved.\n"; +#endif not lint + +#ifndef lint +static char sccsid[] = "@(#)vmstat.c 5.9 (Berkeley) %G%"; +#endif not lint #include +#include +#include + #include +#include #include -#include -#include +#include #include #include -#include -#ifdef vax -#include -#include -#endif -#ifdef sun -#include -#endif +#include +#include +#include +#include struct nlist nl[] = { #define X_CPTIME 0 @@ -45,42 +56,62 @@ struct nlist nl[] = { { "_pgintime" }, #define X_HZ 12 { "_hz" }, -#define X_PHZ 13 +#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" }, #ifdef vax -#define X_MBDINIT 15 +#define X_MBDINIT (X_XSTATS+1) { "_mbdinit" }, -#define X_UBDINIT 16 +#define X_UBDINIT (X_XSTATS+2) { "_ubdinit" }, #endif -#ifdef sun -#define X_MBDINIT 15 - { "_mbdinit" }, +#ifdef tahoe +#define X_VBDINIT (X_XSTATS+1) + { "_vbdinit" }, +#define X_CKEYSTATS (X_XSTATS+2) + { "_ckeystats" }, +#define X_DKEYSTATS (X_XSTATS+3) + { "_dkeystats" }, #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 +char *defdrives[] = { 0 }; +#endif double stat1(); int firstfree, maxfree; int hz; int phz; int HZ; -#ifdef sun -#define INTS(x) (x) -#endif -#ifdef vax -#define INTS(x) ((x) - (hz + phz)) -#endif -struct -{ +struct { int busy; long time[CPUSTATES]; - long xfer[DK_NDRIVE]; + long *xfer; struct vmmeter Rate; struct vmtotal Total; struct vmmeter Sum; @@ -94,34 +125,33 @@ struct #define forkstat s.Forkstat struct vmmeter osum; -int zero; int deficit; double etime; int mf; +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]; - setbuf(stdout, _sobuf); nlist("/vmunix", nl); if(nl[0].n_type == 0) { - printf("no /vmunix namelist\n"); + fprintf(stderr, "no /vmunix namelist\n"); exit(1); } mf = open("/dev/kmem", 0); if(mf < 0) { - printf("cannot open /dev/kmem\n"); + fprintf(stderr, "cannot open /dev/kmem\n"); exit(1); } iter = 0; @@ -138,7 +168,7 @@ main(argc, argv) case 'z': close(mf); mf = open("/dev/kmem", 2); - lseek(mf, (long)nl[X_SUM].n_value, 0); + lseek(mf, (long)nl[X_SUM].n_value, L_SET); write(mf, &z.Sum, sizeof z.Sum); exit(0); @@ -146,67 +176,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); - lseek(mf, (long)nl[X_PHZ].n_value, 0); - read(mf, &phz, sizeof phz); + 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; - for (i = 0; i < DK_NDRIVE; i++) { - strcpy(dr_name[i], "xx"); - dr_unit[i] = i; + 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 re at pi po fr de sr %c%d %c%d %c%d %c%d in sy cs us sy id\n", - 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; @@ -221,15 +311,16 @@ 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("%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 /= (float) HZ; - for(i=0; i<4; i++) - stats(i); + 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); @@ -270,12 +379,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 statbuf; + 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); @@ -288,7 +405,7 @@ dosum() printf("%9d pages paged out\n", sum.v_pgpgout); printf("%9d sequential process pages freed\n", sum.v_seqfree); printf("%9d total reclaims (%d%% fast)\n", sum.v_pgrec, - (sum.v_fastpgrec * 100) / (sum.v_pgrec == 0 ? 1 : 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); @@ -304,23 +421,55 @@ 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, &statbuf, sizeof statbuf); - nchtotal = statbuf.ncs_goodhits + statbuf.ncs_badhits + - statbuf.ncs_miss + statbuf.ncs_long; + read(mf, &nchstats, sizeof nchstats); + nchtotal = nchstats.ncs_goodhits + nchstats.ncs_badhits + + nchstats.ncs_falsehits + nchstats.ncs_miss + nchstats.ncs_long; printf("%9d total name lookups", nchtotal); printf(" (cache hits %d%% system %d%% per-process)\n", - statbuf.ncs_goodhits * 100 / nchtotal, - statbuf.ncs_pass2 * 100 / nchtotal); + pct(nchstats.ncs_goodhits, nchtotal), + pct(nchstats.ncs_pass2, nchtotal)); + printf("%9s badhits %d, falsehits %d, toolong %d\n", "", + nchstats.ncs_badhits, nchstats.ncs_falsehits, nchstats.ncs_long); + 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, @@ -333,7 +482,7 @@ doforkst() stats(dn) { - if (dn >= DK_NDRIVE) { + if (dn >= dk_ndrive) { printf(" 0"); return; } @@ -362,11 +511,110 @@ 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", /* M_FREE */ + "mbuf", /* M_MBUF */ + "devbuf", /* M_DEVBUF */ + "socket", /* M_SOCKET */ + "pcb", /* M_PCB */ + "routetbl", /* M_RTABLE */ + "hosttbl", /* M_HTABLE */ + "fragtbl", /* M_FTABLE */ + "zombie", /* M_ZOMBIE */ + "ifaddr", /* M_IFADDR */ + "soopts", /* M_SOOPTS */ + "soname", /* M_SONAME */ + "namei", /* M_NAMEI */ + "gprof", /* M_GPROF */ + "ioctlops", /* M_IOCTLOPS */ + "superblk", /* M_SUPERBLK */ + "cred", /* M_CRED */ + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + "temp", /* 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; @@ -391,8 +639,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); @@ -402,36 +650,40 @@ 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; + char *cp = (char *)&two_char; - mp = (struct mb_device *) nl[X_MBDINIT].n_value; - if (mp == 0) { - fprintf(stderr, "iostat: Disk init info not in namelist\n"); + 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(mp++, mdev); - if (mdev.md_driver == 0) + steal(up++, udev); + if (udev.ui_driver == 0) break; - if (mdev.md_dk < 0 || mdev.md_alive == 0) + if (udev.ui_dk < 0 || udev.ui_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; + 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