Commit | Line | Data |
---|---|---|
07ed1e09 KM |
1 | /* |
2 | * Copyright (c) 1980 Regents of the University of California. | |
3 | * All rights reserved. The Berkeley software License Agreement | |
4 | * specifies the terms and conditions for redistribution. | |
5 | */ | |
6 | ||
4da6460c | 7 | #ifndef lint |
eef33ea7 | 8 | static char sccsid[] = "@(#)disks.c 5.4 (Berkeley) %G%"; |
07ed1e09 | 9 | #endif not lint |
4da6460c KM |
10 | |
11 | #include "systat.h" | |
4da6460c | 12 | #include <sys/buf.h> |
833d578b | 13 | #include <ctype.h> |
eef33ea7 | 14 | #include <paths.h> |
833d578b SL |
15 | |
16 | static struct nlist nlst[] = { | |
17 | #define X_DK_NDRIVE 0 | |
18 | { "_dk_ndrive" }, | |
19 | #define X_DK_MSPW 1 | |
20 | { "_dk_mspw" }, | |
4da6460c | 21 | #ifdef vax |
8d7d38c3 | 22 | #define X_MBDINIT (X_DK_MSPW+1) |
833d578b | 23 | { "_mbdinit" }, |
8d7d38c3 | 24 | #define X_UBDINIT (X_DK_MSPW+2) |
833d578b | 25 | { "_ubdinit" }, |
4da6460c KM |
26 | #endif |
27 | #ifdef sun | |
8d7d38c3 | 28 | #define X_MBDINIT (X_DK_MSPW+1) |
833d578b | 29 | { "_mbdinit" }, |
8d7d38c3 SL |
30 | #endif |
31 | #ifdef tahoe | |
32 | #define X_VBDINIT (X_DK_MSPW+1) | |
33 | { "_vbdinit" }, | |
4da6460c | 34 | #endif |
833d578b SL |
35 | { "" }, |
36 | }; | |
37 | ||
38 | dkinit() | |
39 | { | |
40 | register int i; | |
41 | register char *cp; | |
42 | static int once = 0; | |
43 | static char buf[1024]; | |
4da6460c | 44 | |
833d578b | 45 | if (once) |
c0b7e584 | 46 | return(1); |
eef33ea7 | 47 | nlist(_PATH_UNIX, nlst); |
833d578b SL |
48 | if (nlst[X_DK_NDRIVE].n_value == 0) { |
49 | error("dk_ndrive undefined in kernel"); | |
c0b7e584 | 50 | return(0); |
833d578b SL |
51 | } |
52 | dk_ndrive = getw(nlst[X_DK_NDRIVE].n_value); | |
53 | if (dk_ndrive <= 0) { | |
eef33ea7 | 54 | error("dk_ndrive=%d according to %s", dk_ndrive, _PATH_UNIX); |
c0b7e584 | 55 | return(0); |
833d578b SL |
56 | } |
57 | dk_mspw = (float *)calloc(dk_ndrive, sizeof (float)); | |
58 | lseek(kmem, nlst[X_DK_MSPW].n_value, L_SET); | |
59 | read(kmem, dk_mspw, dk_ndrive * sizeof (float)); | |
60 | dr_name = (char **)calloc(dk_ndrive, sizeof (char *)); | |
61 | dk_select = (int *)calloc(dk_ndrive, sizeof (int)); | |
62 | for (cp = buf, i = 0; i < dk_ndrive; i++) { | |
63 | dr_name[i] = cp; | |
64 | sprintf(dr_name[i], "dk%d", i); | |
65 | cp += strlen(dr_name[i]) + 1; | |
66 | if (dk_mspw[i] != 0.0) | |
67 | dk_select[i] = 1; | |
68 | } | |
8d7d38c3 | 69 | if (!read_names()) { |
c0b7e584 JB |
70 | free(dr_name); |
71 | free(dk_select); | |
72 | free(dk_mspw); | |
73 | return(0); | |
74 | } | |
75 | once = 1; | |
76 | return(1); | |
833d578b SL |
77 | } |
78 | ||
79 | dkcmd(cmd, args) | |
80 | char *cmd, *args; | |
81 | { | |
eef33ea7 KB |
82 | if (prefix(cmd, "display") || prefix(cmd, "add")) { |
83 | dkselect(args, 1, dk_select); | |
833d578b | 84 | return (1); |
eef33ea7 KB |
85 | } |
86 | if (prefix(cmd, "ignore") || prefix(cmd, "delete")) { | |
87 | dkselect(args, 0, dk_select); | |
833d578b | 88 | return (1); |
eef33ea7 KB |
89 | } |
90 | if (prefix(cmd, "drives")) { | |
833d578b SL |
91 | register int i; |
92 | ||
eef33ea7 KB |
93 | move(CMDLINE, 0); clrtoeol(); |
94 | for (i = 0; i < dk_ndrive; i++) | |
95 | if (dk_mspw[i] != 0.0) | |
96 | printw("%s ", dr_name[i]); | |
97 | return (1); | |
98 | } | |
833d578b SL |
99 | return (0); |
100 | } | |
4da6460c KM |
101 | |
102 | #define steal(where, var) \ | |
103 | lseek(kmem, where, L_SET); read(kmem, &var, sizeof var); | |
104 | ||
105 | #ifdef vax | |
833d578b SL |
106 | #include <vaxuba/ubavar.h> |
107 | #include <vaxmba/mbavar.h> | |
108 | ||
109 | read_names() | |
4da6460c | 110 | { |
4da6460c KM |
111 | struct mba_device mdev; |
112 | struct mba_driver mdrv; | |
113 | short two_char; | |
114 | char *cp = (char *)&two_char; | |
115 | struct uba_device udev; | |
116 | struct uba_driver udrv; | |
833d578b SL |
117 | register struct mba_device *mp; |
118 | register struct uba_device *up; | |
4da6460c | 119 | |
833d578b SL |
120 | mp = (struct mba_device *)nlst[X_MBDINIT].n_value; |
121 | up = (struct uba_device *)nlst[X_UBDINIT].n_value; | |
122 | if (mp == 0 && up == 0) { | |
4da6460c | 123 | error("Disk init info not in namelist\n"); |
c0b7e584 | 124 | return(0); |
4da6460c KM |
125 | } |
126 | if (mp) for (;;) { | |
127 | steal(mp++, mdev); | |
128 | if (mdev.mi_driver == 0) | |
129 | break; | |
130 | if (mdev.mi_dk < 0 || mdev.mi_alive == 0) | |
131 | continue; | |
132 | steal(mdev.mi_driver, mdrv); | |
133 | steal(mdrv.md_dname, two_char); | |
134 | sprintf(dr_name[mdev.mi_dk], "%c%c%d", | |
135 | cp[0], cp[1], mdev.mi_unit); | |
136 | } | |
137 | if (up) for (;;) { | |
138 | steal(up++, udev); | |
139 | if (udev.ui_driver == 0) | |
140 | break; | |
141 | if (udev.ui_dk < 0 || udev.ui_alive == 0) | |
142 | continue; | |
143 | steal(udev.ui_driver, udrv); | |
144 | steal(udrv.ud_dname, two_char); | |
145 | sprintf(dr_name[udev.ui_dk], "%c%c%d", | |
146 | cp[0], cp[1], udev.ui_unit); | |
147 | } | |
c0b7e584 | 148 | return(1); |
4da6460c KM |
149 | } |
150 | #endif | |
151 | ||
152 | #ifdef sun | |
833d578b SL |
153 | #include <sundev/mbvar.h> |
154 | ||
155 | read_names() | |
4da6460c KM |
156 | { |
157 | static int once = 0; | |
158 | struct mb_device mdev; | |
159 | struct mb_driver mdrv; | |
160 | short two_char; | |
161 | char *cp = (char *) &two_char; | |
833d578b | 162 | register struct mb_device *mp; |
4da6460c | 163 | |
833d578b | 164 | mp = (struct mb_device *)nlst[X_MBDINIT].n_value; |
4da6460c KM |
165 | if (mp == 0) { |
166 | error("Disk init info not in namelist\n"); | |
c0b7e584 | 167 | return(0); |
4da6460c KM |
168 | } |
169 | for (;;) { | |
170 | steal(mp++, mdev); | |
171 | if (mdev.md_driver == 0) | |
172 | break; | |
173 | if (mdev.md_dk < 0 || mdev.md_alive == 0) | |
174 | continue; | |
175 | steal(mdev.md_driver, mdrv); | |
176 | steal(mdrv.mdr_dname, two_char); | |
177 | sprintf(dr_name[mdev.md_dk], "%c%c%d", | |
178 | cp[0], cp[1], mdev.md_unit); | |
179 | } | |
c0b7e584 | 180 | return(1); |
4da6460c KM |
181 | } |
182 | #endif | |
183 | ||
8d7d38c3 SL |
184 | #ifdef tahoe |
185 | #include <tahoevba/vbavar.h> | |
186 | ||
187 | /* | |
188 | * Read the drive names out of kmem. | |
189 | */ | |
190 | read_names() | |
191 | { | |
192 | struct vba_device udev, *up; | |
193 | struct vba_driver udrv; | |
194 | short two_char; | |
195 | char *cp = (char *)&two_char; | |
196 | ||
197 | up = (struct vba_device *) nlst[X_VBDINIT].n_value; | |
198 | if (up == 0) { | |
199 | fprintf(stderr, "vmstat: Disk init info not in namelist\n"); | |
200 | exit(1); | |
201 | } | |
202 | for (;;) { | |
203 | steal(up++, udev); | |
204 | if (udev.ui_driver == 0) | |
205 | break; | |
206 | if (udev.ui_dk < 0 || udev.ui_alive == 0) | |
207 | continue; | |
208 | steal(udev.ui_driver, udrv); | |
209 | steal(udrv.ud_dname, two_char); | |
210 | sprintf(dr_name[udev.ui_dk], "%c%c%d", | |
211 | cp[0], cp[1], udev.ui_unit); | |
212 | } | |
213 | } | |
214 | #endif | |
215 | ||
4da6460c KM |
216 | dkselect(args, truefalse, selections) |
217 | char *args; | |
218 | int truefalse, selections[]; | |
219 | { | |
220 | register char *cp; | |
221 | register int i; | |
222 | char *index(); | |
223 | ||
224 | cp = index(args, '\n'); | |
225 | if (cp) | |
226 | *cp = '\0'; | |
227 | for (;;) { | |
228 | for (cp = args; *cp && isspace(*cp); cp++) | |
229 | ; | |
230 | args = cp; | |
231 | for (; *cp && !isspace(*cp); cp++) | |
232 | ; | |
233 | if (*cp) | |
234 | *cp++ = '\0'; | |
235 | if (cp - args == 0) | |
236 | break; | |
833d578b | 237 | for (i = 0; i < dk_ndrive; i++) |
4da6460c | 238 | if (strcmp(args, dr_name[i]) == 0) { |
4da6460c | 239 | if (dk_mspw[i] != 0.0) |
833d578b SL |
240 | selections[i] = truefalse; |
241 | else | |
242 | error("%s: drive not configured", | |
243 | dr_name[i]); | |
4da6460c KM |
244 | break; |
245 | } | |
833d578b | 246 | if (i >= dk_ndrive) |
4da6460c KM |
247 | error("%s: unknown drive", args); |
248 | args = cp; | |
249 | } | |
250 | } |