Return to verify.c CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / sys / stand / vdfmt

Annotation of cci/sys/stand/vdfmt/verify.c, revision 1.1

1.1     ! root        1: #include       "vdfmt.h"
        !             2: 
        !             3: #define        quiet 0
        !             4: 
        !             5: /*
        !             6: **
        !             7: */
        !             8: 
        !             9: verify()
        !            10: {
        !            11:        extern boolean  read_bad_sector_map();
        !            12: 
        !            13:        cur.state = vfy;
        !            14:        print("Starting verification on ");
        !            15:        printf("controller %d, drive %d, ", cur.controller, cur.drive);
        !            16:        printf("type %s.\n",CURRENT->type_name);
        !            17: 
        !            18:        if(is_formatted() == true) {
        !            19:                if(read_bad_sector_map() == true) {
        !            20:                        if(bad_map->bs_id == D_INFO.id) {
        !            21:                                verify_users_data_area();
        !            22:                                return;
        !            23:                        }
        !            24:                }
        !            25:                print("I can't verify drives with old formats.\n");
        !            26:                return;
        !            27:        }
        !            28:        print("I can't verify unformatted drives.\n");
        !            29: }
        !            30: 
        !            31: 
        !            32: /*
        !            33: **
        !            34: */
        !            35: 
        !            36: load_verify_patterns()
        !            37: {
        !            38:        register int index;
        !            39: 
        !            40:        /* Init bad block pattern array */
        !            41:        for(index=0; index<TRKSIZ; index++) {
        !            42:                pattern_0[index] = CURRENT->fmt_pat[0];
        !            43:                pattern_1[index] = CURRENT->fmt_pat[1];
        !            44:                pattern_2[index] = CURRENT->fmt_pat[2];
        !            45:                pattern_3[index] = CURRENT->fmt_pat[3];
        !            46:                pattern_4[index] = CURRENT->fmt_pat[4];
        !            47:                pattern_5[index] = CURRENT->fmt_pat[5];
        !            48:                pattern_6[index] = CURRENT->fmt_pat[6];
        !            49:                pattern_7[index] = CURRENT->fmt_pat[7];
        !            50:                pattern_8[index] = CURRENT->fmt_pat[8];
        !            51:                pattern_9[index] = CURRENT->fmt_pat[9];
        !            52:                pattern_10[index] = CURRENT->fmt_pat[10];
        !            53:                pattern_11[index] = CURRENT->fmt_pat[11];
        !            54:                pattern_12[index] = CURRENT->fmt_pat[12];
        !            55:                pattern_13[index] = CURRENT->fmt_pat[13];
        !            56:                pattern_14[index] = CURRENT->fmt_pat[14];
        !            57:                pattern_15[index] = CURRENT->fmt_pat[15];
        !            58:        }
        !            59: }
        !            60: 
        !            61: 
        !            62: /*
        !            63: **
        !            64: */
        !            65: 
        !            66: verify_relocation_area()
        !            67: {
        !            68:        cur.substate = sub_vfy;
        !            69:        verify_cylinders((int)CURRENT->ncyl - NUMSYS, NUMREL, 16);
        !            70:        sync_bad_sector_map();
        !            71: }
        !            72: 
        !            73: 
        !            74: /*
        !            75: **
        !            76: */
        !            77: 
        !            78: verify_users_data_area()
        !            79: {
        !            80:        int     pats = ops_to_do[cur.controller][cur.drive].numpat;
        !            81: 
        !            82:        cur.substate = sub_vfy;
        !            83:        verify_cylinders(0, (int)CURRENT->ncyl - NUMSYS, pats);
        !            84:        sync_bad_sector_map();
        !            85: }
        !            86: 
        !            87: 
        !            88: /*
        !            89: **
        !            90: */
        !            91: 
        !            92: verify_maintainence_area()
        !            93: {
        !            94:        cur.substate = sub_vfy;
        !            95:        verify_cylinders(CURRENT->ncyl - NUMSYS + NUMREL, NUMMNT, 16);
        !            96:        sync_bad_sector_map();
        !            97: }
        !            98: 
        !            99: 
        !           100: /*
        !           101: **     verify_cylinders does full track certification for every track
        !           102: ** on the cylinder.  This is done for speed and minimal head movement.  If
        !           103: ** an error occurs on any single track the track is flagged for later
        !           104: ** verification by verify sectors.
        !           105: */
        !           106: 
        !           107: verify_cylinders(base_cyl, cyl_count, pats)
        !           108: int    base_cyl, cyl_count, pats;
        !           109: {
        !           110:        dskadr          dskaddr;
        !           111: 
        !           112:        /* verify each track of each cylinder */
        !           113:        for (dskaddr.cylinder=base_cyl; dskaddr.cylinder<(base_cyl+cyl_count);
        !           114:            dskaddr.cylinder++)
        !           115:                for (dskaddr.track=0; dskaddr.track<CURRENT->ntrak;
        !           116:                    dskaddr.track++)
        !           117:                        verify_track(&dskaddr, pats, quiet);
        !           118: }
        !           119: 
        !           120: 
        !           121: /*
        !           122: **     verify_track verifies a single track. If the full track write and
        !           123: ** compare operation fails then each sector is read individually to determin
        !           124: ** which sectors are really bad.  If a sector is bad it is flagged as bad by
        !           125: ** the verify sector routine.
        !           126: */
        !           127: 
        !           128: verify_track(dskaddr, pats, verbosity)
        !           129: dskadr *dskaddr;
        !           130: int    pats;
        !           131: int    verbosity;
        !           132: {
        !           133:        register int    index, i;
        !           134:        register int    count;
        !           135:        register long   before;
        !           136:        register long   *after;
        !           137:        register long   offset = CURRENT->secsize / sizeof(long);
        !           138:        int             pattern_count = pats;
        !           139: 
        !           140:        if(pats == 0)
        !           141:                return;
        !           142:        dskaddr->sector = (char)0;
        !           143:        access_dsk((char *)pattern_address[0], dskaddr, WD, CURRENT->nsec, 1);
        !           144:        for(index = 0; index < pattern_count; index++) {
        !           145:                if(!data_ok()) {
        !           146:                        if(dcb.operrsta & HEADER_ERROR)  {
        !           147:                                flag_sector(dskaddr, dcb.operrsta, verbosity);
        !           148:                                break;
        !           149:                        }
        !           150:                        if(dcb.operrsta & DATA_ERROR)
        !           151:                                pattern_count = 16;
        !           152:                }
        !           153:                access_dsk((char *)scratch,dskaddr,RD,CURRENT->nsec,1);
        !           154:                if(!data_ok()) {
        !           155:                        if(dcb.operrsta & HEADER_ERROR)  {
        !           156:                                flag_sector(dskaddr, dcb.operrsta, verbosity);
        !           157:                                break;
        !           158:                        }
        !           159:                        pattern_count = 16;
        !           160:                        for(i = 0; i < CURRENT->nsec; i++) {
        !           161:                                register long   *next;
        !           162: 
        !           163:                                dskaddr->sector = i;
        !           164:                                next = &scratch[i * offset];
        !           165:                                access_dsk((char *)next,dskaddr,RD,1,1);
        !           166:                                if(!data_ok()) {
        !           167:                                        flag_sector(dskaddr,
        !           168:                                            dcb.operrsta,verbosity);
        !           169:                                }
        !           170:                        }
        !           171:                        dskaddr->sector = (char)0;
        !           172:                }
        !           173:                if(index+1 < pattern_count)
        !           174:                        access_dsk((char *)pattern_address[index+1],
        !           175:                            dskaddr, WD, CURRENT->nsec, 0);
        !           176:                count = CURRENT->nsec * offset;
        !           177:                before = *pattern_address[index];
        !           178:                after = scratch;
        !           179:                for(i=0; i<count; i++) {
        !           180:                        if(before != *(after++)) {
        !           181:                                dskaddr->sector = i / offset;
        !           182:                                flag_sector(dskaddr, DATA_ERROR, verbosity);
        !           183:                        }
        !           184:                }
        !           185:                if(index+1 <= pattern_count) {
        !           186:                        poll(60);
        !           187:                        if(vdtimeout <= 0) {
        !           188:                                printf(" while verifing track.\n");
        !           189:                                _longjmp(abort_environ, 1);
        !           190:                        }
        !           191:                }
        !           192:                if(kill_processes == true) {
        !           193:                        sync_bad_sector_map();
        !           194:                        _longjmp(quit_environ, 1);
        !           195:                }
        !           196:        }
        !           197: }
        !           198: 
        !           199: 
        !           200: flag_sector(dskaddr, status, verbose)
        !           201: dskadr *dskaddr;
        !           202: long   status;
        !           203: int    verbose;
        !           204: {
        !           205:        fmt_err         error;
        !           206:        bs_entry        entry;
        !           207: 
        !           208:        indent();
        !           209:        if(verbose) {
        !           210:                print("Error at sector %d, status=0x%x.",
        !           211:                    to_sector(*dskaddr), status);
        !           212:                printf("  Sector will be relocated.\n");
        !           213:        }
        !           214:        if(is_in_map(dskaddr) == false) {
        !           215:                error.err_adr = *dskaddr;
        !           216:                error.err_stat = status;
        !           217:                entry = (*C_INFO.code_pos)(error);
        !           218:                add_flaw(&entry);
        !           219:        }
        !           220:        exdent(1);
        !           221: }

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