![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to verify.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 verify.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / sys / stand / vdfmt |
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.