![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bad144.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / etc|
Return to bad144.c CVS log | Up to [CSRG BSD Unix] / 43BSD / etc |
1.1 root 1: /*
2: * Copyright (c) 1980 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: char copyright[] =
9: "@(#) Copyright (c) 1980 Regents of the University of California.\n\
10: All rights reserved.\n";
11: #endif not lint
12:
13: #ifndef lint
14: static char sccsid[] = "@(#)bad144.c 5.4 (Berkeley) 3/20/86";
15: #endif not lint
16:
17: /*
18: * bad144
19: *
20: * This program prints and/or initializes a bad block record for a pack,
21: * in the format used by the DEC standard 144.
22: * It can also add bad sector(s) to the record, moving the sector
23: * replacements as necessary.
24: *
25: * It is preferable to write the bad information with a standard formatter,
26: * but this program will do.
27: *
28: * RP06 sectors are marked as bad by inverting the format bit in the
29: * header; on other drives the valid-sector bit is cleared.
30: */
31: #include <sys/types.h>
32: #include <sys/dkbad.h>
33: #include <sys/ioctl.h>
34: #include <sys/file.h>
35: #include <machine/dkio.h>
36:
37: #include <stdio.h>
38: #include <disktab.h>
39:
40: #define RETRIES 10 /* number of retries on reading old sectors */
41:
42: int fflag, add, copy, verbose, nflag;
43: int compare();
44: struct dkbad dkbad, oldbad;
45: daddr_t size, getold(), badsn();
46: struct disktab *dp;
47: char name[BUFSIZ];
48: char *malloc();
49: off_t lseek();
50:
51: main(argc, argv)
52: int argc;
53: char *argv[];
54: {
55: register struct bt_bad *bt;
56: daddr_t sn, bn[126];
57: int i, f, nbad, new, bad, errs;
58:
59: argc--, argv++;
60: while (argc > 0 && **argv == '-') {
61: (*argv)++;
62: while (**argv) {
63: switch (**argv) {
64: case 'f':
65: fflag++;
66: break;
67: case 'a':
68: add++;
69: break;
70: case 'c':
71: copy++;
72: break;
73: case 'v':
74: verbose++;
75: break;
76: case 'n':
77: nflag++;
78: verbose++;
79: break;
80: }
81: (*argv)++;
82: }
83: argc--, argv++;
84: }
85: if (argc < 2) {
86: fprintf(stderr,
87: "usage: bad144 [ -f ] type disk [ snum [ bn ... ] ]\n");
88: fprintf(stderr,
89: "to read or overwrite bad-sector table, e.g.: bad144 rk07 hk0\n");
90: fprintf(stderr,
91: "or bad144 -a [ -f ] [ -c ] type disk bn ...\n");
92: fprintf(stderr, "where options are:\n");
93: fprintf(stderr, "\t-a add new bad sectors to the table\n");
94: fprintf(stderr, "\t-f reformat listed sectors as bad\n");
95: fprintf(stderr, "\t-c copy original sector to replacement\n");
96: exit(1);
97: }
98: dp = getdiskbyname(argv[0]);
99: if (dp == NULL) {
100: fprintf(stderr, "%s: unknown disk type\n", argv[0]);
101: exit(1);
102: }
103: if (argv[1][0] != '/')
104: (void)sprintf(name, "/dev/r%sc", argv[1]);
105: else
106: (void)strcpy(name, argv[1]);
107: argc -= 2;
108: argv += 2;
109: size = dp->d_nsectors * dp->d_ntracks * dp->d_ncylinders;
110: if (argc == 0) {
111: f = open(name, O_RDONLY);
112: if (f < 0)
113: Perror(name);
114: sn = getold(f, &dkbad);
115: printf("bad block information at sector %d in %s:\n",
116: sn, name);
117: printf("cartridge serial number: %d(10)\n", dkbad.bt_csn);
118: switch (dkbad.bt_flag) {
119:
120: case -1:
121: printf("alignment cartridge\n");
122: break;
123:
124: case 0:
125: break;
126:
127: default:
128: printf("bt_flag=%x(16)?\n", dkbad.bt_flag);
129: break;
130: }
131: bt = dkbad.bt_bad;
132: for (i = 0; i < 126; i++) {
133: bad = (bt->bt_cyl<<16) + bt->bt_trksec;
134: if (bad < 0)
135: break;
136: printf("sn=%d, cn=%d, tn=%d, sn=%d\n", badsn(bt),
137: bt->bt_cyl, bt->bt_trksec>>8, bt->bt_trksec&0xff);
138: bt++;
139: }
140: (void) checkold();
141: exit(0);
142: }
143: f = open(name, (fflag || add)? O_RDWR: O_WRONLY);
144: if (f < 0)
145: Perror(name);
146: if (add) {
147: /*
148: * Read in the old badsector table.
149: * Verify that it makes sense, and the bad sectors
150: * are in order. Copy the old table to the new one.
151: */
152: (void) getold(f, &oldbad);
153: i = checkold();
154: if (verbose)
155: printf("Had %d bad sectors\n", i);
156: if (i + argc > 126) {
157: printf("bad144: not enough room for %d more sectors\n",
158: argc);
159: printf("limited to 126 by information format\n");
160: exit(1);
161: }
162: dkbad = oldbad;
163: } else {
164: dkbad.bt_csn = atoi(*argv++);
165: argc--;
166: dkbad.bt_mbz = 0;
167: if (argc > 126) {
168: printf("bad144: too many bad sectors specified\n");
169: printf("limited to 126 by information format\n");
170: exit(1);
171: }
172: i = 0;
173: }
174: errs = 0;
175: new = argc;
176: while (argc > 0) {
177: daddr_t sn = atoi(*argv++);
178: argc--;
179: if (sn < 0 || sn >= size) {
180: printf("%d: out of range [0,%d) for %s\n",
181: sn, size, dp->d_name);
182: errs++;
183: continue;
184: }
185: bn[i] = sn;
186: dkbad.bt_bad[i].bt_cyl = sn / (dp->d_nsectors*dp->d_ntracks);
187: sn %= (dp->d_nsectors*dp->d_ntracks);
188: dkbad.bt_bad[i].bt_trksec =
189: ((sn/dp->d_nsectors) << 8) + (sn%dp->d_nsectors);
190: i++;
191: }
192: if (errs)
193: exit(1);
194: nbad = i;
195: while (i < 126) {
196: dkbad.bt_bad[i].bt_trksec = -1;
197: dkbad.bt_bad[i].bt_cyl = -1;
198: i++;
199: }
200: if (add) {
201: /*
202: * Sort the new bad sectors into the list.
203: * Then shuffle the replacement sectors so that
204: * the previous bad sectors get the same replacement data.
205: */
206: qsort((char *)dkbad.bt_bad, nbad, sizeof (struct bt_bad),
207: compare);
208: shift(f, nbad, nbad-new);
209: }
210: for (i = 0; i < 10 && i < dp->d_nsectors; i += 2) {
211: if (lseek(f, dp->d_secsize * (size - dp->d_nsectors + i),
212: L_SET) < 0)
213: Perror("lseek");
214: if (verbose)
215: printf("write badsect file at %d\n",
216: size - dp->d_nsectors + i);
217: if (nflag == 0 &&
218: write(f, (caddr_t)&dkbad, sizeof dkbad) != sizeof dkbad) {
219: char msg[80];
220: (void)sprintf(msg, "bad144: write bad sector file %d",
221: i/2);
222: perror(msg);
223: }
224: }
225: if (fflag)
226: for (i = nbad - new; i < nbad; i++)
227: format(f, bn[i]);
228: exit(0);
229: }
230:
231: daddr_t
232: getold(f, bad)
233: struct dkbad *bad;
234: {
235: register int i;
236: daddr_t sn;
237: char msg[80];
238:
239: for (i = 0; i < 10 && i < dp->d_nsectors; i += 2) {
240: sn = size - dp->d_nsectors + i;
241: if (lseek(f, sn * dp->d_secsize, L_SET) < 0)
242: Perror("lseek");
243: if (read(f, (char *)bad, sizeof (*bad)) == sizeof (*bad)) {
244: if (i > 0)
245: printf("Using bad-sector file %d\n", i/2);
246: return(sn);
247: }
248: (void)sprintf(msg, "bad144: read bad sector file at sn %d",
249: sn);
250: perror(msg);
251: }
252: fprintf(stderr,
253: "bad144: %s: can't read bad block info\n", name);
254: exit(1);
255: /*NOTREACHED*/
256: }
257:
258: checkold()
259: {
260: register int i;
261: register struct bt_bad *bt;
262: daddr_t sn, lsn;
263: int errors = 0, warned = 0;
264:
265: if (oldbad.bt_flag != 0) {
266: fprintf(stderr, "bad144: %s: bad flag in bad-sector table\n",
267: name);
268: errors++;
269: }
270: if (oldbad.bt_mbz != 0) {
271: fprintf(stderr, "bad144: %s: bad magic number\n", name);
272: errors++;
273: }
274: lsn = 0;
275: bt = oldbad.bt_bad;
276: for (i = 0; i < 126; i++, bt++) {
277: if (bt->bt_cyl == -1 && bt->bt_trksec == -1)
278: break;
279: if ((bt->bt_cyl >= dp->d_ncylinders) ||
280: ((bt->bt_trksec >> 8) >= dp->d_ntracks) ||
281: ((bt->bt_trksec & 0xff) >= dp->d_nsectors)) {
282: fprintf(stderr,
283: "bad144: cyl/trk/sect out of range in existing entry: ");
284: fprintf(stderr, "sn=%d, cn=%d, tn=%d, sn=%d\n",
285: badsn(bt), bt->bt_cyl, bt->bt_trksec>>8,
286: bt->bt_trksec & 0xff);
287: errors++;
288: }
289: sn = (bt->bt_cyl * dp->d_ntracks +
290: (bt->bt_trksec >> 8)) *
291: dp->d_nsectors + (bt->bt_trksec & 0xff);
292: if (sn < lsn && !warned) {
293: fprintf(stderr, "bad144: bad sector file out of order\n");
294: errors++;
295: warned++;
296: }
297: lsn = sn;
298: }
299: if (errors)
300: exit(1);
301: return (i);
302: }
303:
304: /*
305: * Move the bad sector replacements
306: * to make room for the new bad sectors.
307: * new is the new number of bad sectors, old is the previous count.
308: */
309: shift(f, new, old)
310: {
311: daddr_t repl;
312:
313: /*
314: * First replacement is last sector of second-to-last track.
315: */
316: repl = size - dp->d_nsectors - 1;
317: new--; old--;
318: while (new >= 0 && new != old) {
319: if (old < 0 ||
320: compare(&dkbad.bt_bad[new], &oldbad.bt_bad[old]) > 0) {
321: /*
322: * Insert new replacement here-- copy original
323: * sector if requested and possible,
324: * otherwise write a zero block.
325: */
326: if (!copy ||
327: !blkcopy(f, badsn(&dkbad.bt_bad[new]), repl - new))
328: blkzero(f, repl - new);
329: } else {
330: if (blkcopy(f, repl - old, repl - new) == 0)
331: fprintf(stderr,
332: "Can't copy replacement sector %d to %d\n",
333: repl-old, repl-new);
334: old--;
335: }
336: new--;
337: }
338: }
339:
340: char *buf;
341:
342: /*
343: * Copy disk sector s1 to s2.
344: */
345: blkcopy(f, s1, s2)
346: daddr_t s1, s2;
347: {
348: register tries, n;
349:
350: if (buf == (char *)NULL) {
351: buf = malloc((unsigned)dp->d_secsize);
352: if (buf == (char *)NULL) {
353: fprintf(stderr, "Out of memory\n");
354: exit(20);
355: }
356: }
357: if (lseek(f, dp->d_secsize * s1, L_SET) < 0)
358: Perror("lseek");
359: for (tries = 0; tries < RETRIES; tries++)
360: if ((n = read(f, buf, dp->d_secsize)) == dp->d_secsize)
361: break;
362: if (n != dp->d_secsize) {
363: fprintf(stderr, "bad144: can't read sector, %d: ", s1);
364: if (n < 0)
365: perror((char *)0);
366: return(0);
367: }
368: if (lseek(f, dp->d_secsize * s2, L_SET) < 0)
369: Perror("lseek");
370: if (verbose)
371: printf("copying %d to %d\n", s1, s2);
372: if (nflag == 0 && write(f, buf, dp->d_secsize) != dp->d_secsize) {
373: fprintf(stderr,
374: "bad144: can't write replacement sector, %d: ", s2);
375: perror((char *)0);
376: return(0);
377: }
378: return(1);
379: }
380:
381: char *zbuf;
382:
383: blkzero(f, sn)
384: daddr_t sn;
385: {
386:
387: if (zbuf == (char *)NULL) {
388: zbuf = malloc((unsigned)dp->d_secsize);
389: if (zbuf == (char *)NULL) {
390: fprintf(stderr, "Out of memory\n");
391: exit(20);
392: }
393: }
394: if (lseek(f, dp->d_secsize * sn, L_SET) < 0)
395: Perror("lseek");
396: if (verbose)
397: printf("zeroing %d\n", sn);
398: if (nflag == 0 && write(f, zbuf, dp->d_secsize) != dp->d_secsize) {
399: fprintf(stderr,
400: "bad144: can't write replacement sector, %d: ", sn);
401: perror((char *)0);
402: }
403: }
404:
405: compare(b1, b2)
406: register struct bt_bad *b1, *b2;
407: {
408: if (b1->bt_cyl > b2->bt_cyl)
409: return(1);
410: if (b1->bt_cyl < b2->bt_cyl)
411: return(-1);
412: return (b1->bt_trksec - b2->bt_trksec);
413: }
414:
415: daddr_t
416: badsn(bt)
417: register struct bt_bad *bt;
418: {
419: return ((bt->bt_cyl*dp->d_ntracks + (bt->bt_trksec>>8)) * dp->d_nsectors
420: + (bt->bt_trksec&0xff));
421: }
422:
423: struct rp06hdr {
424: short h_cyl;
425: short h_trksec;
426: short h_key1;
427: short h_key2;
428: char h_data[512];
429: #define RP06_FMT 010000 /* 1 == 16 bit, 0 == 18 bit */
430: };
431:
432: /*
433: * Most massbus and unibus drives
434: * have headers of this form
435: */
436: struct hpuphdr {
437: u_short hpup_cyl;
438: u_char hpup_sect;
439: u_char hpup_track;
440: char hpup_data[512];
441: #define HPUP_OKSECT 0xc000 /* this normally means sector is good */
442: #define HPUP_16BIT 0x1000 /* 1 == 16 bit format */
443: };
444: int rp06format(), hpupformat();
445:
446: struct formats {
447: char *f_name; /* disk name */
448: int f_bufsize; /* size of sector + header */
449: int f_bic; /* value to bic in hpup_cyl */
450: int (*f_routine)(); /* routine for special handling */
451: } formats[] = {
452: { "rp06", sizeof (struct rp06hdr), RP06_FMT, rp06format },
453: { "eagle", sizeof (struct hpuphdr), HPUP_OKSECT, hpupformat },
454: { "capricorn", sizeof (struct hpuphdr), HPUP_OKSECT, hpupformat },
455: { "rm03", sizeof (struct hpuphdr), HPUP_OKSECT, hpupformat },
456: { "rm05", sizeof (struct hpuphdr), HPUP_OKSECT, hpupformat },
457: { "9300", sizeof (struct hpuphdr), HPUP_OKSECT, hpupformat },
458: { "9766", sizeof (struct hpuphdr), HPUP_OKSECT, hpupformat },
459: { 0, 0, 0, 0 }
460: };
461:
462: /*ARGSUSED*/
463: hpupformat(fp, dp, blk, buf, count)
464: struct formats *fp;
465: struct disktab *dp;
466: daddr_t blk;
467: char *buf;
468: int count;
469: {
470: struct hpuphdr *hdr = (struct hpuphdr *)buf;
471: int sect;
472:
473: if (count < sizeof(struct hpuphdr)) {
474: hdr->hpup_cyl = (HPUP_OKSECT | HPUP_16BIT) |
475: (blk / (dp->d_nsectors * dp->d_ntracks));
476: sect = blk % (dp->d_nsectors * dp->d_ntracks);
477: hdr->hpup_track = (u_char)(sect / dp->d_nsectors);
478: hdr->hpup_sect = (u_char)(sect % dp->d_nsectors);
479: }
480: return (0);
481: }
482:
483: /*ARGSUSED*/
484: rp06format(fp, dp, blk, buf, count)
485: struct formats *fp;
486: struct disktab *dp;
487: daddr_t blk;
488: char *buf;
489: int count;
490: {
491:
492: if (count < sizeof(struct rp06hdr)) {
493: fprintf(stderr, "Can't read header on blk %d, can't reformat\n",
494: blk);
495: return (-1);
496: }
497: return (0);
498: }
499:
500: format(fd, blk)
501: int fd;
502: daddr_t blk;
503: {
504: register struct formats *fp;
505: static char *buf;
506: static char bufsize;
507: int n;
508:
509: for (fp = formats; fp->f_name; fp++)
510: if (strcmp(dp->d_name, fp->f_name) == 0)
511: break;
512: if (fp->f_name == 0) {
513: fprintf(stderr, "bad144: don't know how to format %s disks\n",
514: dp->d_name);
515: exit(2);
516: }
517: if (buf && bufsize < fp->f_bufsize) {
518: free(buf);
519: buf = NULL;
520: }
521: if (buf == NULL)
522: buf = malloc((unsigned)fp->f_bufsize);
523: if (buf == NULL) {
524: fprintf(stderr, "bad144: can't allocate sector buffer\n");
525: exit(3);
526: }
527: bufsize = fp->f_bufsize;
528: /*
529: * Here we do the actual formatting. All we really
530: * do is rewrite the sector header and flag the bad sector
531: * according to the format table description. If a special
532: * purpose format routine is specified, we allow it to
533: * process the sector as well.
534: */
535: if (lseek(fd, (long)blk * dp->d_secsize, L_SET) < 0)
536: Perror("lseek");
537: if (verbose)
538: printf("format blk %d\n", blk);
539: if (ioctl(fd, DKIOCHDR, (char *)0) < 0)
540: Perror("ioctl");
541: if ((n = read(fd, buf, fp->f_bufsize)) < 0)
542: bzero(buf, fp->f_bufsize);
543: if (fp->f_bic) {
544: struct hpuphdr *xp = (struct hpuphdr *)buf;
545:
546: xp->hpup_cyl &= ~fp->f_bic;
547: }
548: if (fp->f_routine)
549: if ((*fp->f_routine)(fp, dp, blk, buf, n) != 0)
550: return;
551: if (lseek(fd, (long)blk * dp->d_secsize, L_SET) < 0)
552: Perror("lseek");
553: if (nflag)
554: return;
555: if (ioctl(fd, DKIOCHDR, (char *)0) < 0)
556: Perror("ioctl");
557: if (write(fd, buf, fp->f_bufsize) != fp->f_bufsize) {
558: char msg[80];
559: (void)sprintf(msg, "bad144: write format %d", blk);
560: perror(msg);
561: }
562: }
563:
564: Perror(op)
565: char *op;
566: {
567:
568: fprintf(stderr, "bad144: "); perror(op);
569: exit(4);
570: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.