![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to badscan.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / etc|
Return to badscan.c CVS log | Up to [MW Coherent from dump] / coherent / d / etc |
1.1 root 1: /*
2: * badscan.c
3: * 2/7/91
4: * Usage: badscan [-v] [-o proto] [-b boot] device count
5: * device device to be scanned (e.g. /dev/rat0a)
6: * count size of file system to be scanned
7: * sdev master boot record for device size info (e.g. /dev/at0x)
8: * Options:
9: * -b boot use "boot" for boot in prototype file (default: /conf/boot)
10: * -o proto output file name for prototype file (default: stdout)
11: * -v verbose messages as to the percentage of file system scanned
12: *
13: * Due to Inetco's braindamaged notion of removing stdio from everything, this
14: * does not #include <stdio.h> and uses sys write() calls to fd 1 and fd 2 in
15: * lieu of stdout and stderr. This should be fixed when someone gets the urge.
16: *
17: * $Log: /newbits/etc/badscan.c,v $
18: * Revision 1.6 91/02/22 12:14:25 bin
19: * updated version provided by stevesf for v311
20: *
21: * Revision 1.7 91/02/07 12:36:00 bin
22: * steve 2/7/91
23: * Following norm's suggestion, SCSI badscan now issues warning but
24: * the continues with block-by-block scan of device.
25: *
26: * Revision 1.6 91/02/07 09:58:21 bin
27: * steve 2/7/91
28: * Added include of <sys/devices.h>, changed explicitly declared floppy
29: * and hard disk major device manifest constants accordingly.
30: * Added check for major==SCSI; if so, print "SCSI devices do not require
31: * badscan" and exit successfully.
32: * Added "badscan:" at start of fatal() messages.
33: * Added comment moaning about Inetco avoiding stdio.
34: *
35: * Revision 1.5 90/04/20 09:01:50 bin
36: * steve 4/20/90
37: * Previous version failed on floppy disks because HDGETA ioctl only works
38: * on hard disks. Now it checks the major number, does HDGETA to find
39: * tracksize on hard disk and uses tracksize=1 (sector by sector scan)
40: * on floppies. Future: should add FDGETA ioctl to floppy driver and
41: * let badscan (and mkfs) find default floppy size automatically.
42: *
43: * Revision 1.4 90/04/19 14:08:36 bin
44: * steve 4/19/90
45: * Change -v messages slightly for use during install;
46: * use '\r' instead of '\n', overwrite with "Done\n" when finished.
47: *
48: * Revision 1.3 90/03/27 08:33:48 bin
49: * steve 03/27/90
50: * Mark entire bad track as bad rather than reading each sector in track.
51: *
52: * Revision 1.2 90/03/22 09:57:41 root
53: * Find sectors per track with ioctl rather than assuming 17.
54: * Rearranged code, changed fatal error messages, changed screwy spacing.
55: * steve 3/22/90
56: *
57: * 88/03/23 Allan Cornish /usr/src/cmd/etc/badscan.c
58: * Reads are no longer attempted past logical end of partition,
59: * when a logical track straddles the partition boundary.
60: *
61: * 88/01/27 Jim Belton /usr/src/cmd/etc/badscan.c
62: * Fixed bug for counts >= 32K by declaring atol().
63: *
64: * 86/11/03 Joe Iu
65: * Added -o and -b options, where the protofile and the boot file name
66: * can be specified by the user explicitly.
67: *
68: * 85/12/03 Allan Cornish
69: * Multi-sector read algorithm adjusted to ensure track alignment,
70: * even on track 0 where master boot block is not included in partition.
71: *
72: * 85/11/16 Allan Cornish
73: * Added track reads, with block by block retry on error.
74: *
75: * 85/11/13 Allan Cornish
76: * Added estimate of time remaining to each progress report.
77: *
78: * 85/11/06 Allan Cornish
79: * Added -v flag to report progress every 10 percent of scan.
80: *
81: * 88/07/11 Jim Napier
82: * Modified sput() to retry write if returns zero. This was causing an
83: * invalid prototype file to be created when using the Seagate ST-251
84: * hard disk which contains bad blocks.
85: */
86:
87: #include <sys/stat.h>
88: #include <sys/devices.h>
89: #include <sys/fdisk.h>
90: #include <sys/hdioctl.h>
91:
92: #define BUFSIZ 512
93: #define MAXUINT ((unsigned)65535L)
94: #define NULL ((char *)0)
95: #define TRUE (0 == 0)
96:
97: /*
98: * External functions.
99: */
100: extern long atol();
101: extern char *malloc();
102:
103: /*
104: * Forward referenced functions.
105: */
106: void bad();
107: void fatal();
108: void lput();
109: void sput();
110: void usage();
111:
112: /*
113: * Global variables.
114: */
115: char *bfile = "/conf/boot";
116: int bflag;
117: int oflag;
118: struct stat sb;
119: int vflag;
120:
121: /**
122: * main - validate number and type of arguments.
123: * - scan device (arg1) for bad blocks until lim (arg2) reached.
124: * - generate a mkfs prototype file on standard output or the
125: * designated protofile.
126: */
127: main(argc, argv) register int argc; register char *argv[];
128: {
129: register int n;
130: long bno;
131: long incr;
132: long lim;
133: long t0, t1;
134: int percent;
135: int nspt;
136: char *buf;
137: hdparm_t hdparms;
138: unsigned int tracksize;
139: unsigned long base;
140:
141: /*
142: * Read options declared.
143: */
144: while((--argc > 0) && ((*++argv)[0] == '-')) {
145:
146: if((*argv)[2] != '\0')
147: usage();
148:
149: switch((*argv)[1]) {
150:
151: case 'v':
152: if(vflag)
153: usage();
154: vflag = TRUE;
155: break;
156:
157: case 'o':
158: if(oflag || (--argc <= 0))
159: usage();
160: oflag = TRUE;
161:
162: /*
163: * Open protofile to store badscan information.
164: */
165: close(1);
166: if(creat(*++argv, 0644) == -1)
167: fatal("cannot create ", *argv);
168: break;
169:
170: case 'b':
171: if(bflag || (--argc <= 0))
172: usage();
173:
174: bflag = TRUE;
175: /*
176: * Set boot file name.
177: */
178: bfile = *++argv;
179: break;
180:
181: default:
182: usage();
183: break;
184: }
185: }
186:
187: /*
188: * Check to ensure that only arg1 and arg2 are available.
189: */
190: if (argc != 2)
191: usage();
192:
193: /*
194: * The first argument not associated with an option must be a
195: * character or block special file.
196: */
197: if (stat(argv[0], &sb) < 0)
198: fatal("cannot stat: ", argv[0]);
199: sb.st_mode &= S_IFMT;
200: if ((sb.st_mode != S_IFCHR) && (sb.st_mode != S_IFBLK))
201: fatal("not a device special file: ", argv[0]);
202: if ((n = major(sb.st_rdev)) == SCSI_MAJOR)
203: sput(2, "badscan: warning: SCSI devices do not require badscan\n");
204: else if (n != AT_MAJOR && n != FL_MAJOR)
205: fatal("not a disk device: ", argv[0]);
206:
207: /*
208: * Open the special file (arg1).
209: * Find the size of a track.
210: */
211: close(0);
212: if (open(argv[0], 0) == -1)
213: fatal("cannot open: ", argv[0]);
214: if (n == AT_MAJOR) {
215: /* Get hard disk track size with ioctl. */
216: if (ioctl(0, HDGETA, (char *)&hdparms) == -1)
217: fatal("cannot get disk device parameters: ", argv[0]);
218: tracksize = hdparms.nspt;
219: } else {
220: /* Badscan a floppy disk or a SCSI disk. */
221: /* Floppy ioctl FDGETA should be implemented but is not (yet). */
222: #if 0
223: /* Kludge: this code knows floppy minor to tracksize mapping. */
224: n = minor(sb.st_rdev) & 7;
225: if (n < 3) /* minor 0, 1, 2, 8, 9, 10, ... */
226: tracksize = 8;
227: else if (n < 6) /* minor 3, 4, 5, 11, 12, 13, ... */
228: tracksize = 9;
229: else if (n == 6) /* minor 6, 14, ... */
230: tracksize = 15;
231: else /* minor 7, 15, ... */
232: fatal("unsupported minor number", argv[0]);
233: #else
234: /* Scan block by block for now. */
235: tracksize = 1;
236: #endif
237: }
238:
239: /*
240: * Allocate a track buffer.
241: */
242: if (tracksize > MAXUINT/BUFSIZ || (buf = malloc(tracksize * BUFSIZ)) == NULL)
243: fatal("cannot allocate track buffer", "");
244:
245: /*
246: * Validate and evaluate length (arg2)
247: */
248: lim = atol(argv[1]);
249: if (lim <= 0) {
250:
251: register struct hdisk_s *hp;
252: int f2;
253:
254: if ((f2 = open(argv[1], 0)) < 0)
255: fatal("bad size: ", argv[1]);
256: if (read(f2, buf, 512) != 512)
257: fatal("cannot read: ", argv[1]);
258: close(f2);
259: hp = buf;
260: if (hp->hd_sig != HDSIG)
261: fatal("bad partition table: ", argv[1]);
262: lim = hp->hd_partn[ sb.st_rdev & 3 ].p_size;
263: base = hp->hd_partn[ sb.st_rdev & 3 ].p_base;
264: nspt = tracksize - base % tracksize;
265: if (lim <= 0)
266: fatal("null partition: ", argv[1]);
267: }
268:
269: /*
270: * Create header for mkfs prototype file.
271: */
272: sput(1, bfile);
273: sput(1, "\n");
274: lput(1, lim);
275: sput(1, " ");
276: lput(1, (lim/6 + 7) & ~7L); /* ensure ninode is multiple of 8 */
277: percent = 10;
278: incr = lim / 10;
279: time(&t0);
280:
281: /*
282: * Scan for bad blocks.
283: * The first and last tracks may have less than tracksize sectors.
284: */
285: for (bno=0; bno < lim; (bno += nspt), (nspt = tracksize)) {
286:
287: /*
288: * Try a track read first.
289: */
290: lseek(0, bno * BUFSIZ, 0);
291:
292: /*
293: * Avoid reading past end of partition.
294: */
295: if (bno + nspt > lim)
296: nspt = lim - bno;
297:
298: /* Mark each block in a bad track as bad. */
299: if (read(0, buf, (nspt * BUFSIZ)) != (nspt * BUFSIZ))
300: for (n=0; n < nspt; ++n)
301: bad(bno+n);
302:
303: /*
304: * Periodically generate reports
305: */
306: if (vflag && (bno >= incr) && (bno < lim)) {
307:
308: /*
309: * Estimate seconds remaining to next 1/10 minute.
310: */
311: time(&t1);
312: t1 = (t1 - t0) * (100 - percent);
313: t1 += percent - 1;
314: t1 /= percent;
315: t1 += 5;
316:
317: lput(2, (long) percent);
318: sput(2, "% done: ");
319: if (t1 < 6000)
320: sput(2, " ");
321: if (t1 < 600)
322: sput(2, " ");
323: lput(2, t1 / 60);
324: sput(2, ".");
325: lput(2, (t1 % 60) / 6);
326: sput(2, " minutes remaining...\r");
327:
328: percent += 10;
329: incr = (lim * percent) / 100;
330: }
331: }
332: sput(2, "Done. \n");
333: sput(1, "\nd--755 0 0\n$\n");
334: exit(0);
335: }
336:
337: /**
338: * void
339: * bad(n)
340: * long n;
341: * Input: n - bad block location.
342: * Action: Flag block n as being bad.
343: * Return: None.
344: * Note: None.
345: */
346: void
347: bad(n) register long n;
348: {
349: static int nbad = 0;
350: static long last = -1;
351:
352: if ((last+1) != n)
353: nbad = 0;
354: last = n;
355: if ((nbad & 7) == 0)
356: sput(1, "\n%b");
357: sput(1, " ");
358: lput(1, n);
359: ++nbad;
360: }
361:
362: /**
363: * void
364: * fatal(s1, s2)
365: * char * s1, *s2;
366: * Input: s1, s2 - pointer to error message strings.
367: * Action: Print fatal message, terminate with extreme prejudice.
368: * Return: Never return. Always exit.
369: * Note: None.
370: */
371: void
372: fatal(s1, s2) char * s1, * s2;
373: {
374: sput(2, "badscan: ");
375: sput(2, s1);
376: sput(2, s2);
377: sput(2, "\n");
378: exit(1);
379: }
380:
381: /**
382: * void
383: * lput(fd, num)
384: * int fd;
385: * unsigned long num;
386: *
387: * Input: fd - output file descriptor.
388: * num -
389: * Action: Convert long num to ascii string sent to file fd.
390: * Return: None.
391: * Note: None.
392: */
393: void
394: lput(fd, num) int fd; unsigned long num;
395: {
396: register char * cp;
397: static char buf[16];
398:
399: cp = &buf[15];
400:
401: /*
402: * Compute character equivalent value of long num.
403: */
404: do {
405: *--cp = (num % 10) + '0';
406: } while (num /= 10);
407: sput(fd, cp);
408: }
409:
410: /**
411: * void
412: * sput(fd, s)
413: * int fd;
414: * char * s;
415: *
416: * Input: fd - output file descriptor.
417: * s - pointer to character string.
418: * Action: Write string s to file descriptor fd.
419: * Return: None.
420: * Note: None.
421: */
422: void
423: sput(fd, s) int fd; register char * s;
424: {
425: register char * cp;
426: int i,j;
427:
428: /*
429: * Get location of end of string.
430: */
431: for (cp = s; *cp != '\0'; ++cp)
432: ;
433:
434: /* WRITE WITH RETRY IF WRITE() RETURNS 0 */
435: i = cp-s;
436: while ((j = write(fd, s, i)) == 0) ;
437:
438: }
439:
440: /**
441: * void
442: * usage()
443: * Input: None.
444: * Action: Display command format.
445: * return: None.
446: * Note: None.
447: */
448: void
449: usage()
450: {
451: fatal( "Usage: badscan [-v] [-o proto] [-b boot] dev size\n",
452: " badscan [-v] [-o proto] [-b boot] dev sdev");
453: }
454:
455: /* end of badscan.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.