![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vdformat.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|
Return to vdformat.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / sys / stand |
1.1 root 1: /*
2: ** format disk on VDDC / SMD_E controller - (fsd/smd/xfd/xsd) type
3: **
4: ** Author: John R. Franks
5: **
6: ** This program is used to maintain drives attached to a VDDC controller.
7: ** The basic functions are 1) format media, 2) verify media, 3) relocate
8: ** bad blocks that have appeared on the media, and 4) Format and initialize the
9: ** maintenance cylinders on the drive.
10: **
11: ** For in depth information on the structure of this program please refer
12: ** to the comments above the individual subroutines in addition to the design
13: ** notes in vdutil.doc.
14: */
15:
16: #include <setjmp.h>
17: #include "../machine/mtpr.h"
18: #include "../h/param.h"
19: #include "../h/inode.h"
20: #include "../h/fs.h"
21: #include "../vba/vddc.h"
22: #include "../stand/saio.h"
23:
24: #define MAXCONTROLLER 4
25: #define MAXDRIVE 16
26:
27: #define NUMMNT 2
28: #define NUMREL 3
29: #define NUMSYS (NUMREL+NUMMNT)
30:
31: #define TRUE 1
32: #define FALSE 0
33:
34: #define MAXTRKS 24
35: #define MAXSECS_PER_TRK 48
36: #define MAXERR 1000
37: #define SECSIZ 512
38: #define TRKSIZ ((SECSIZ/sizeof(long)) * MAXSECS_PER_TRK)
39:
40: #define HARD_ERROR (DRVNRDY | INVDADR | DNEMEM | PARERR | OPABRT | \
41: WPTERR | DSEEKERR | NOTCYLERR)
42: #define DATA_ERROR (CTLRERR | UCDATERR | DCOMPERR | DSERLY | DSLATE | \
43: TOPLUS | TOMNUS | CPDCRT | \
44: HRDERR | SFTERR)
45: #define HEADER_ERROR (HCRCERR | HCMPERR)
46: #define NRM (short)0
47: #define BAD (short)VDUF
48: #define WPT (short)(NRM | VDWPT)
49: #define RELOC_SECTOR (short)(VDALT)
50: #define ALT_SECTOR (short)(VDALT)
51:
52: static jmp_buf environ;
53:
54: /* Free bad block allocation bit map */
55: typedef struct {
56: long error;
57: enum {ALLOCATED, NOTALLOCATED} freestatus;
58: } fmt_free;
59:
60:
61:
62: typedef enum {SINGLE_SECTOR, FULL_TRACK} rel_type;
63:
64: typedef struct {
65: dskadr err_adr;
66: long err_stat;
67: } fmt_err;
68:
69: static fmt_free free[NUMREL*MAXTRKS][MAXSECS_PER_TRK];
70: static fmt_err dsk_err[MAXERR];/* Disk error table */
71: static fmt_mdcb mdcb; /* Master device control block */
72: static fmt_dcb dcb; /* Device control blocks */
73: static int bad_secs = 0; /* Sequence # of last error detected */
74: static cdr *controller_address; /* controller physical address */
75: static int ctlr_num = 0; /* ctlr number */
76: static int unit_number = 0; /* unit number */
77: static int drive_type; /* disk type index */
78: static char *drive_name;
79: static int verify_count = 16;
80: static char *stars = "***************";
81: static char *sure_question = "This is DESTRUCTIVE! Are you sure";
82: static char *operation_string = 0;
83: static char *format_string = "Formatting";
84: static char *scan_string = "Scanning";
85: static char *relocate_string = "Relocation";
86: static char drives_to_do[MAXCONTROLLER][MAXDRIVE];
87: static char ctlr_type[MAXCONTROLLER] =
88: {UNKNOWN, UNKNOWN, UNKNOWN, UNKNOWN};
89: static char *controller_name[MAXCONTROLLER] =
90: {"Unknown","Unknown","Unknown","Unknown"};
91:
92: static long pattern_0[TRKSIZ], pattern_1[TRKSIZ];
93: static long pattern_2[TRKSIZ], pattern_3[TRKSIZ];
94: static long pattern_4[TRKSIZ], pattern_5[TRKSIZ];
95: static long pattern_6[TRKSIZ], pattern_7[TRKSIZ];
96: static long pattern_8[TRKSIZ], pattern_9[TRKSIZ];
97: static long pattern_10[TRKSIZ], pattern_11[TRKSIZ];
98: static long pattern_12[TRKSIZ], pattern_13[TRKSIZ];
99: static long pattern_14[TRKSIZ], pattern_15[TRKSIZ];
100:
101: static long *pattern_address[] = {
102: pattern_0, pattern_1, pattern_2, pattern_3,
103: pattern_4, pattern_5, pattern_6, pattern_7,
104: pattern_8, pattern_9, pattern_10, pattern_11,
105: pattern_12, pattern_13, pattern_14, pattern_15
106: };
107:
108: /* Double buffer for scanning existing file systems and general scratch */
109: static long scratch[TRKSIZ];
110: static long save[TRKSIZ];
111:
112: static long max_cyl;
113: static long max_trk;
114: static long max_sec;
115: static long sector_size;
116: static long num_slip;
117: static int max_drive;
118:
119: /*
120: ** Main, of course, is the entry point into vdfmt. It is responsible
121: ** for calling the routine for the get the disk parameters from the user,
122: ** creating and initializing the bad block patterns for scanning the disk, and
123: ** determining whether or not the user wants to format or relocate bad
124: ** blocks before calling the appropriate routines.
125: **
126: ** Formatting implies cerification of media and creation of the maintenance
127: ** cylinders and relocation of bad blocks.
128: */
129:
130: main()
131: {
132: register int index;
133: register int (*operation)();
134: register int controller, drive;
135: cdr *controller_address;
136: int (*get_operation_type())();
137:
138: printf("VDFORMAT Version 2.\n\n");
139: /* Identify which controllers are present and what type they are. */
140: for(controller = 0; controller < MAXCONTROLLER; controller++) {
141: controller_address = (cdr *)(vddcaddr[controller]|IOBASE);
142: if(!badaddr(controller_address, 2)) {
143: controller_address->cdr_reset = 0xffffffff;
144: DELAY(1000000);
145: if(controller_address->cdr_reset != 0xffffffff) {
146: ctlr_type[controller] = SMDCTLR;
147: controller_name[controller] = "SMD";
148: DELAY(1000000);
149: }
150: else {
151: ctlr_type[controller] = SMD_ECTLR;
152: controller_name[controller] = "SMD/E";
153: controller_address->cdr_reserved = 0x0;
154: DELAY(3000000);
155: }
156: printf("Controller #%d is an %s disk controller.\n",
157: controller, controller_name[controller]);
158: }
159: else
160: ctlr_type[controller] = UNKNOWN;
161: }
162: /* Get operation type */
163: operation = get_operation_type();
164: /* Read user input about disk parameters */
165: get_disk_parameters();
166: for(controller=0; controller<MAXCONTROLLER; controller++) {
167: max_drive = (ctlr_type[controller] == SMDCTLR) ? 4 : 16;
168: for(drive=0; drive<max_drive; drive++)
169: if(drives_to_do[controller][drive] != -1)
170: do_operation(controller, drive, operation);
171: }
172: }
173:
174: /*
175: ** Get_operation_type allows the user to choose which operation he / she
176: ** wants to perform on all the drives selected. It returns the address of that
177: ** function.
178: */
179:
180: int (*get_operation_type())()
181: {
182: extern int format_operation();
183: extern int scan_operation();
184: extern int relocate_operation();
185:
186: for(;;) {
187: if(get_yes_no("Do you want to format media"))
188: if(get_yes_no(sure_question)) {
189: get_number_of_patterns();
190: operation_string = format_string;
191: return format_operation;
192: }
193: if(get_yes_no("Do you want to scan an existing file system for bad sectors")) {
194: get_number_of_patterns();
195: operation_string = scan_string;
196: return scan_operation;
197: }
198: if(get_yes_no("Do you want to add bad sectors from manufacturer's list")) {
199: operation_string = relocate_string;
200: return relocate_operation;
201: }
202: printf("\nAn operation must be specified!\n\n");
203: }
204: }
205:
206: /*
207: ** Get_number_of_patterns reads and validates and sets the number of
208: ** patterns to use during a verification operation. If no string was typed
209: ** then the number of patterns defaults to four.
210: */
211:
212: get_number_of_patterns()
213: {
214: char count_string[10];
215:
216: for(;;) {
217: count_string[0] = (char)0;
218: printf("Number of patterns to use when verifying? [1-16]: (16) ");
219: gets(count_string);
220: if(count_string[0]) {
221: sscanf(count_string, "%d", &verify_count);
222: if ((verify_count >= 1) && (verify_count <= 16))
223: break;
224: printf("\nPattern count must be between 1 and 16.\n\n");
225: }
226: else {
227: printf("\nDefaulting to 16 patterns.\n\n");
228: verify_count = 16;
229: break;
230: }
231: }
232: }
233:
234: /*
235: ** This routine ask the user the controller number, unit number,
236: ** and the drive type of the drive to be formatted. When all information is
237: ** gathered and correct, then, the open() system routine is called to initialize
238: ** the controller and spin up drives if necessary. If the open fails the whole
239: ** process is started over again.
240: */
241:
242: get_disk_parameters()
243: {
244: register int at_least_one_drive_specified = 0;
245: register int controller, drive, type;
246:
247: for(controller = 0; controller < MAXCONTROLLER; controller++) {
248: max_drive = (ctlr_type[controller] == SMDCTLR) ? 4 : 16;
249: for(drive = 0; drive < max_drive; drive++)
250: drives_to_do[controller][drive] = -1;
251: }
252: printf("\nEnter controller number and drive number for each disk.\n");
253: printf("Key <RETURN> to controller number prompt when through.\n");
254: for(;;) {
255: if((controller = get_controller_number()) != -1) {
256: drive = get_drive_number(controller);
257: type = get_drive_type(controller);
258: printf("Is an '%s' drive on controller %d, unit %d ok",
259: vdst[type].type_name, controller, drive);
260: if(get_yes_no("")) {
261: drives_to_do[controller][drive] = type;
262: at_least_one_drive_specified = 1;
263: }
264: else
265: printf("\nEntry ignored.\n");
266: continue;
267: }
268: if(at_least_one_drive_specified)
269: break;
270: printf("You must specify at least one controller number!\n");
271: }
272: }
273:
274: /*
275: ** Get_controller_number reads, validates and returns a controller number.
276: */
277:
278: get_controller_number()
279: {
280: char controller[20];
281: int controller_number;
282: int i, controller_printed = FALSE;
283:
284: for(;;) {
285: printf("\nController number? [");
286: for(i=0; i<MAXCONTROLLER; i++)
287: if(ctlr_type[i] != UNKNOWN) {
288: if(controller_printed)
289: printf(", ");
290: controller_printed = TRUE;
291: printf("%d", i);
292: }
293: printf("]: ");
294: gets(controller);
295: if(!controller[0])
296: return -1;
297: if(!sscanf(controller, "%d", &controller_number)) {
298: printf("\nResponse must start with a digit!\n");
299: continue;
300: }
301: if ((controller_number >= 0) && (controller_number <= 3))
302: if(ctlr_type[controller_number] != UNKNOWN)
303: break;
304: printf("\nController number %d is illegal!\n",
305: controller_number);
306: }
307: return controller_number;
308: }
309:
310: /*
311: ** Get_drive_number reads, validates and returns a drive number.
312: */
313:
314: get_drive_number(controller)
315: int controller;
316: {
317: char drive_string[20];
318: int drive, max_drive;
319:
320: for(;;) {
321: max_drive = (ctlr_type[controller] == SMDCTLR) ? 3 : 15;
322: printf("Unit number? [0-%d]: ", max_drive);
323: gets(drive_string);
324: if(!drive_string[0]) {
325: printf("\nA drive number must be specified!\n\n");
326: continue;
327: }
328: if(!sscanf(drive_string, "%d", &drive)) {
329: printf("\nResponse must start with a digit!\n\n");
330: continue;
331: }
332: if((drive >= 0) && (drive <= max_drive))
333: break;
334: printf("\nDrive number %d is illegal!\n\n", drive);
335: }
336: return drive;
337: }
338:
339: /*
340: ** Do_operation executes the function wanted on all drive in the to_to
341: ** list.
342: */
343:
344: do_operation(controller, drive, operation)
345: int controller, drive;
346: int (*operation)();
347: {
348: int status;
349:
350: printf("\n%s %s on controller %d, drive %d, started. %s\n\n",
351: stars, operation_string, controller, drive, stars);
352: if(!(status = _setjmp(environ))) {
353: drive_name = "unknown";
354: init_environment_for_operation(controller, drive);
355: (*operation)();
356: printf("\n%s %s on controller %d, drive %d completed ok. %s\n",
357: stars, operation_string, controller, drive, stars);
358: return;
359: }
360: printf("\n%s %s on controller %d, drive %d ABORTED! %s\n",
361: stars, operation_string, controller, drive, stars);
362: return;
363: }
364:
365: /*
366: ** Init_environment_for_operation reset all the variables used by the
367: ** system to suit the new drive type.
368: */
369:
370: init_environment_for_operation(controller, drive)
371: int controller, drive;
372: {
373: register int index;
374:
375: ctlr_num = controller;
376: controller_address = (cdr *)(vddcaddr[controller]+IOBASE);
377: unit_number = drive;
378: drive_type = drives_to_do[controller][drive];
379: drive_name = vdst[drive_type].type_name;
380: max_cyl = vdst[drive_type].ncyl;
381: max_trk = vdst[drive_type].ntrak;
382: max_sec = vdst[drive_type].nsec;
383: sector_size = vdst[drive_type].secsize;
384: num_slip = vdst[drive_type].nslip;
385: bad_secs = 0;
386: /* Init bad block pattern array */
387: for(index=0; index<TRKSIZ; index++) {
388: pattern_0[index] = vdst[drive_type].fmt_pat[0];
389: pattern_1[index] = vdst[drive_type].fmt_pat[1];
390: pattern_2[index] = vdst[drive_type].fmt_pat[2];
391: pattern_3[index] = vdst[drive_type].fmt_pat[3];
392: pattern_4[index] = vdst[drive_type].fmt_pat[4];
393: pattern_5[index] = vdst[drive_type].fmt_pat[5];
394: pattern_6[index] = vdst[drive_type].fmt_pat[6];
395: pattern_7[index] = vdst[drive_type].fmt_pat[7];
396: pattern_8[index] = vdst[drive_type].fmt_pat[8];
397: pattern_9[index] = vdst[drive_type].fmt_pat[9];
398: pattern_10[index] = vdst[drive_type].fmt_pat[10];
399: pattern_11[index] = vdst[drive_type].fmt_pat[11];
400: pattern_12[index] = vdst[drive_type].fmt_pat[12];
401: pattern_13[index] = vdst[drive_type].fmt_pat[13];
402: pattern_14[index] = vdst[drive_type].fmt_pat[14];
403: pattern_15[index] = vdst[drive_type].fmt_pat[15];
404: }
405: spin_up_drive();
406: }
407:
408: /*
409: ** Spin_up_drive starts the drives on a controller and waits around for
410: ** the drive to spin up if it is not already spinning.
411: */
412:
413: spin_up_drive()
414: {
415: VDDC_RESET(controller_address, ctlr_type[ctlr_num]);
416: if(ctlr_type[ctlr_num] == SMD_ECTLR) {
417: ((cdr *)controller_address)->cdr_csr = 0;
418: ((cdr *)controller_address)->mdcb_tcf = AM_ENPDA;
419: ((cdr *)controller_address)->dcb_tcf = AM_ENPDA;
420: ((cdr *)controller_address)->trail_tcf = AM_ENPDA;
421: ((cdr *)controller_address)->data_tcf = AM_ENPDA;
422: ((cdr *)controller_address)->cdr_ccf = CCF_STS | XMD_32BIT |
423: BSZ_16WRD | CCF_ERR | CCF_ENP | CCF_EPE | CCF_EDE | CCF_ECE;
424: }
425: access_with_no_trailer(INIT, 10);
426: access_with_no_trailer(DIAG, 20);
427: configure_drive(0);
428: }
429:
430: /*
431: ** Access_with_no_trailer is used to perform controller functions which
432: ** require no data movement.
433: */
434:
435: access_with_no_trailer(function, wait_time)
436: int function, wait_time;
437: {
438: dcb.opcode = function; /* command */
439: dcb.intflg = NOINT;
440: dcb.nxtdcb = (fmt_dcb *)0; /* end of chain */
441: dcb.operrsta = 0;
442: dcb.devselect = (function == VDSTART) ? 0 : (char)unit_number;
443: dcb.trailcnt = (char)0;
444: mdcb.firstdcb = &dcb;
445: mdcb.vddcstat = 0;
446: VDDC_ATTENTION(controller_address, &mdcb, ctlr_type[ctlr_num]);
447: POLLTILLDONE(controller_address, &dcb, wait_time, ctlr_type[ctlr_num]);
448: if(vdtimeout <= 0) {
449: printf(" during startup operation.\n");
450: _longjmp(environ, 1);
451: }
452: return dcb.operrsta;
453: }
454:
455: /*
456: ** Configure_drive tells the controller what kind of drive is attached
457: ** on a particular line.
458: */
459:
460: configure_drive(pass)
461: int pass;
462: {
463: dcb.opcode = RSTCFG; /* command */
464: dcb.intflg = NOINT;
465: dcb.nxtdcb = (fmt_dcb *)0; /* end of chain */
466: dcb.operrsta = 0;
467: dcb.devselect = (char)unit_number;
468: dcb.trail.rstrail.ncyl = max_cyl;
469: dcb.trail.rstrail.nsurfaces = max_trk;
470: if(ctlr_type[ctlr_num] == SMDCTLR)
471: dcb.trailcnt = (char)2;
472: else {
473: dcb.trailcnt = (char)4;
474: dcb.trail.rstrail.nsectors = max_sec;
475: dcb.trail.rstrail.slip_sec = num_slip;
476: }
477: mdcb.firstdcb = &dcb;
478: mdcb.vddcstat = 0;
479: VDDC_ATTENTION(controller_address, &mdcb, ctlr_type[ctlr_num]);
480: POLLTILLDONE(controller_address, &dcb, 5, ctlr_type[ctlr_num]);
481: if(vdtimeout <= 0) {
482: printf(" during drive configuration.\n");
483: _longjmp(environ, 1);
484: }
485: if(dcb.operrsta & (NOTCYLERR | DRVNRDY)) {
486: if(pass) {
487: printf("\nDrive failed to start!\n\n");
488: _longjmp(environ, -1);
489: }
490: access_with_no_trailer(VDSTART, (unit_number*6)+62);
491: DELAY((unit_number * 5500000) + 62000000);
492: configure_drive(1);
493: }
494: }
495:
496: /*
497: ** Get_drive_type reads a drive type, validates it and returns the
498: ** validated drive type number to the calling routine.
499: */
500:
501: get_drive_type(controller)
502: register int controller;
503: {
504: char disk[10];
505:
506: for(;;) {
507: printf("Drive type? [fsd/smd/xfd");
508: if(ctlr_type[controller] == SMD_ECTLR)
509: printf("/fuj/xsd");
510: printf("]: ");
511: gets(disk);
512: if (!strcmp(disk,"fsd"))
513: return FSD;
514: if (!strcmp(disk,"smd"))
515: return SMD;
516: if (!strcmp(disk,"xfd"))
517: return XFD;
518: if(ctlr_type[controller] == SMD_ECTLR) {
519: if (!strcmp(disk,"fuj"))
520: return FUJ;
521: if (!strcmp(disk,"xsd"))
522: return XSD;
523: }
524: printf("Illegal drive type '%s'\n", disk);
525: }
526: }
527:
528: /*
529: ** Format_operation is the main routine for formatting a disk.
530: ** Take note the the first operation must be format_data_area due to a micro-
531: ** code bug in the controller. While formatting sectors one sector count is
532: ** lost every 64k sectors, so, on an fsd drive the last four sectors will
533: ** not be formatted. This is overcome by formatting the entire disk first, then
534: ** formatting the maintenance area, which happens to cover the last n sectors
535: ** that were lost.
536: */
537:
538: format_operation()
539: {
540: /* Format relocation area and data area */
541: format_data_area();
542: /* Verify the reloaction area and data area */
543: verify_data_area();
544: if(bad_secs)
545: relocate_bad_blocks();
546: /* Format maintenance cylinders for field service */
547: lay_maint_cylinders();
548: }
549:
550: /*
551: ** Relocate_operation() prompts the user for bad block numbers and adds
552: ** to the current bad block table. This process continues until a null response
553: ** is typed in when prompted for a bad block. The user is asked to verify that
554: ** the block number typed in is really the block that they wanted to relocate
555: ** before the tables are updated.
556: */
557:
558: relocate_operation()
559: {
560: long old_blk;
561: char nxt_blk[20];
562: dskadr daddr;
563: long last_block = max_cyl * max_trk * max_sec;
564:
565: bad_secs = 0;
566: printf("Just key <RETURN> when through entering sector numbers.\n");
567: while(bad_secs < MAXERR) {
568: printf("Sector number? ");
569: gets(nxt_blk);
570: if(!nxt_blk[0])
571: break;
572: sscanf(nxt_blk, "%ld", &old_blk);
573: if(old_blk >= last_block) {
574: printf("\nBlock number must be between 0 and %d!\n\n",
575: last_block - 1);
576: continue;
577: }
578: printf("Relocate sector #%ld", old_blk);
579: if(get_yes_no("")) {
580: daddr.sector = old_blk % max_sec;
581: daddr.track = (old_blk / max_sec) % max_trk;
582: daddr.cylinder = (old_blk / max_sec) / max_trk;
583: flag_sector(&daddr, 0);
584: }
585: else
586: printf("\nEntry ignored.\n");
587: printf("\n");
588: }
589: relocate_bad_blocks();
590: }
591:
592: /*
593: **
594: */
595:
596: scan_operation()
597: {
598: register int status, j=0;
599: dskadr daddr;
600: register int old_verify_count = verify_count;
601:
602: bad_secs = 0;
603: daddr.sector = 0;
604: for(daddr.cylinder=0;daddr.cylinder<(max_cyl-NUMSYS);daddr.cylinder++) {
605: if(j++ % 50) printf(".");
606: else printf("\n Scanning cylinder %d.", (int)daddr.cylinder);
607: for(daddr.track = 0; daddr.track < max_trk; daddr.track++) {
608: status = access(save, &daddr , FTR, 1, 1);
609: if(status & (HRDERR | SFTERR))
610: verify_count = 16;
611: verify_track(&daddr);
612: status = access(save, &daddr , FTW, 1, 1);
613: verify_count = old_verify_count;
614: }
615: }
616: printf("\n");
617: print_bad_sector_list();
618: print_number_of_bad_sectors("file system");
619: if(bad_secs)
620: relocate_bad_blocks();
621: }
622:
623: /*
624: ** This routine formats the user data area and bad block area of the disk.
625: */
626:
627: format_data_area()
628: {
629: register long sector_count;
630: dskadr zero;
631: register int index;
632:
633: printf("Formatting media...\n");
634: zero.cylinder = (short)0;
635: zero.track = (char)0;
636: zero.sector = (char)0;
637: sector_count = (long)(max_cyl * max_trk * max_sec);
638: format_sectors(&zero, &zero, NRM, sector_count);
639: printf("Formatting complete.\n");
640: }
641:
642: /*
643: ** This routine creates a bad block relocation area on disk and then
644: ** certifies the user data area of the disk.
645: */
646:
647: verify_data_area()
648: {
649: printf("Scanning for bad sectors...\n");
650: init_relocation_area();
651: verify_user_data_area();
652: printf("\nBad block scan complete.\n");
653: }
654:
655: /*
656: ** Vdinit_relocation_area certifies the bad block relocation area and flags
657: ** each bad block in the area as bad for later use by load_free_table(). No
658: ** relocation takes place.
659: */
660:
661: init_relocation_area()
662: {
663: printf(" Verifying bad sector relocation area...\n");
664: verify_cylinders((int)max_cyl - NUMSYS, NUMREL);
665: print_number_of_bad_sectors("relocation");
666: if(bad_secs)
667: mark_sectors_as_bad();
668: printf(" Relocation area verified.\n");
669: }
670:
671: /*
672: ** This routine certifies the area to be used for user data.
673: */
674:
675: verify_user_data_area()
676: {
677: int temp;
678:
679: printf(" Verifying file system area...\n");
680: verify_cylinders(0, (int)(max_cyl-NUMSYS));
681: print_number_of_bad_sectors("file system");
682: printf(" File system area verified.\n");
683: }
684:
685: /*
686: ** Vdlay_maint_cylinders creates the maintenance cylinders for field
687: ** service techs to run diagnostics on.
688: */
689:
690: lay_maint_cylinders()
691: {
692: dskadr daddr;
693: register long *pattern_ptr = (long *)&daddr;
694: register int index;
695:
696: printf("Creating maintenance cylinders...\n");
697: /* format read only cylinder */
698: daddr.cylinder = (short)(max_cyl - NUMMNT);
699: daddr.track = daddr.sector = (char)0;
700: format_sectors(&daddr, &daddr, NRM, (long)(NUMMNT * max_trk * max_sec));
701: printf(" Verifying maintenance area...\n");
702: verify_cylinders(daddr.cylinder, NUMMNT);
703: print_number_of_bad_sectors("maintenance");
704: printf(" Maintenance area verified.\n");
705: printf(" Writing Read / Write patterns.\n");
706: daddr.cylinder = (short)(max_cyl - NUMMNT);
707: for(daddr.track=0; daddr.track<max_trk; daddr.track++)
708: for(daddr.sector=0; daddr.sector<max_sec; daddr.sector++)
709: if(is_bad(&daddr)) {
710: extern rel_type new_location();
711: rel_type type;
712: dskadr naddr;
713:
714: type = new_location(&daddr, &naddr,
715: dsk_err[index].err_stat);
716: relocate(&daddr, &naddr, type);
717: }
718: printf(" Writing Read only patterns.\n");
719: for(daddr.cylinder++; daddr.cylinder<max_cyl; daddr.cylinder++) {
720: for(daddr.track=0; daddr.track<max_trk; daddr.track++)
721: for(daddr.sector = 0; daddr.sector < max_sec;
722: daddr.sector++) {
723: for(index=0; index<(sector_size/sizeof(long)); index++)
724: scratch[index] = *pattern_ptr;
725: if(is_bad(&daddr))
726: mark_bad_sector(&daddr, (short)VDWPT);
727: else
728: format_sectors(&daddr,&daddr,WPT,(long)1);
729: }
730: }
731: printf("Maintenance cylinders complete.\n");
732: }
733:
734: /*
735: ** Is_bad checks to see if a block is known to be bad already.
736: */
737:
738: is_bad(daddr)
739: dskadr *daddr;
740: {
741: register int index;
742:
743: for(index=0; index<bad_secs; index++)
744: if(daddr->cylinder == dsk_err[index].err_adr.cylinder)
745: if(daddr->track == dsk_err[index].err_adr.track)
746: if(daddr->sector==dsk_err[index].err_adr.sector)
747: return 1;
748: return 0;
749: }
750:
751: /*
752: ** verify_cylinders does full track certification for every track
753: ** on the cylinder. This is done for speed and minimal head movement. If
754: ** an error occurs on any single track the track is flagged for later
755: ** verification by verify sectors.
756: */
757:
758: verify_cylinders(base_cyl, cyl_count)
759: int base_cyl, cyl_count;
760: {
761: register int i, j = 0;
762: dskadr daddr;
763:
764: bad_secs = 0;
765: /* verify each track of each cylinder */
766: for (daddr.cylinder=base_cyl; daddr.cylinder<(base_cyl+cyl_count);
767: daddr.cylinder++) {
768: if(j++ % 50) printf(".");
769: else printf("\n Scanning cylinder %d.", (int)daddr.cylinder);
770: for (daddr.track = 0; daddr.track < max_trk; daddr.track++) {
771: verify_track(&daddr);
772: }
773: }
774: printf("\n");
775: print_bad_sector_list();
776: }
777:
778: /*
779: ** verify_track verifies a single track. If the full track write and
780: ** compare operation fails then each sector is read individually to determin
781: ** which sectors are really bad. If a sector is bad it is flagged as bad by
782: ** the verify sector routine.
783: */
784:
785: verify_track(daddr)
786: dskadr *daddr;
787: {
788: register int index, i;
789: register int count;
790: register long before;
791: register long *after;
792: register int status;
793: register long offset = sector_size / sizeof(long);
794: int pattern_count = verify_count;
795:
796: daddr->sector = (char)0;
797: access(pattern_address[0], daddr, FTW, 1, 1);
798: for(index = 0; index < pattern_count; index++) {
799: data_ok(dcb.operrsta);
800: if(dcb.operrsta & HEADER_ERROR) {
801: if(ctlr_type[ctlr_num]==SMDCTLR)
802: goto hard;
803: flag_sector(daddr, dcb.operrsta);
804: break;
805: }
806: if(status & DATA_ERROR)
807: pattern_count = 16;
808: status = access(scratch, daddr, FTR, 1, 1);
809: if(status & HEADER_ERROR) {
810: if(ctlr_type[ctlr_num]==SMDCTLR)
811: goto hard;
812: flag_sector(daddr, status);
813: break;
814: }
815: if(!data_ok(status)) {
816: pattern_count = 16;
817: for(i = 0; i < max_sec; i++) {
818: register long *next;
819:
820: daddr->sector = i;
821: next = &scratch[i * offset];
822: status = access(next, daddr, RD, 1, 1);
823: if(!data_ok(status))
824: flag_sector(daddr, status);
825: }
826: daddr->sector = (char)0;
827: }
828: if(index+1 < pattern_count)
829: access(pattern_address[index+1], daddr, FTW, 1, 0);
830: count = max_sec * offset;
831: before = *pattern_address[index];
832: after = scratch;
833: mtpr(0, PADC);
834: for(i=0; i<count; i++) {
835: if(before != *(after++)) {
836: daddr->sector = i / offset;
837: flag_sector(daddr, 0);
838: }
839: }
840: POLLTILLDONE(controller_address, &dcb, 60, ctlr_type[ctlr_num]);
841: if(vdtimeout <= 0) {
842: printf(" in verify_track.\n");
843: _longjmp(environ, 1);
844: }
845: }
846: return;
847:
848: hard: printf("\nSMD Controllers can't recover from header errors!");
849: printf(" Status = 0x%x\n", dcb.operrsta);
850: _longjmp(environ, dcb.operrsta);
851: }
852:
853: /*
854: ** Vdflag_sector makes an entry into the bad block table for the current
855: ** bad sector.
856: */
857:
858: flag_sector(daddr, status)
859: dskadr *daddr;
860: long status;
861: {
862: register int index;
863:
864: if(bad_secs < MAXERR) {
865: for(index=0; index<bad_secs; index++)
866: if((dsk_err[index].err_adr.cylinder==daddr->cylinder) &&
867: (dsk_err[index].err_adr.track == daddr->track) &&
868: (dsk_err[index].err_adr.sector==daddr->sector))
869: return;
870: dsk_err[bad_secs].err_adr.cylinder = daddr->cylinder;
871: dsk_err[bad_secs].err_adr.track = daddr->track;
872: dsk_err[bad_secs].err_adr.sector = daddr->sector;
873: dsk_err[bad_secs++].err_stat = status;
874: return;
875: }
876: printf("Maximum number of %d bad tracks exceeded!\n", MAXERR);
877: _longjmp(environ, MAXERR);
878: }
879:
880: /*
881: ** Print_bad_sector list tells the user which sectors are bad.
882: */
883:
884: print_bad_sector_list()
885: {
886: register int index;
887: register int sec;
888: dskadr daddr;
889:
890: if(bad_secs) {
891: printf(" The following sector");
892: if(bad_secs == 1)
893: printf(" is");
894: else
895: printf("s are");
896: printf(" bad:\n");
897: for(index=0; index<bad_secs; index++) {
898: sec = dsk_err[index].err_adr.cylinder * max_trk;
899: sec += dsk_err[index].err_adr.track;
900: sec *= max_sec;
901: sec += dsk_err[index].err_adr.sector;
902: printf(" %ld\n", sec);
903: }
904: }
905: }
906:
907: /*
908: ** Print_number_of_bad_sectors is used to announce to the user the
909: ** total number of bad sectors in a particular segment of the disk. Rules
910: ** of english for making a word plural are used to make a readable sentence.
911: */
912:
913: print_number_of_bad_sectors(str)
914: char *str;
915: {
916: if(bad_secs)
917: printf("\n %d", bad_secs);
918: else
919: printf("\n No");
920: printf(" bad sector");
921: if(bad_secs != 1)
922: printf("s");
923: printf(" found in %s area.\n", str);
924: }
925:
926: /*
927: ** Vdmark_sectors_as_bad marks every block in the current bad block
928: ** table as bad on the disk.
929: */
930:
931: mark_sectors_as_bad()
932: {
933: register int index;
934: dskadr daddr;
935:
936: for(index=0; index<bad_secs; index++) {
937: daddr.cylinder = dsk_err[index].err_adr.cylinder;
938: daddr.track = dsk_err[index].err_adr.track;
939: daddr.sector = dsk_err[index].err_adr.sector;
940: mark_bad_sector(&daddr, (short)0);
941: }
942: }
943:
944: /*
945: ** mark_bad_sector marks a single sector, on disk, as bad using the bad
946: ** block flags in the sector header.
947: */
948:
949: mark_bad_sector(daddr, flags)
950: dskadr *daddr;
951: short flags;
952: {
953: format_sectors(daddr, daddr, BAD | flags, (long)1);
954: }
955:
956:
957: /*
958: ** relocate_bad_blocks scans the current disk error table and relocates
959: ** every block that is flagged as bad in the table. At the beginning of the
960: ** routine the operator is given the chance to add blocks of his/her own to
961: ** the table.
962: */
963:
964: relocate_bad_blocks()
965: {
966: extern rel_type new_location();
967: register int index;
968: dskadr daddr, naddr;
969: rel_type type;
970:
971: printf("Relocating bad sectors...\n");
972: load_free_table();
973: for(index=0; index<bad_secs; index++) {
974: daddr.cylinder = dsk_err[index].err_adr.cylinder;
975: daddr.track = dsk_err[index].err_adr.track;
976: daddr.sector = dsk_err[index].err_adr.sector;
977: type = new_location(&daddr, &naddr, dsk_err[index].err_stat);
978: relocate(&daddr, &naddr, type);
979: }
980: printf("Relocation complete.\n");
981: }
982:
983: /*
984: ** Vdrelocate commands the controller to relocate a block from daddr
985: ** to naddr. Once this has been done the controller will automatically perform
986: ** relocation whenever data is transfered to or from daddr.
987: */
988:
989: relocate(daddr, naddr, type)
990: dskadr *daddr, *naddr;
991: rel_type type;
992: {
993: if(type == FULL_TRACK)
994: relocate_track(daddr, naddr);
995: else
996: relocate_sector(daddr, naddr);
997: }
998:
999:
1000: /*
1001: **
1002: */
1003:
1004: relocate_sector(daddr, naddr)
1005: dskadr *daddr, *naddr;
1006: {
1007: dskadr phys, reloc;
1008: register long blk;
1009: register long status;
1010:
1011: access(save, daddr, RD, 1, 1);
1012: phys.cylinder = daddr->cylinder;
1013: phys.track = daddr->track;
1014: phys.sector = daddr-> sector;
1015: reloc.cylinder = naddr->cylinder;
1016: reloc.track = naddr->track;
1017: reloc.sector = naddr->sector;
1018: format_sectors(&phys, &reloc, RELOC_SECTOR, (long)1);
1019:
1020: phys.cylinder = naddr->cylinder;
1021: phys.track = naddr->track;
1022: phys.sector = naddr->sector;
1023: reloc.cylinder = daddr->cylinder;
1024: reloc.track = daddr->track;
1025: reloc.sector = daddr->sector;
1026: format_sectors(&phys, &reloc, ALT_SECTOR, (long)1);
1027: blk = (daddr->cylinder * max_trk) + daddr->track;
1028: blk = (blk * max_sec) + daddr->sector;
1029: printf(" Sector #%ld ", blk);
1030: status = access(save, daddr, WD, 1, 1);
1031: if((status & ALTACC) && !(status & HRDERR)) {
1032: blk = (naddr->cylinder * max_trk) + naddr->track;
1033: blk = (blk * max_sec) + naddr->sector;
1034: printf("relocated to sector #%d.\n", blk);
1035: return;
1036: }
1037: printf("was not relocated successfully! Status = %lx\n", status);
1038: }
1039:
1040:
1041:
1042: /*
1043: **
1044: */
1045:
1046: relocate_track(daddr, naddr)
1047: dskadr *daddr, *naddr;
1048: {
1049: dskadr phys, reloc;
1050: register long blk;
1051: register long status;
1052:
1053: access(save, daddr, FTR, 1, 1);
1054: phys.cylinder = daddr->cylinder;
1055: phys.track = daddr->track;
1056: phys.sector = 0;
1057: reloc.cylinder = naddr->cylinder;
1058: reloc.track = naddr->track;
1059: reloc.sector = 0xff;
1060: format_sectors(&phys, &reloc, RELOC_SECTOR, max_sec);
1061:
1062: phys.cylinder = naddr->cylinder;
1063: phys.track = naddr->track;
1064: phys.sector = 0;
1065: reloc.cylinder = daddr->cylinder;
1066: reloc.track = daddr->track;
1067: reloc.sector = 0;
1068: format_sectors(&phys, &reloc, ALT_SECTOR, max_sec);
1069: blk = (daddr->cylinder * max_trk) + daddr->track;
1070: printf(" Track #%ld ", blk);
1071: status = access(save, daddr, FTW, 1, 1);
1072: if((status & ALTACC) && !(status & HRDERR)) {
1073: blk = (naddr->cylinder * max_trk) + naddr->track;
1074: printf("relocated to track #%d.\n", blk);
1075: return;
1076: }
1077: printf("was not relocated successfully! Status = %lx\n", status);
1078: }
1079:
1080: /*
1081: ** access is used by other routines to do reads and writes to the disk.
1082: ** The status of the read / write is returned to the caller for processing.
1083: */
1084:
1085: access(buf, daddr, func, count, wait)
1086: char *buf;
1087: dskadr *daddr;
1088: int func, count, wait;
1089: {
1090: dcb.opcode = func; /* format sector command */
1091: dcb.intflg = NOINT;
1092: dcb.nxtdcb = (fmt_dcb *)0; /* end of chain */
1093: dcb.operrsta = 0;
1094: dcb.devselect = (char)unit_number;
1095: dcb.trailcnt = (char)(sizeof(trrw) / 4);
1096: dcb.trail.rwtrail.memadr = buf;
1097: dcb.trail.rwtrail.wcount = count * (sector_size / sizeof(short));
1098: dcb.trail.rwtrail.disk.cylinder = daddr->cylinder;
1099: dcb.trail.rwtrail.disk.track = daddr->track;
1100: dcb.trail.rwtrail.disk.sector = daddr->sector;
1101: mdcb.firstdcb = &dcb;
1102: mdcb.vddcstat = 0;
1103: VDDC_ATTENTION(controller_address, &mdcb, ctlr_type[ctlr_num]);
1104: if(wait) {
1105: POLLTILLDONE(controller_address,&dcb,2*60,ctlr_type[ctlr_num]);
1106: if(vdtimeout <= 0) {
1107: printf(" in access.\n");
1108: _longjmp(environ, 1);
1109: }
1110: }
1111: return dcb.operrsta;
1112: }
1113:
1114: /*
1115: ** Vdformat_sectors is used to do the actual formatting of a block.
1116: */
1117:
1118: format_sectors(daddr, haddr, flags, count)
1119: dskadr *daddr, *haddr;
1120: short flags;
1121: long count;
1122: {
1123: dcb.opcode = FSECT; /* format sector command */
1124: dcb.intflg = NOINT;
1125: dcb.nxtdcb = (fmt_dcb *)0; /* end of chain */
1126: dcb.operrsta = 0;
1127: dcb.devselect = (char)unit_number;
1128: dcb.trailcnt = (char)(sizeof(trfmt) / 4);
1129: dcb.trail.fmtrail.addr = (char *)scratch;
1130: dcb.trail.fmtrail.nsectors = count;
1131: dcb.trail.fmtrail.disk.cylinder = daddr->cylinder | flags;
1132: dcb.trail.fmtrail.disk.track = daddr->track;
1133: dcb.trail.fmtrail.disk.sector = daddr->sector;
1134: dcb.trail.fmtrail.hdr.cylinder = haddr->cylinder | flags;
1135: dcb.trail.fmtrail.hdr.track = haddr->track;
1136: dcb.trail.fmtrail.hdr.sector = haddr->sector;
1137: mdcb.firstdcb = &dcb;
1138: mdcb.vddcstat = 0;
1139: VDDC_ATTENTION(controller_address, &mdcb, ctlr_type[ctlr_num]);
1140: POLLTILLDONE(controller_address, &dcb,
1141: ((count+849)/850)+120, ctlr_type[ctlr_num]);
1142: if(vdtimeout <= 0) {
1143: printf(" in format_sectors.\n");
1144: _longjmp(environ, 1);
1145: }
1146: if (!data_ok(dcb.operrsta)) {
1147: printf("Data error during format operation!\n");
1148: _longjmp(environ, dcb.operrsta);
1149: }
1150: }
1151:
1152: /*
1153: ** Print_dcb() dumps the MDCB and DCB for diagnostic purposes. This
1154: ** routine is called whenever a fatal error is encountered.
1155: */
1156:
1157: printdcb(ptr)
1158: register long *ptr;
1159: {
1160: register long i;
1161: register long trailer_count;
1162:
1163: printf("Dump of MDCB: ");
1164: for(i=0; i<4; i++)
1165: printf(" %lx", *(ptr+i));
1166: if(ptr = (long *)*ptr) {
1167: printf(" and DCB:");
1168: trailer_count = *(ptr+3) & 0xff;
1169: for(i=0; i<7+trailer_count; i++) {
1170: uncache(ptr+i);
1171: printf(" %lx", *(ptr+i));
1172: }
1173: }
1174: printf("\n");
1175: for(i=0; i<5000000; i++) ;
1176: }
1177:
1178:
1179: /*
1180: ** Vdload_free_table checks each block in the bad block relocation area
1181: ** to see if it is used. If it is, the free relocation block table is updated.
1182: */
1183:
1184: load_free_table()
1185: {
1186: dskadr daddr;
1187: register int i, j;
1188:
1189: /* Clear free table before starting */
1190: for(i = 0; i < (max_trk * NUMREL); i++)
1191: for(j = 0; j < max_sec; j++) {
1192: free[i][j].freestatus = NOTALLOCATED;
1193: free[i][j].error = (long)0;
1194: }
1195: /* For each relocation cylinder */
1196: for(daddr.cylinder = max_cyl-NUMSYS;
1197: daddr.cylinder < (max_cyl-NUMMNT); daddr.cylinder++)
1198: /* For each track on a cylinder */
1199: for(daddr.track = 0; daddr.track < max_trk; daddr.track++)
1200: /* For each sector on a track */
1201: for(daddr.sector=0;daddr.sector<max_sec;daddr.sector++)
1202: if(block_should_be_allocated(&daddr))
1203: allocate(&daddr, (long)0);
1204: }
1205:
1206: /*
1207: ** block_should_be_allocated does a read header and data command into
1208: ** a local buffer. The header address is then checked to see if the block
1209: ** has the relocation bit set or if the block was marked as bad. (either VDMF
1210: ** or VDUF or both bits set). In addition, if data data error is picked up
1211: ** during the read then the block should be allocated. If the block meets
1212: ** the above criteria then
1213: */
1214:
1215: block_should_be_allocated(daddr)
1216: dskadr *daddr;
1217: {
1218: /* return false if already replaced or either VDMF or VDUF is set */
1219: return (access(scratch, daddr, RD, 1, 1) & (HRDERR|SFTERR|ALTACC));
1220: }
1221:
1222: /*
1223: ** allocate marks a replacement sector as used.
1224: */
1225:
1226: allocate(daddr, status)
1227: dskadr *daddr;
1228: long status;
1229: {
1230: register long trk;
1231:
1232: trk = daddr->cylinder - (max_cyl - NUMSYS);
1233: trk *= max_trk;
1234: trk += daddr->track;
1235: free[trk][daddr->sector].freestatus = ALLOCATED;
1236: free[trk][daddr->sector].error = status;
1237: }
1238:
1239: /*
1240: ** Vdnew_location allocates a replacement block given a bad block address.
1241: ** The algorithm is fairly simple; it simply searches for the first
1242: ** free sector that has the same sector number of the bad sector. If no sector
1243: ** is found then the drive should be considered bad because of a microcode bug
1244: ** in the controller that forces us to use the same sector number as the bad
1245: ** sector for relocation purposes. Using different tracks and cylinders is ok
1246: ** of course.
1247: */
1248:
1249: rel_type new_location(daddr, naddr, status)
1250: dskadr *daddr, *naddr;
1251: long status;
1252: {
1253: register int index, sec;
1254:
1255: if(status & (HEADER_ERROR)) {
1256: for(index = 0; index < (max_trk * NUMREL); index++) {
1257: for(sec=0; sec < max_sec; sec++) {
1258: if(free[index][sec].freestatus == ALLOCATED)
1259: break;
1260: }
1261: if(sec == max_sec) {
1262: for(sec = 0; sec < max_sec; sec++) {
1263: free[index][sec].freestatus = ALLOCATED;
1264: free[index][sec].error = status;
1265: }
1266: naddr->cylinder=index/max_trk+(max_cyl-NUMSYS);
1267: naddr->track = index % max_trk;
1268: naddr->sector = 0;
1269: return FULL_TRACK;
1270: }
1271: }
1272: }
1273: for(index = 0; index < (max_trk * NUMREL); index++)
1274: if(free[index][daddr->sector].freestatus != ALLOCATED) {
1275: free[index][daddr->sector].freestatus = ALLOCATED;
1276: free[index][daddr->sector].error = status;
1277: naddr->cylinder = index / max_trk + (max_cyl - NUMSYS);
1278: naddr->track = index % max_trk;
1279: naddr->sector = daddr->sector;
1280: return SINGLE_SECTOR;
1281: }
1282: printf("Bad sector relocation area is full!");
1283: _longjmp(environ, daddr->sector);
1284: }
1285:
1286: /*
1287: ** data_ok checks an error status word for bit patterns
1288: ** associated with error conditions from the VDDC controller. If a hardware
1289: ** error is present then the problem is reported on the console and the program
1290: ** is halted. If a data error is present the a zero is returned.
1291: ** If everything is OK then a 1 is returned.
1292: */
1293:
1294: data_ok(status)
1295: long status;
1296: {
1297: if(status & HARD_ERROR){
1298: if(status & DRVNRDY)
1299: printf("\nDrive is not ready!");
1300: else if(status & INVDADR)
1301: printf("\nInvalid disk address issued!");
1302: else if(status & DNEMEM)
1303: printf("\nNon-existent memory error!");
1304: else if(status & PARERR)
1305: printf("\nMain memory parity error!");
1306: else if(status & OPABRT)
1307: printf("\nCPU aborted operation!");
1308: else if(status & WPTERR)
1309: printf("\nDrive is write protected!");
1310: else if(status & DSEEKERR)
1311: printf("\nDisk seek error!");
1312: else
1313: printf("\nNot on cylinder error!");
1314: printf(" Status = %lx\n", status);
1315: _longjmp(environ, -1);
1316: }
1317: return (int)(!(status & DATA_ERROR));
1318: }
1319:
1320: /*
1321: ** Vdget_yes_no is used to ask simple yes or no questions. The question
1322: ** prompt is supplied by the caller, The question mark, possible responses,
1323: ** and the default response is printed at the end of the prompt. The routine
1324: ** then reads the answer and returns a 1 if a 'y' is typed or no response was
1325: ** given, otherwise, a zero is returned.
1326: */
1327:
1328: get_yes_no(str)
1329: register char *str;
1330: {
1331: char answer[80];
1332:
1333: for(;;) {
1334: printf("%s? [y/n] (n): ", str);
1335: gets(answer);
1336: if((answer[0] == 'Y') || (answer[0] == 'y'))
1337: return(TRUE);
1338: if((answer[0] == 'N') || (answer[0] == 'n'))
1339: return(FALSE);
1340: printf("\nA 'Y' (yes) or 'N' (no) must be typed!\n\n");
1341: }
1342: }
1343:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.