![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to relocate.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / tahoestand / vdformat|
Return to relocate.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / tahoestand / vdformat |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)relocate.c 1.7 (Berkeley/CCI) 6/24/90";
3: #endif
4:
5: #include "vdfmt.h"
6: #include "cmd.h"
7:
8: /*
9: **
10: */
11:
12: relocate()
13: {
14: extern boolean is_formatted();
15:
16: cur.state = rel;
17: print("Adding flaws to bad sector map on ");
18: printf("controller %d, drive %d, ", cur.controller, cur.drive);
19: printf("type %s.\n", lab->d_typename);
20:
21: indent();
22: if(is_formatted() == true) {
23: if(read_bad_sector_map() == true)
24: if(bad_map->bs_id != D_INFO->id) {
25: print("Drive serial numbers do not match!\n");
26: exdent(1);
27: _longjmp(abort_environ, 1);
28: }
29: get_new_relocations();
30: cur.substate = sub_wmap;
31: sync_bad_sector_map();
32: }
33: else
34: print("Drive must be formatted befor relocations are done.\n");
35: exdent(1);
36: }
37:
38:
39: /*
40: **
41: */
42:
43: rel_help()
44: {
45: indent();
46: print("Relocation commands are in the following form:\n");
47: indent();
48: print("[a-h] (block) - UNIX file system block (%s-byte) number.\n",
49: DEV_BSIZE);
50: print("SEctor (sector) - Absolute sector number on disk.\n");
51: print("Track (track) - Absolute disk track number.\n");
52: print("(cylinder) (head) (offset) (length) - CDC flaw map format.\n");
53: print("STARt - Starts relocation process.\n\n");
54: exdent(2);
55: }
56:
57:
58: /*
59: **
60: */
61:
62: get_new_relocations()
63: {
64: char line[256];
65: char *ptr;
66: bs_entry entry;
67: dskadr dskaddr;
68: fmt_err dskerr;
69: int max_track;
70: register int block;
71:
72: dskaddr.cylinder = lab->d_ncylinders - 1;
73: dskaddr.track = lab->d_ntracks - 1;
74: max_track = to_track(dskaddr);
75: for(;;) {
76: print("Location? ");
77: get_string_cmd(line, rel_help);
78: if(kill_processes == true)
79: _longjmp(quit_environ, 1);
80: if(line[0] == '\0')
81: continue;
82: ptr = line;
83: trim_white(ptr);
84: if(!strncmp(ptr, "he", 2) || !strncmp(ptr, "?", 1) ||
85: !strncmp(ptr, "stat", 4) || !strncmp(ptr, "!", 1))
86: continue;
87: indent();
88: if((*ptr >= 'a') && (*ptr <= 'h')) {
89: register char par = *(ptr++);
90:
91: block = get_next_digit(ptr);
92: dskerr.err_adr = *from_unix((unsigned char)par,
93: (unsigned int)block);
94: if((dskerr.err_adr.cylinder == -1) || (block == -1)) {
95: print("Invalid UNIX block number!\n");
96: goto next;
97: }
98: print("Confirm block %d on file-system '%c'",block,par);
99: dskerr.err_stat = DATA_ERROR;
100: doreloc:
101: printf(" (cn %d tn %d sn %d)", dskerr.err_adr.cylinder,
102: dskerr.err_adr.track, dskerr.err_adr.sector);
103: if(get_yes_no("") == true) {
104: (*C_INFO->code_pos)(&dskerr, &entry);
105: add_user_relocations(&entry);
106: }
107: }
108: else if(*ptr == 't') {
109: block = get_next_digit(ptr);
110: if((block == -1) || (block >= max_track)) {
111: print("Invalid track number!\n");
112: goto next;
113: }
114: dskerr.err_adr = *from_track(block);
115: dskerr.err_stat = HEADER_ERROR;
116: print("Confirm track %d", block);
117: goto doreloc;
118: }
119: else if(!strncmp(ptr, "se", 2)) {
120: block = get_next_digit(ptr);
121:
122: if((block == -1) ||
123: ((lab->d_nsectors*lab->d_ntracks*lab->d_ncylinders)<block)){
124: print("Invalid sector number!\n");
125: goto next;
126: }
127: dskerr.err_adr = *from_sector((unsigned int)block);
128: dskerr.err_stat = DATA_ERROR;
129: goto doreloc;
130: }
131: else if(is_digit(*ptr)) {
132: entry.bs_cyl = get_next_digit(ptr);
133: skipdigits(ptr);
134: finddigit(ptr);
135: entry.bs_trk = get_next_digit(ptr);
136: skipdigits(ptr);
137: finddigit(ptr);
138: entry.bs_offset = get_next_digit(ptr);
139: skipdigits(ptr);
140: finddigit(ptr);
141: entry.bs_length = get_next_digit(ptr);
142: if((entry.bs_trk != -1) && (entry.bs_offset != -1) &&
143: (entry.bs_length != -1)) {
144: if(entry.bs_cyl >= lab->d_ncylinders)
145: print("Cylinder number to high!\n");
146: else if(entry.bs_trk >= lab->d_ntracks)
147: print("Head number to high!\n");
148: else if(entry.bs_offset >= lab->d_traksize)
149: print("Offset too long!\n");
150: else if(entry.bs_length == 0)
151: print("Can't have a 0 length error!\n");
152: else {
153: print("Confirm Cyl %d, ",entry.bs_cyl);
154: printf("Head %d, ", entry.bs_trk);
155: printf("offset %d, ", entry.bs_offset);
156: printf("length %d", entry.bs_length);
157: if(get_yes_no("") == true)
158: add_user_relocations(&entry);
159: }
160: }
161: else
162: goto bad;
163: }
164: else if(!strncmp(ptr, "start", 4)) {
165: exdent(1);
166: break;
167: }
168: else
169: bad: print("What?\n");
170: next: exdent(1);
171: }
172: }
173:
174: dskadr check_track_for_relocations(entry, i)
175: bs_entry entry;
176: register int i;
177: {
178: register int j = i;
179: fmt_err temp, cmp;
180: boolean bad_track = false;
181:
182: (*C_INFO->decode_pos)(&entry, &cmp);
183: /* Check to see if a alternate track is or will be on this track */
184: while((bad_map->list[j].bs_cyl == entry.bs_cyl) &&
185: (bad_map->list[j].bs_trk == entry.bs_trk)) {
186: (*C_INFO->decode_pos)(&bad_map->list[j], &temp);
187: if(temp.err_stat & HEADER_ERROR) {
188: bad_track = true;
189: /* if track was mapped out (it can't be us) */
190: if(((bad_map->list[j].bs_alt.cylinder != 0)) ||
191: (bad_map->list[j].bs_alt.track != 0) ||
192: (bad_map->list[j].bs_alt.sector != 0)) {
193: return cmp.err_adr;
194: }
195: }
196: j++;
197: }
198: /*
199: ** If it was a bad track and it was not the current entry
200: ** that produced it then then map it
201: ** to itself and forget about it for now since it will be taken
202: ** care of later.
203: **
204: ** If it was the current entry return zero and the track will be
205: ** mapped out correctly.
206: */
207: if(bad_track == true) {
208: if(cmp.err_stat & HEADER_ERROR)
209: return entry.bs_alt; /* better known as zero */
210: else
211: return cmp.err_adr;
212: }
213: /*
214: ** if we made it through all the bad track stuff then check for
215: ** multiple errors on the same sector that are already mapped!
216: */
217: j = i;
218: while((bad_map->list[j].bs_cyl == entry.bs_cyl) &&
219: (bad_map->list[j].bs_trk == entry.bs_trk)) {
220: (*C_INFO->decode_pos)(&bad_map->list[j], &temp);
221: if(temp.err_adr.sector == cmp.err_adr.sector) {
222: /* if it is not really the current entry */
223: if((bad_map->list[j].bs_offset != entry.bs_offset) ||
224: (bad_map->list[j].bs_length != entry.bs_length)) {
225: /* if the sector is already mapped out */
226: if(((bad_map->list[j].bs_alt.cylinder != 0)) ||
227: (bad_map->list[j].bs_alt.track != 0) ||
228: (bad_map->list[j].bs_alt.sector != 0)) {
229: return temp.err_adr;
230: }
231: }
232: }
233: j++;
234: }
235: return entry.bs_alt;
236: }
237:
238:
239: /*
240: **
241: */
242:
243: dskadr is_relocated(entry)
244: bs_entry entry;
245: {
246: register int i;
247:
248: for(i=0; i<bad_map->bs_count; i++)
249: if((bad_map->list[i].bs_cyl == entry.bs_cyl) &&
250: (bad_map->list[i].bs_trk == entry.bs_trk))
251: return check_track_for_relocations(entry, i);
252: return entry.bs_alt;
253: }
254:
255:
256:
257: /*
258: **
259: */
260:
261: sync_bad_sector_map()
262: {
263: register int i;
264: dskadr dskaddr;
265:
266: /*
267: ** do all the relocation cylinders first to allocate all flaws in
268: ** relocation area.
269: */
270: for(i=bad_map->bs_count-1; i>=0; i--) {
271: if((bad_map->list[i].bs_cyl >= lab->d_ncylinders-NUMSYS) &&
272: (bad_map->list[i].bs_cyl < lab->d_ncylinders-NUMMAP-NUMMNT)) {
273: if((bad_map->list[i].bs_alt.cylinder == 0) &&
274: (bad_map->list[i].bs_alt.track == 0) &&
275: (bad_map->list[i].bs_alt.sector == 0)) {
276: bad_map->list[i].bs_alt =
277: *new_location(&bad_map->list[i]);
278: }
279: }
280: }
281: for(i=bad_map->bs_count-1; i>=0; i--) {
282: if((bad_map->list[i].bs_alt.cylinder == 0) &&
283: (bad_map->list[i].bs_alt.track == 0) &&
284: (bad_map->list[i].bs_alt.sector == 0)) {
285: dskaddr = is_relocated(bad_map->list[i]);
286: if((dskaddr.cylinder == 0) && (dskaddr.track == 0) &&
287: (dskaddr.sector == 0)) {
288: bad_map->list[i].bs_alt =
289: *new_location(&bad_map->list[i]);
290: do_relocation(bad_map->list[i]);
291: }
292: else
293: bad_map->list[i].bs_alt = dskaddr;
294: }
295: }
296: write_bad_sector_map();
297: }
298:
299:
300:
301: /*
302: **
303: */
304:
305: do_relocation(entry)
306: bs_entry entry;
307: {
308: fmt_err temp;
309:
310: if(entry.bs_cyl >= lab->d_ncylinders-NUMSYS)
311: if(entry.bs_cyl != (lab->d_ncylinders - NUMMAP - NUMMNT))
312: return;
313: (*C_INFO->decode_pos)(&entry, &temp);
314: if((entry.bs_alt.cylinder == 0) && (entry.bs_alt.track == 0) &&
315: (entry.bs_alt.sector == 0))
316: print_unix_block(temp.err_adr);
317: else if(temp.err_stat & HEADER_ERROR)
318: if(C_INFO->type == VDTYPE_VDDC) {
319: print("Can't relocate tracks on VDDC controllers.\n");
320: print_unix_block(temp.err_adr);
321: }
322: else
323: relocate_track(entry);
324: else
325: relocate_sector(entry);
326: }
327:
328:
329: /*
330: **
331: */
332:
333: relocate_sector(entry)
334: bs_entry entry;
335: {
336: dskadr phys, reloc;
337: fmt_err temp;
338: register long status;
339:
340: (*C_INFO->decode_pos)(&entry, &temp);
341: phys = temp.err_adr;
342: reloc = entry.bs_alt;
343: format_sectors(&phys, &reloc, RELOC_SECTOR, (long)1);
344:
345: format_sectors(&reloc, &phys, ALT_SECTOR, (long)1);
346: status = access_dsk((char *)save, &temp.err_adr, VDOP_WD, 1, 1);
347: if(!((status & DCBS_ATA) && !(status & (DCBS_HARD|DCBS_SOFT)))) {
348: print(
349: "Sector relocation failed (c %d t %d s %d). Status = 0x%x.\n",
350: phys.cylinder, phys.track, phys.sector, status);
351: print_unix_block(phys);
352: }
353: }
354:
355:
356:
357: /*
358: **
359: */
360:
361: relocate_track(entry)
362: bs_entry entry;
363: {
364: dskadr phys, reloc;
365: fmt_err temp;
366: register long status;
367:
368: (*C_INFO->decode_pos)(&entry, &temp);
369: temp.err_adr.sector = 0;
370: phys = temp.err_adr;
371: reloc = entry.bs_alt;
372: reloc.sector = 0xff;
373: format_sectors(&phys, &reloc, RELOC_SECTOR, (long)lab->d_nsectors);
374:
375: reloc.sector = 0x00;
376: format_sectors(&reloc, &phys, ALT_SECTOR, (long)lab->d_nsectors);
377: status = access_dsk((char *)save, &temp.err_adr, VDOP_WD, lab->d_nsectors, 1);
378: if(!((status & DCBS_ATA) && !(status & (DCBS_HARD|DCBS_SOFT)))) {
379: print("Track relocation failed. Status = 0x%x.\n", status);
380: print_unix_block(phys);
381: }
382: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.