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 |
07ed1e09 KM |
8 | static char sccsid[] = "@(#)disks.c 5.1 (Berkeley) %G%"; |
9 | #endif not lint | |
4da6460c KM |
10 | |
11 | #include "systat.h" | |
4da6460c | 12 | #include <sys/buf.h> |
833d578b SL |
13 | #include <ctype.h> |
14 | ||
15 | static struct nlist nlst[] = { | |
16 | #define X_DK_NDRIVE 0 | |
17 | { "_dk_ndrive" }, | |
18 | #define X_DK_MSPW 1 | |
19 | { "_dk_mspw" }, | |
4da6460c | 20 | #ifdef vax |
833d578b SL |
21 | #define X_MBDINIT 2 |
22 | { "_mbdinit" }, | |
23 | #define X_UBDINIT 3 | |
24 | { "_ubdinit" }, | |
4da6460c KM |
25 | #endif |
26 | #ifdef sun | |
833d578b SL |
27 | #define X_MBDINIT 2 |
28 | { "_mbdinit" }, | |
4da6460c | 29 | #endif |
833d578b SL |
30 | { "" }, |
31 | }; | |
32 | ||
33 | dkinit() | |
34 | { | |
35 | register int i; | |
36 | register char *cp; | |
37 | static int once = 0; | |
38 | static char buf[1024]; | |
4da6460c | 39 | |
833d578b SL |
40 | if (once) |
41 | return; | |
42 | once = 1; | |
43 | nlist("/vmunix", nlst); | |
44 | if (nlst[X_DK_NDRIVE].n_value == 0) { | |
45 | error("dk_ndrive undefined in kernel"); | |
46 | return; | |
47 | } | |
48 | dk_ndrive = getw(nlst[X_DK_NDRIVE].n_value); | |
49 | if (dk_ndrive <= 0) { | |
50 | error("dk_ndrive=%d according to /vmunix", dk_ndrive); | |
51 | return; | |
52 | } | |
53 | dk_mspw = (float *)calloc(dk_ndrive, sizeof (float)); | |
54 | lseek(kmem, nlst[X_DK_MSPW].n_value, L_SET); | |
55 | read(kmem, dk_mspw, dk_ndrive * sizeof (float)); | |
56 | dr_name = (char **)calloc(dk_ndrive, sizeof (char *)); | |
57 | dk_select = (int *)calloc(dk_ndrive, sizeof (int)); | |
58 | for (cp = buf, i = 0; i < dk_ndrive; i++) { | |
59 | dr_name[i] = cp; | |
60 | sprintf(dr_name[i], "dk%d", i); | |
61 | cp += strlen(dr_name[i]) + 1; | |
62 | if (dk_mspw[i] != 0.0) | |
63 | dk_select[i] = 1; | |
64 | } | |
65 | read_names(); | |
66 | } | |
67 | ||
68 | dkcmd(cmd, args) | |
69 | char *cmd, *args; | |
70 | { | |
71 | ||
72 | if (prefix(cmd, "display") || prefix(cmd, "add")) { | |
73 | dkselect(args, 1, dk_select); | |
74 | return (1); | |
75 | } | |
76 | if (prefix(cmd, "ignore") || prefix(cmd, "delete")) { | |
77 | dkselect(args, 0, dk_select); | |
78 | return (1); | |
79 | } | |
80 | if (prefix(cmd, "drives")) { | |
81 | register int i; | |
82 | ||
83 | move(CMDLINE, 0); clrtoeol(); | |
84 | for (i = 0; i < dk_ndrive; i++) | |
85 | if (dk_mspw[i] != 0.0) | |
86 | printw("%s ", dr_name[i]); | |
87 | return (1); | |
88 | } | |
89 | return (0); | |
90 | } | |
4da6460c KM |
91 | |
92 | #define steal(where, var) \ | |
93 | lseek(kmem, where, L_SET); read(kmem, &var, sizeof var); | |
94 | ||
95 | #ifdef vax | |
833d578b SL |
96 | #include <vaxuba/ubavar.h> |
97 | #include <vaxmba/mbavar.h> | |
98 | ||
99 | read_names() | |
4da6460c KM |
100 | { |
101 | static int once = 0; | |
102 | struct mba_device mdev; | |
103 | struct mba_driver mdrv; | |
104 | short two_char; | |
105 | char *cp = (char *)&two_char; | |
106 | struct uba_device udev; | |
107 | struct uba_driver udrv; | |
833d578b SL |
108 | register struct mba_device *mp; |
109 | register struct uba_device *up; | |
4da6460c | 110 | |
833d578b SL |
111 | mp = (struct mba_device *)nlst[X_MBDINIT].n_value; |
112 | up = (struct uba_device *)nlst[X_UBDINIT].n_value; | |
113 | if (mp == 0 && up == 0) { | |
4da6460c KM |
114 | error("Disk init info not in namelist\n"); |
115 | return; | |
116 | } | |
117 | if (mp) for (;;) { | |
118 | steal(mp++, mdev); | |
119 | if (mdev.mi_driver == 0) | |
120 | break; | |
121 | if (mdev.mi_dk < 0 || mdev.mi_alive == 0) | |
122 | continue; | |
123 | steal(mdev.mi_driver, mdrv); | |
124 | steal(mdrv.md_dname, two_char); | |
125 | sprintf(dr_name[mdev.mi_dk], "%c%c%d", | |
126 | cp[0], cp[1], mdev.mi_unit); | |
127 | } | |
128 | if (up) for (;;) { | |
129 | steal(up++, udev); | |
130 | if (udev.ui_driver == 0) | |
131 | break; | |
132 | if (udev.ui_dk < 0 || udev.ui_alive == 0) | |
133 | continue; | |
134 | steal(udev.ui_driver, udrv); | |
135 | steal(udrv.ud_dname, two_char); | |
136 | sprintf(dr_name[udev.ui_dk], "%c%c%d", | |
137 | cp[0], cp[1], udev.ui_unit); | |
138 | } | |
139 | } | |
140 | #endif | |
141 | ||
142 | #ifdef sun | |
833d578b SL |
143 | #include <sundev/mbvar.h> |
144 | ||
145 | read_names() | |
4da6460c KM |
146 | { |
147 | static int once = 0; | |
148 | struct mb_device mdev; | |
149 | struct mb_driver mdrv; | |
150 | short two_char; | |
151 | char *cp = (char *) &two_char; | |
833d578b | 152 | register struct mb_device *mp; |
4da6460c | 153 | |
833d578b | 154 | mp = (struct mb_device *)nlst[X_MBDINIT].n_value; |
4da6460c KM |
155 | if (mp == 0) { |
156 | error("Disk init info not in namelist\n"); | |
157 | return; | |
158 | } | |
159 | for (;;) { | |
160 | steal(mp++, mdev); | |
161 | if (mdev.md_driver == 0) | |
162 | break; | |
163 | if (mdev.md_dk < 0 || mdev.md_alive == 0) | |
164 | continue; | |
165 | steal(mdev.md_driver, mdrv); | |
166 | steal(mdrv.mdr_dname, two_char); | |
167 | sprintf(dr_name[mdev.md_dk], "%c%c%d", | |
168 | cp[0], cp[1], mdev.md_unit); | |
169 | } | |
170 | } | |
171 | #endif | |
172 | ||
173 | dkselect(args, truefalse, selections) | |
174 | char *args; | |
175 | int truefalse, selections[]; | |
176 | { | |
177 | register char *cp; | |
178 | register int i; | |
179 | char *index(); | |
180 | ||
181 | cp = index(args, '\n'); | |
182 | if (cp) | |
183 | *cp = '\0'; | |
184 | for (;;) { | |
185 | for (cp = args; *cp && isspace(*cp); cp++) | |
186 | ; | |
187 | args = cp; | |
188 | for (; *cp && !isspace(*cp); cp++) | |
189 | ; | |
190 | if (*cp) | |
191 | *cp++ = '\0'; | |
192 | if (cp - args == 0) | |
193 | break; | |
833d578b | 194 | for (i = 0; i < dk_ndrive; i++) |
4da6460c | 195 | if (strcmp(args, dr_name[i]) == 0) { |
4da6460c | 196 | if (dk_mspw[i] != 0.0) |
833d578b SL |
197 | selections[i] = truefalse; |
198 | else | |
199 | error("%s: drive not configured", | |
200 | dr_name[i]); | |
4da6460c KM |
201 | break; |
202 | } | |
833d578b | 203 | if (i >= dk_ndrive) |
4da6460c KM |
204 | error("%s: unknown drive", args); |
205 | args = cp; | |
206 | } | |
207 | } |