Annotation of 43BSDTahoe/sys/tahoestand/vdformat/correct.c, revision 1.1.1.1

1.1       root        1: #ifndef lint
                      2: static char sccsid[] = "@(#)correct.c  1.3 (Berkeley/CCI) 6/7/88";
                      3: #endif
                      4: 
                      5: #include       "vdfmt.h"
                      6: #include       "cmd.h"
                      7: 
                      8: /*
                      9: **
                     10: */
                     11: 
                     12: correct()
                     13: {
                     14:        cur.state = cor;
                     15:        print("Making corrections to bad sector map on ");
                     16:        printf("controller %d, drive %d, ", cur.controller, cur.drive);
                     17:        printf("type %s.\n", lab->d_typename);
                     18: 
                     19:        indent();
                     20:        if(is_formatted() == true)
                     21:                if(read_bad_sector_map() == true) {
                     22:                        get_corrections();
                     23:                        cur.substate = sub_wmap;
                     24:                        sync_bad_sector_map();
                     25:                }
                     26:                else 
                     27:                        print("There is no bad sector map on this drive!\n");
                     28:        else
                     29:                print("Drive must be formatted befor corrections are done.\n");
                     30:        exdent(1);
                     31: }
                     32: 
                     33: 
                     34: /*
                     35: **
                     36: */
                     37: 
                     38: cor_help()
                     39: {
                     40:        indent();
                     41:        print("Correction commands are in the following form:\n");
                     42:        indent();
                     43:        print("ID              -  Correct module serial number.\n");
                     44:        print("[a-h] (block)   -  UNIX file system format.\n");
                     45:        print("SEctor (sector) -  Absolute sector number on disk.\n");
                     46:        print("Track (track)   -  Absolute disk track number.\n");
                     47:        print("(cylinder) (head) (offset) (length) - CDC flaw map format.\n");
                     48:        print("CLEAR           -  Remove all relocations not from flaw map.\n");
                     49:        print("STARt           -  Ends correction process.\n\n");
                     50:        exdent(2);
                     51: }
                     52: 
                     53: 
                     54: /*
                     55: **
                     56: */
                     57: 
                     58: get_corrections()
                     59: {
                     60:        extern int      id_help();
                     61:        char            line[256];
                     62:        char            *ptr;
                     63:        bs_entry        entry;
                     64:        dskadr          dskaddr;
                     65:        fmt_err         dskerr;
                     66:        int             max_track;
                     67:        register int    block;
                     68: 
                     69:        dskaddr.cylinder = lab->d_ncylinders - 1;
                     70:        dskaddr.cylinder = lab->d_ntracks - 1;
                     71:        max_track = to_track(dskaddr);
                     72:        indent();
                     73:        for(;;) {
                     74:                print("Location? ");
                     75:                get_string_cmd(line, cor_help);
                     76:                if(kill_processes == true)
                     77:                        break;
                     78:                if(line[0] == '\0')
                     79:                        continue;
                     80:                ptr = line;
                     81:                trim_white(ptr);
                     82:                if(!strncmp(ptr, "he", 2) || !strncmp(ptr, "?", 1) ||
                     83:                    !strncmp(ptr, "stat", 4) || !strncmp(ptr, "!", 1))
                     84:                        continue;
                     85:                indent();
                     86:                if(!strncmp(ptr, "id", 2)) {
                     87:                        register int    temp;
                     88: 
                     89:                        for(;;) {
                     90:                                print("Pack ID is %d. Change to? ",
                     91:                                    bad_map->bs_id);
                     92:                                temp = get_digit_cmd(id_help);
                     93:                                if(temp > 0)
                     94:                                        break;
                     95:                        }
                     96:                        D_INFO->id = bad_map->bs_id = temp;
                     97:                } else if (!strcmp(ptr, "clear")) {
                     98:                        print(
                     99:                     "Confirm removal of ALL relocations installed manually\n");
                    100:                        if (get_yes_no("or by verification") == true)
                    101:                                clear_relocations(true);
                    102:                }
                    103:                else if((*ptr  >= 'a') && (*ptr <= 'h')) {
                    104:                        register char   par = *ptr++;
                    105: 
                    106:                        block = get_next_digit(ptr);
                    107:                        dskerr.err_adr = *from_unix((unsigned char)par,
                    108:                            (unsigned int)block);
                    109:                        if((dskerr.err_adr.cylinder == -1) || (block == -1)) {
                    110:                                print("Invalid UNIX block number!\n");
                    111:                                goto    next;
                    112:                        }
                    113:                        print("Confirm block %d on file-system '%c'",block,par);
                    114:                        dskerr.err_stat = DATA_ERROR;
                    115:                doreloc:
                    116:                        printf(" (cn %d tn %d bn %d)", dskerr.err_adr.cylinder,
                    117:                            dskerr.err_adr.track, dskerr.err_adr.sector);
                    118:                        if(get_yes_no("") == true) {
                    119:                                (*C_INFO->code_pos)(&dskerr, &entry);
                    120:                                remove_user_relocations(&entry);
                    121:                        }
                    122:                }
                    123:                else if(*ptr == 't') {
                    124:                        block = get_next_digit(ptr);
                    125:                        if((block == -1) || (block >= max_track)) {
                    126:                                print("Invalid track number!\n");
                    127:                                goto    next;
                    128:                        }
                    129:                        dskerr.err_adr = *from_track(block);
                    130:                        dskerr.err_stat = HEADER_ERROR;
                    131:                        print("Confirm track %d", block);
                    132:                        goto doreloc;
                    133:                }
                    134:                else if(!strncmp(ptr, "se", 2)) {
                    135:                        block = get_next_digit(ptr);
                    136:                        if (block == -1 ||
                    137:                            block > lab->d_nsectors*lab->d_ntracks*lab->d_ncylinders) {
                    138:                                print("Invalid sector number!\n");
                    139:                                goto    next;
                    140:                        }
                    141:                        dskerr.err_adr = *from_sector((unsigned int)block);
                    142:                        dskerr.err_stat = DATA_ERROR;
                    143:                        print("Confirm sector %d", block);
                    144:                        goto doreloc;
                    145:                }
                    146:                else if(is_digit(*ptr)) {
                    147:                        entry.bs_cyl = get_next_digit(ptr);
                    148:                        skipdigits(ptr);
                    149:                        finddigit(ptr);
                    150:                        entry.bs_trk = get_next_digit(ptr);
                    151:                        skipdigits(ptr);
                    152:                        finddigit(ptr);
                    153:                        entry.bs_offset = get_next_digit(ptr);
                    154:                        skipdigits(ptr);
                    155:                        finddigit(ptr);
                    156:                        entry.bs_length = get_next_digit(ptr);
                    157:                        if((entry.bs_trk != -1) && (entry.bs_offset != -1) &&
                    158:                            (entry.bs_length != -1)) {
                    159:                                if(entry.bs_cyl >= lab->d_ncylinders)
                    160:                                        print("Cylinder number to high!\n");
                    161:                                else if(entry.bs_trk >= lab->d_ntracks)
                    162:                                        print("Head number to high!\n");
                    163:                                else if(entry.bs_offset >= lab->d_traksize)
                    164:                                        print("Offset too long!\n");
                    165:                                else if(entry.bs_length == 0)
                    166:                                        print("Can't have a 0 length error!\n");
                    167:                                else {
                    168:                                        print("Confirm  Cyl %d, ",entry.bs_cyl);
                    169:                                        printf("Head %d, ", entry.bs_trk);
                    170:                                        printf("offset %d, ", entry.bs_offset);
                    171:                                        printf("length %d", entry.bs_length);
                    172:                                        if(get_yes_no("") == true)
                    173:                                                remove_user_relocations(&entry);
                    174:                                }
                    175:                        }
                    176:                        else
                    177:                                goto bad;
                    178:                } else if(!strncmp(ptr, "star", 4)) {
                    179:                        exdent(1);
                    180:                        break;
                    181:                }
                    182:                else
                    183: bad:                   print("What?\n");
                    184: next:          exdent(1);
                    185:        }
                    186:        exdent(1);
                    187: }
                    188: 

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.