![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to proc_cmd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / sys / stand / vdfmt|
Return to proc_cmd.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / sys / stand / vdfmt |
1.1 root 1: #include "vdfmt.h"
2: #include "cmd.h"
3:
4: #define RESET 1
5: #define LIST 2
6: #define DELETE 3
7: #define FORMAT 4
8: #define VERIFY 5
9: #define RELOCATE 6
10: #define CORRECT 7
11: #define INFO 8
12: #define PROFILE 9
13: #define EXERCISE 10
14: #define START 11
15:
16: static cmd_text_element commands[] = {
17: { RESET, "RESET", "Reinitialize VDFORMAT, and start over" },
18: { LIST, "List", "List operations specified so far" },
19: { DELETE, "Delete", "Delete specific operations" },
20: { FORMAT, "Format", "Format and verify disk surface" },
21: { VERIFY, "Verify", "Destructively verify disk surface" },
22: { RELOCATE, "Relocate", "Add known flaws to bad sector map" },
23: { CORRECT, "Correct", "Correct erroneous relocations or drive ID" },
24: { INFO, "Info", "Display known disk information" },
25: { PROFILE, "Profile", "Display seek profile graph of disk" },
26: { EXERCISE, "Exercise", "Perform seek exercises on disk" },
27: { START, "STARt", "Start operations" },
28: { 0, "", "" }
29: };
30:
31: static cmd_text_element drive_types[20];
32:
33:
34: /*
35: **
36: */
37:
38: process_commands()
39: {
40: int type, tokens[20];
41: int *tok_ptr, count;
42: int op_mask = 0;
43: char *cptr;
44: boolean should_start = false;
45:
46: for(type=0; type<nvddrv; type++) {
47: drive_types[type].cmd_token = (int)&vdst[type];
48: drive_types[type].cmd_text = vdst[type].type_name;
49: cptr = drive_types[type].cmd_text;
50: while(*cptr) {
51: *cptr = toupper(*cptr);
52: cptr++;
53: }
54: drive_types[type].cmd_help = vdst[type].type_discript;
55: }
56: drive_types[type].cmd_token = 0;
57: for(;;) {
58: cur.state = cmd;
59: kill_processes = false;
60: exdent(-1);
61: op_mask = 0;
62: print("Operation? ");
63: count = get_text_cmd(commands, tokens);
64: if(kill_processes == true)
65: _longjmp(quit_environ, 1);
66: tok_ptr = tokens;
67: if((*tok_ptr == 0) || !count)
68: continue;
69: while(*tok_ptr) {
70: switch (*tok_ptr) {
71: case RESET :
72: reset();
73: break;
74: case LIST :
75: list();
76: break;
77: case DELETE :
78: delete();
79: break;
80: case FORMAT :
81: op_mask |= FORMAT_OP;
82: break;
83: case VERIFY :
84: op_mask |= VERIFY_OP;
85: break;
86: case RELOCATE :
87: op_mask |= RELOCATE_OP;
88: break;
89: case CORRECT :
90: op_mask |= CORRECT_OP;
91: break;
92: case INFO :
93: op_mask |= INFO_OP;
94: break;
95: case PROFILE :
96: op_mask |= PROFILE_OP;
97: break;
98: case EXERCISE :
99: op_mask |= EXERCISE_OP;
100: break;
101: case START :
102: should_start = true;
103: break;
104: default: /* ignore */
105: break;
106: }
107: tok_ptr++;
108: }
109: if(op_mask) {
110: get_drive_parameters(op_mask);
111: }
112: if(should_start) {
113: start_commands();
114: should_start = false;
115: }
116: }
117: }
118:
119:
120: /*
121: **
122: */
123:
124: static boolean header_printed = false;
125:
126: get_drive_parameters(op_mask)
127: int op_mask;
128: {
129: int c_list[20], i, num_pat;
130:
131: indent();
132: header_printed = false;
133: get_ctlr_list(c_list, op_mask);
134: if(kill_processes == true) {
135: kill_processes = false;
136: c_list[0]= -1;
137: }
138: for(i=0; c_list[i] != -1; i++) {
139: int d_list[40], j;
140:
141: indent();
142: get_drive_list(c_list[i], d_list, op_mask);
143: if(kill_processes == true) {
144: kill_processes = false;
145: break;
146: }
147: indent();
148: if(op_mask & (FORMAT_OP | VERIFY_OP)) {
149: num_pat = get_num_pat();
150: if(kill_processes == true) {
151: kill_processes = false;
152: break;
153: }
154: }
155: for(j=0; d_list[j] != -1; j++) {
156: get_drive_type(c_list[i], d_list[j]);
157: if(kill_processes == true) {
158: kill_processes = false;
159: break;
160: }
161: if(op_mask & ~INFO_OP) {
162: indent();
163: get_drive_id(c_list[i], d_list[j]);
164: if(kill_processes == true) {
165: kill_processes = false;
166: break;
167: }
168: exdent(1);
169: }
170: ops_to_do[c_list[i]][d_list[j]].op |= op_mask;
171: if(op_mask & (FORMAT_OP | VERIFY_OP))
172: ops_to_do[c_list[i]][d_list[j]].numpat=num_pat;
173: }
174: exdent(1);
175: }
176: exdent(2);
177: }
178:
179: /*
180: **
181: */
182:
183: get_ctlr_list(c_list, op_mask)
184: int *c_list, op_mask;
185: {
186: extern int ctlr_help();
187: register int i, ctlr;
188: int table[MAXCTLR+10];
189:
190: i = 0;
191: for(ctlr=0; ctlr<MAXCTLR; ctlr++)
192: if(c_info[ctlr].alive == u_true)
193: table[i++] = ctlr;
194: table[i] = -1;
195: /* If only one controller is possible don't ask */
196: if(table[1] == -1) {
197: *c_list++ = table[0];
198: *c_list = -1;
199: return;
200: }
201: for(;;) {
202: header_printed = true;
203: print(""); /* Force indent */
204: print_op_list(op_mask);
205: printf(" on which controllers? ");
206: get_digit_list(c_list, table, ctlr_help);
207: if(kill_processes == true)
208: return;
209: if(*c_list != -1)
210: break;
211: }
212: }
213:
214:
215: /*
216: **
217: */
218:
219: ctlr_help()
220: {
221: register int ctlr;
222:
223: indent();
224: print("The following controllers are attached to the system:\n");
225: indent();
226: for(ctlr=0; ctlr<MAXCTLR; ctlr++)
227: if(c_info[ctlr].alive == u_true) {
228: print("Controller %d, which is a%s %s controller.\n",
229: ctlr, (c_info[ctlr].name[0] == 'S') ? "n" : "",
230: c_info[ctlr].name);
231: }
232: print("\n");
233: exdent(2);
234: }
235:
236: static int max_drive = 0;
237:
238: /*
239: **
240: */
241:
242: get_drive_list(ctlr, d_list, op_mask)
243: int ctlr, *d_list, op_mask;
244: {
245: extern int drive_help();
246: int table[MAXDRIVE+10];
247: int i;
248:
249: max_drive = (c_info[ctlr].type == SMDCTLR) ? 4 : 16;
250: for(i=0; i<max_drive; i++)
251: table[i] = i;
252: table[i] = -1;
253: for(;;) {
254: if(header_printed == true)
255: print("Drives on controller %d? ", ctlr);
256: else {
257: header_printed = true;
258: print(""); /* Force indent */
259: print_op_list(op_mask);
260: printf(" on which drives? ");
261: }
262: get_digit_list(d_list, table, drive_help);
263: if(kill_processes == true)
264: return;
265: if(*d_list != -1)
266: break;
267: }
268: }
269:
270:
271: /*
272: **
273: */
274:
275: get_drive_type(ctlr, drive)
276: int ctlr, drive;
277: {
278: int tokens[20];
279: int count;
280:
281: for(;;) {
282: print("Drive type for controller %d, drive %d? ", ctlr, drive);
283: if(d_info[ctlr][drive].info != 0)
284: printf("(%s) ", d_info[ctlr][drive].info->type_name);
285: if(c_info[ctlr].type == SMDCTLR)
286: count = get_text_cmd(drive_types+2, tokens);
287: else
288: count = get_text_cmd(drive_types, tokens);
289: if(kill_processes == true)
290: return;
291: if(!*tokens && (d_info[ctlr][drive].info != 0) && !count)
292: break;
293: if(d_info[ctlr][drive].info = (fs_tab *)*tokens)
294: break;
295: }
296: }
297:
298:
299:
300: /*
301: **
302: */
303:
304: id_help()
305: {
306: indent();
307: print("The following commands are available:\n");
308: indent();
309: print("STATus - Display formatter state.\n");
310: print("QUIT - Terminate current operation.\n");
311: print("");
312: print("A module serial can be any number greater than zero.\n");
313: exdent(2);
314: }
315:
316:
317: /*
318: **
319: */
320:
321: get_drive_id(ctlr, drive)
322: int ctlr, drive;
323: {
324: int new_id;
325:
326: for(;;) {
327: print("Module serial number for controller %d, drive %d? ",
328: ctlr, drive);
329: if(d_info[ctlr][drive].id != -1)
330: printf("(%d) ", d_info[ctlr][drive].id);
331: new_id = get_digit_cmd(id_help);
332: if(new_id > 0) {
333: d_info[ctlr][drive].id = new_id;
334: break;
335: }
336: else if(d_info[ctlr][drive].id != -1)
337: break;
338: }
339: }
340:
341:
342: /*
343: **
344: */
345:
346: drive_help()
347: {
348: indent();
349: print("Drive numbers 0 through %d may be entered.\n", max_drive-1);
350: exdent(1);
351: }
352:
353:
354: /*
355: **
356: */
357:
358: pat_help()
359: {
360: indent();
361: print("Between 0 and 16 patterns may be used while verifying.\n");
362: exdent(1);
363: }
364:
365:
366: /*
367: **
368: */
369:
370: get_num_pat()
371: {
372: int table[17+10];
373: int results[17+10];
374: int i;
375:
376: for(i=0; i<=16; i++)
377: table[i] = i;
378: table[i] = -1;
379: for(;;) {
380: print("Number of patterns to use while verifying? ");
381: get_digit_list(results, table, pat_help);
382: if(kill_processes == true)
383: return 0;
384: if(results[0] != -1)
385: break;
386: }
387: return results[0];
388: }
389:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.