]>
Commit | Line | Data |
---|---|---|
3839e657 TT |
1 | /* |
2 | * badblocks.c - Bad blocks checker | |
3 | * | |
4 | * Copyright (C) 1992, 1993, 1994 Remy Card <card@masi.ibp.fr> | |
5 | * Laboratoire MASI, Institut Blaise Pascal | |
6 | * Universite Pierre et Marie Curie (Paris VI) | |
7 | * | |
dd018f5a | 8 | * Copyright 1995, 1996, 1997, 1998, 1999 by Theodore Ts'o |
879ac920 | 9 | * Copyright 1999 by David Beattie |
19c78dc0 | 10 | * |
3839e657 TT |
11 | * This file is based on the minix file system programs fsck and mkfs |
12 | * written and copyrighted by Linus Torvalds <Linus.Torvalds@cs.helsinki.fi> | |
efc6f628 | 13 | * |
19c78dc0 TT |
14 | * %Begin-Header% |
15 | * This file may be redistributed under the terms of the GNU Public | |
16 | * License. | |
17 | * %End-Header% | |
3839e657 TT |
18 | */ |
19 | ||
20 | /* | |
21 | * History: | |
22 | * 93/05/26 - Creation from e2fsck | |
23 | * 94/02/27 - Made a separate bad blocks checker | |
879ac920 | 24 | * 99/06/30...99/07/26 - Added non-destructive write-testing, |
dd018f5a TT |
25 | * configurable blocks-at-once parameter, |
26 | * loading of badblocks list to avoid testing | |
efc6f628 | 27 | * blocks known to be bad, multiple passes to |
dd018f5a TT |
28 | * make sure that no new blocks are added to the |
29 | * list. (Work done by David Beattie) | |
3839e657 TT |
30 | */ |
31 | ||
1c29b097 TT |
32 | #define _GNU_SOURCE /* for O_DIRECT */ |
33 | ||
22301afb TT |
34 | #ifndef O_LARGEFILE |
35 | #define O_LARGEFILE 0 | |
36 | #endif | |
37 | ||
3839e657 TT |
38 | #include <errno.h> |
39 | #include <fcntl.h> | |
a418d3ad | 40 | #ifdef HAVE_GETOPT_H |
3839e657 | 41 | #include <getopt.h> |
373b8337 TT |
42 | #else |
43 | extern char *optarg; | |
44 | extern int optind; | |
a418d3ad | 45 | #endif |
3839e657 TT |
46 | #include <signal.h> |
47 | #include <stdio.h> | |
48 | #include <stdlib.h> | |
49 | #include <string.h> | |
50 | #include <unistd.h> | |
879ac920 | 51 | #include <setjmp.h> |
6d40f568 | 52 | #include <time.h> |
5267a520 | 53 | #include <limits.h> |
3839e657 | 54 | |
edf261f6 | 55 | #include <sys/time.h> |
3839e657 | 56 | #include <sys/ioctl.h> |
f3db3566 | 57 | #include <sys/types.h> |
79e62409 | 58 | #include <sys/time.h> |
3839e657 | 59 | |
3839e657 | 60 | #include "et/com_err.h" |
d40259fd | 61 | #include "ext2fs/ext2_io.h" |
54c637d4 | 62 | #include "ext2fs/ext2_fs.h" |
879ac920 | 63 | #include "ext2fs/ext2fs.h" |
d9c56d3c | 64 | #include "nls-enable.h" |
3839e657 TT |
65 | |
66 | const char * program_name = "badblocks"; | |
f63978af | 67 | const char * done_string = N_("done \n"); |
3839e657 | 68 | |
4d003982 TT |
69 | static int v_flag = 0; /* verbose */ |
70 | static int w_flag = 0; /* do r/w test: 0=no, 1=yes, | |
71 | * 2=non-destructive */ | |
72 | static int s_flag = 0; /* show progress of test */ | |
981dc56a | 73 | static int force = 0; /* force check of mounted device */ |
849b6bc8 TT |
74 | static int t_flag = 0; /* number of test patterns */ |
75 | static int t_max = 0; /* allocated test patterns */ | |
e9860ae9 | 76 | static unsigned int *t_patts = NULL; /* test patterns */ |
1c29b097 | 77 | static int current_O_DIRECT = 0; /* Current status of O_DIRECT flag */ |
f63978af | 78 | static int exclusive_ok = 0; |
931b0289 | 79 | static unsigned int max_bb = 0; /* Abort test if more than this number of bad blocks has been encountered */ |
264f64a5 | 80 | static unsigned int d_flag = 0; /* delay factor between reads */ |
1c29b097 | 81 | |
849b6bc8 | 82 | #define T_INC 32 |
4d003982 | 83 | |
acd77415 | 84 | unsigned int sys_page_size = 4096; |
1c29b097 | 85 | |
8820c79f | 86 | static void usage(void) |
3839e657 | 87 | { |
ad39bcd9 BS |
88 | fprintf(stderr, _( |
89 | "Usage: %s [-b block_size] [-i input_file] [-o output_file] [-svwnf]\n" | |
90 | " [-c blocks_at_once] [-d delay_factor_between_reads] [-e max_bad_blocks]\n" | |
91 | " [-p num_passes] [-t test_pattern [-t test_pattern [...]]]\n" | |
92 | " device [last_block [first_block]]\n"), | |
3839e657 TT |
93 | program_name); |
94 | exit (1); | |
95 | } | |
96 | ||
d8b5f777 TT |
97 | static void exclusive_usage(void) |
98 | { | |
efc6f628 TT |
99 | fprintf(stderr, |
100 | _("%s: The -n and -w options are mutually exclusive.\n\n"), | |
017a76ee TT |
101 | program_name); |
102 | exit(1); | |
d8b5f777 TT |
103 | } |
104 | ||
acd77415 TT |
105 | static blk_t currently_testing = 0; |
106 | static blk_t num_blocks = 0; | |
879ac920 TT |
107 | static ext2_badblocks_list bb_list = NULL; |
108 | static FILE *out; | |
109 | static blk_t next_bad = 0; | |
110 | static ext2_badblocks_iterate bb_iter = NULL; | |
19c78dc0 | 111 | |
1c29b097 TT |
112 | static void *allocate_buffer(size_t size) |
113 | { | |
114 | void *ret = 0; | |
efc6f628 | 115 | |
1c29b097 TT |
116 | #ifdef HAVE_POSIX_MEMALIGN |
117 | if (posix_memalign(&ret, sys_page_size, size) < 0) | |
118 | ret = 0; | |
119 | #else | |
120 | #ifdef HAVE_MEMALIGN | |
121 | ret = memalign(sys_page_size, size); | |
122 | #else | |
123 | #ifdef HAVE_VALLOC | |
124 | ret = valloc(size); | |
125 | #endif /* HAVE_VALLOC */ | |
efc6f628 | 126 | #endif /* HAVE_MEMALIGN */ |
1c29b097 TT |
127 | #endif /* HAVE_POSIX_MEMALIGN */ |
128 | ||
129 | if (!ret) | |
130 | ret = malloc(size); | |
131 | ||
132 | return ret; | |
133 | } | |
134 | ||
dd018f5a TT |
135 | /* |
136 | * This routine reports a new bad block. If the bad block has already | |
137 | * been seen before, then it returns 0; otherwise it returns 1. | |
138 | */ | |
acd77415 | 139 | static int bb_output (blk_t bad) |
879ac920 TT |
140 | { |
141 | errcode_t errcode; | |
142 | ||
dd018f5a TT |
143 | if (ext2fs_badblocks_list_test(bb_list, bad)) |
144 | return 0; | |
145 | ||
acd77415 | 146 | fprintf(out, "%lu\n", (unsigned long) bad); |
cc4f98ed | 147 | fflush(out); |
879ac920 TT |
148 | |
149 | errcode = ext2fs_badblocks_list_add (bb_list, bad); | |
150 | if (errcode) { | |
151 | com_err (program_name, errcode, "adding to in-memory bad block list"); | |
152 | exit (1); | |
153 | } | |
154 | ||
155 | /* kludge: | |
efc6f628 | 156 | increment the iteration through the bb_list if |
879ac920 TT |
157 | an element was just added before the current iteration |
158 | position. This should not cause next_bad to change. */ | |
159 | if (bb_iter && bad < next_bad) | |
160 | ext2fs_badblocks_list_iterate (bb_iter, &next_bad); | |
dd018f5a | 161 | return 1; |
879ac920 TT |
162 | } |
163 | ||
8820c79f | 164 | static void print_status(void) |
19c78dc0 | 165 | { |
efc6f628 | 166 | fprintf(stderr, "%15lu/%15lu", (unsigned long) currently_testing, |
acd77415 | 167 | (unsigned long) num_blocks); |
c76564a8 | 168 | fputs("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b", stderr); |
19c78dc0 TT |
169 | fflush (stderr); |
170 | } | |
171 | ||
54434927 | 172 | static void alarm_intr(int alnum EXT2FS_ATTR((unused))) |
19c78dc0 TT |
173 | { |
174 | signal (SIGALRM, alarm_intr); | |
175 | alarm(1); | |
176 | if (!num_blocks) | |
177 | return; | |
c76564a8 | 178 | print_status(); |
19c78dc0 TT |
179 | } |
180 | ||
879ac920 TT |
181 | static void *terminate_addr = NULL; |
182 | ||
54434927 | 183 | static void terminate_intr(int signo EXT2FS_ATTR((unused))) |
879ac920 TT |
184 | { |
185 | if (terminate_addr) | |
186 | longjmp(terminate_addr,1); | |
187 | exit(1); | |
188 | } | |
189 | ||
981dc56a | 190 | static void capture_terminate(jmp_buf term_addr) |
879ac920 TT |
191 | { |
192 | terminate_addr = term_addr; | |
193 | signal (SIGHUP, terminate_intr); | |
194 | signal (SIGINT, terminate_intr); | |
195 | signal (SIGPIPE, terminate_intr); | |
196 | signal (SIGTERM, terminate_intr); | |
197 | signal (SIGUSR1, terminate_intr); | |
198 | signal (SIGUSR2, terminate_intr); | |
199 | } | |
200 | ||
8820c79f | 201 | static void uncapture_terminate(void) |
4d003982 TT |
202 | { |
203 | terminate_addr = NULL; | |
204 | signal (SIGHUP, SIG_DFL); | |
205 | signal (SIGINT, SIG_DFL); | |
206 | signal (SIGPIPE, SIG_DFL); | |
207 | signal (SIGTERM, SIG_DFL); | |
208 | signal (SIGUSR1, SIG_DFL); | |
209 | signal (SIGUSR2, SIG_DFL); | |
210 | } | |
211 | ||
1f9a60c2 | 212 | static void set_o_direct(int dev, unsigned char *buffer, size_t size, |
acd77415 | 213 | blk_t current_block) |
1c29b097 TT |
214 | { |
215 | #ifdef O_DIRECT | |
216 | int new_flag = O_DIRECT; | |
217 | int flag; | |
efc6f628 | 218 | |
1c29b097 | 219 | if ((((unsigned long) buffer & (sys_page_size - 1)) != 0) || |
1f9a60c2 TT |
220 | ((size & (sys_page_size - 1)) != 0) || |
221 | ((current_block & ((sys_page_size >> 9)-1)) != 0)) | |
1c29b097 TT |
222 | new_flag = 0; |
223 | ||
224 | if (new_flag != current_O_DIRECT) { | |
dc058719 | 225 | /* printf("%s O_DIRECT\n", new_flag ? "Setting" : "Clearing"); */ |
1c29b097 TT |
226 | flag = fcntl(dev, F_GETFL); |
227 | if (flag > 0) { | |
228 | flag = (flag & ~O_DIRECT) | new_flag; | |
229 | fcntl(dev, F_SETFL, flag); | |
230 | } | |
231 | current_O_DIRECT = new_flag; | |
232 | } | |
233 | #endif | |
234 | } | |
235 | ||
236 | ||
e9860ae9 | 237 | static void pattern_fill(unsigned char *buffer, unsigned int pattern, |
84c05457 | 238 | size_t n) |
849b6bc8 | 239 | { |
54434927 | 240 | unsigned int i, nb; |
84c05457 | 241 | unsigned char bpattern[sizeof(pattern)], *ptr; |
efc6f628 | 242 | |
e9860ae9 | 243 | if (pattern == (unsigned int) ~0) { |
849b6bc8 TT |
244 | for (ptr = buffer; ptr < buffer + n; ptr++) { |
245 | (*ptr) = random() % (1 << (8 * sizeof(char))); | |
246 | } | |
247 | if (s_flag | v_flag) | |
54434927 | 248 | fputs(_("Testing with random pattern: "), stderr); |
849b6bc8 TT |
249 | } else { |
250 | bpattern[0] = 0; | |
251 | for (i = 0; i < sizeof(bpattern); i++) { | |
252 | if (pattern == 0) | |
253 | break; | |
254 | bpattern[i] = pattern & 0xFF; | |
255 | pattern = pattern >> 8; | |
256 | } | |
257 | nb = i ? (i-1) : 0; | |
258 | for (ptr = buffer, i = nb; ptr < buffer + n; ptr++) { | |
54434927 TT |
259 | *ptr = bpattern[i]; |
260 | if (i == 0) | |
849b6bc8 | 261 | i = nb; |
54434927 TT |
262 | else |
263 | i--; | |
849b6bc8 | 264 | } |
84c05457 | 265 | if (s_flag | v_flag) { |
54434927 | 266 | fputs(_("Testing with pattern 0x"), stderr); |
84c05457 TT |
267 | for (i = 0; i <= nb; i++) |
268 | fprintf(stderr, "%02x", buffer[i]); | |
54434927 | 269 | fputs(": ", stderr); |
84c05457 | 270 | } |
849b6bc8 TT |
271 | } |
272 | } | |
273 | ||
3839e657 | 274 | /* |
879ac920 TT |
275 | * Perform a read of a sequence of blocks; return the number of blocks |
276 | * successfully sequentially read. | |
3839e657 | 277 | */ |
acd77415 TT |
278 | static int do_read (int dev, unsigned char * buffer, int try, int block_size, |
279 | blk_t current_block) | |
3839e657 TT |
280 | { |
281 | long got; | |
264f64a5 IP |
282 | struct timeval tv1, tv2; |
283 | #define NANOSEC (1000000000L) | |
284 | #define MILISEC (1000L) | |
3839e657 | 285 | |
1f9a60c2 | 286 | set_o_direct(dev, buffer, try * block_size, current_block); |
1c29b097 | 287 | |
19c78dc0 TT |
288 | if (v_flag > 1) |
289 | print_status(); | |
290 | ||
3839e657 | 291 | /* Seek to the correct loc. */ |
19c78dc0 | 292 | if (ext2fs_llseek (dev, (ext2_loff_t) current_block * block_size, |
f3db3566 | 293 | SEEK_SET) != (ext2_loff_t) current_block * block_size) |
d9c56d3c | 294 | com_err (program_name, errno, _("during seek")); |
3839e657 TT |
295 | |
296 | /* Try the read */ | |
264f64a5 | 297 | if (d_flag) |
edf261f6 | 298 | gettimeofday(&tv1, NULL); |
3839e657 | 299 | got = read (dev, buffer, try * block_size); |
264f64a5 | 300 | if (d_flag) |
edf261f6 | 301 | gettimeofday(&tv2, NULL); |
3839e657 | 302 | if (got < 0) |
efc6f628 | 303 | got = 0; |
9f10a7b3 | 304 | if (got & 511) |
d9c56d3c | 305 | fprintf(stderr, _("Weird value (%ld) in do_read\n"), got); |
879ac920 | 306 | got /= block_size; |
264f64a5 | 307 | if (d_flag && got == try) { |
c13ab4fa | 308 | #ifdef HAVE_NANOSLEEP |
264f64a5 IP |
309 | struct timespec ts; |
310 | ts.tv_sec = tv2.tv_sec - tv1.tv_sec; | |
311 | ts.tv_nsec = (tv2.tv_usec - tv1.tv_usec) * MILISEC; | |
312 | if (ts.tv_nsec < 0) { | |
313 | ts.tv_nsec += NANOSEC; | |
314 | ts.tv_sec -= 1; | |
315 | } | |
316 | /* increase/decrease the sleep time based on d_flag value */ | |
317 | ts.tv_sec = ts.tv_sec * d_flag / 100; | |
318 | ts.tv_nsec = ts.tv_nsec * d_flag / 100; | |
319 | if (ts.tv_nsec > NANOSEC) { | |
320 | ts.tv_sec += ts.tv_nsec / NANOSEC; | |
321 | ts.tv_nsec %= NANOSEC; | |
322 | } | |
323 | if (ts.tv_sec || ts.tv_nsec) | |
324 | nanosleep(&ts, NULL); | |
c13ab4fa TT |
325 | #else |
326 | #ifdef HAVE_USLEEP | |
327 | struct timeval tv; | |
328 | tv.tv_sec = tv2.tv_sec - tv1.tv_sec; | |
329 | tv.tv_usec = tv2.tv_usec - tv1.tv_usec; | |
330 | tv.tv_sec = tv.tv_sec * d_flag / 100; | |
331 | tv.tv_usec = tv.tv_usec * d_flag / 100; | |
332 | if (tv.tv_usec > 1000000) { | |
333 | tv.tv_sec += tv.tv_usec / 1000000; | |
334 | tv.tv_usec %= 1000000; | |
335 | } | |
336 | if (tv.tv_sec) | |
337 | sleep(tv.tv_sec); | |
338 | if (tv.tv_usec) | |
339 | usleep(tv.tv_usec); | |
340 | #endif | |
341 | #endif | |
264f64a5 | 342 | } |
879ac920 TT |
343 | return got; |
344 | } | |
345 | ||
346 | /* | |
347 | * Perform a write of a sequence of blocks; return the number of blocks | |
348 | * successfully sequentially written. | |
349 | */ | |
acd77415 TT |
350 | static int do_write(int dev, unsigned char * buffer, int try, int block_size, |
351 | unsigned long current_block) | |
879ac920 TT |
352 | { |
353 | long got; | |
354 | ||
1f9a60c2 | 355 | set_o_direct(dev, buffer, try * block_size, current_block); |
1c29b097 | 356 | |
879ac920 TT |
357 | if (v_flag > 1) |
358 | print_status(); | |
359 | ||
360 | /* Seek to the correct loc. */ | |
361 | if (ext2fs_llseek (dev, (ext2_loff_t) current_block * block_size, | |
362 | SEEK_SET) != (ext2_loff_t) current_block * block_size) | |
d9c56d3c | 363 | com_err (program_name, errno, _("during seek")); |
879ac920 TT |
364 | |
365 | /* Try the write */ | |
366 | got = write (dev, buffer, try * block_size); | |
367 | if (got < 0) | |
efc6f628 | 368 | got = 0; |
879ac920 | 369 | if (got & 511) |
54434927 | 370 | fprintf(stderr, "Weird value (%ld) in do_write\n", got); |
3839e657 TT |
371 | got /= block_size; |
372 | return got; | |
373 | } | |
374 | ||
879ac920 TT |
375 | static int host_dev; |
376 | ||
4d404547 | 377 | static void flush_bufs(void) |
a418d3ad | 378 | { |
4d404547 | 379 | errcode_t retval; |
a418d3ad | 380 | |
4d404547 TT |
381 | retval = ext2fs_sync_device(host_dev, 1); |
382 | if (retval) | |
383 | com_err(program_name, retval, _("during ext2fs_sync_device")); | |
a418d3ad TT |
384 | } |
385 | ||
acd77415 | 386 | static unsigned int test_ro (int dev, blk_t last_block, |
f56f32b0 | 387 | int block_size, blk_t first_block, |
acd77415 | 388 | unsigned int blocks_at_once) |
3839e657 | 389 | { |
48e6e813 | 390 | unsigned char * blkbuf; |
3839e657 | 391 | int try; |
acd77415 | 392 | int got; |
879ac920 TT |
393 | unsigned int bb_count = 0; |
394 | errcode_t errcode; | |
3839e657 | 395 | |
879ac920 TT |
396 | errcode = ext2fs_badblocks_list_iterate_begin(bb_list,&bb_iter); |
397 | if (errcode) { | |
d9c56d3c TT |
398 | com_err (program_name, errcode, |
399 | _("while beginning bad block list iteration")); | |
879ac920 TT |
400 | exit (1); |
401 | } | |
402 | do { | |
403 | ext2fs_badblocks_list_iterate (bb_iter, &next_bad); | |
f56f32b0 | 404 | } while (next_bad && next_bad < first_block); |
879ac920 | 405 | |
849b6bc8 | 406 | if (t_flag) { |
1c29b097 | 407 | blkbuf = allocate_buffer((blocks_at_once + 1) * block_size); |
849b6bc8 | 408 | } else { |
1c29b097 | 409 | blkbuf = allocate_buffer(blocks_at_once * block_size); |
849b6bc8 | 410 | } |
3839e657 TT |
411 | if (!blkbuf) |
412 | { | |
d9c56d3c | 413 | com_err (program_name, ENOMEM, _("while allocating buffers")); |
3839e657 TT |
414 | exit (1); |
415 | } | |
f3db3566 | 416 | if (v_flag) { |
efc6f628 TT |
417 | fprintf (stderr, _("Checking blocks %lu to %lu\n"), |
418 | (unsigned long) first_block, | |
acd77415 | 419 | (unsigned long) last_block - 1); |
f3db3566 | 420 | } |
849b6bc8 | 421 | if (t_flag) { |
54434927 | 422 | fputs(_("Checking for bad blocks in read-only mode\n"), stderr); |
849b6bc8 TT |
423 | pattern_fill(blkbuf + blocks_at_once * block_size, |
424 | t_patts[0], block_size); | |
425 | } | |
426 | flush_bufs(); | |
879ac920 | 427 | try = blocks_at_once; |
f56f32b0 | 428 | currently_testing = first_block; |
8938ce64 | 429 | num_blocks = last_block - 1; |
849b6bc8 | 430 | if (!t_flag && (s_flag || v_flag)) { |
54434927 | 431 | fputs(_("Checking for bad blocks (read-only test): "), stderr); |
19c78dc0 TT |
432 | if (v_flag <= 1) |
433 | alarm_intr(SIGALRM); | |
3839e657 | 434 | } |
cd130a08 | 435 | while (currently_testing < last_block) |
3839e657 | 436 | { |
931b0289 IP |
437 | if (max_bb && bb_count >= max_bb) { |
438 | if (s_flag || v_flag) { | |
439 | fputs(_("Too many bad blocks, aborting test\n"), stderr); | |
440 | } | |
441 | break; | |
442 | } | |
879ac920 TT |
443 | if (next_bad) { |
444 | if (currently_testing == next_bad) { | |
445 | /* fprintf (out, "%lu\n", nextbad); */ | |
446 | ext2fs_badblocks_list_iterate (bb_iter, &next_bad); | |
447 | currently_testing++; | |
448 | continue; | |
449 | } | |
450 | else if (currently_testing + try > next_bad) | |
451 | try = next_bad - currently_testing; | |
452 | } | |
cd130a08 TT |
453 | if (currently_testing + try > last_block) |
454 | try = last_block - currently_testing; | |
879ac920 | 455 | got = do_read (dev, blkbuf, try, block_size, currently_testing); |
849b6bc8 TT |
456 | if (t_flag) { |
457 | /* test the comparison between all the | |
458 | blocks successfully read */ | |
459 | int i; | |
460 | for (i = 0; i < got; ++i) | |
461 | if (memcmp (blkbuf+i*block_size, | |
462 | blkbuf+blocks_at_once*block_size, | |
463 | block_size)) | |
464 | bb_count += bb_output(currently_testing + i); | |
465 | } | |
3839e657 TT |
466 | currently_testing += got; |
467 | if (got == try) { | |
879ac920 | 468 | try = blocks_at_once; |
1f9a60c2 | 469 | /* recover page-aligned offset for O_DIRECT */ |
acd77415 | 470 | if ( (blocks_at_once >= sys_page_size >> 9) |
1f9a60c2 TT |
471 | && (currently_testing % (sys_page_size >> 9)!= 0)) |
472 | try -= (sys_page_size >> 9) | |
efc6f628 | 473 | - (currently_testing |
1f9a60c2 | 474 | % (sys_page_size >> 9)); |
3839e657 TT |
475 | continue; |
476 | } | |
477 | else | |
478 | try = 1; | |
879ac920 | 479 | if (got == 0) { |
dd018f5a | 480 | bb_count += bb_output(currently_testing++); |
879ac920 | 481 | } |
3839e657 TT |
482 | } |
483 | num_blocks = 0; | |
484 | alarm(0); | |
849b6bc8 | 485 | if (s_flag || v_flag) |
3ef681c5 | 486 | fputs(_(done_string), stderr); |
879ac920 | 487 | |
f3db3566 | 488 | fflush (stderr); |
3839e657 | 489 | free (blkbuf); |
879ac920 TT |
490 | |
491 | ext2fs_badblocks_list_iterate_end(bb_iter); | |
492 | ||
493 | return bb_count; | |
3839e657 TT |
494 | } |
495 | ||
acd77415 | 496 | static unsigned int test_rw (int dev, blk_t last_block, |
f56f32b0 | 497 | int block_size, blk_t first_block, |
acd77415 | 498 | unsigned int blocks_at_once) |
3839e657 | 499 | { |
1c29b097 | 500 | unsigned char *buffer, *read_buffer; |
e9860ae9 TT |
501 | const unsigned int patterns[] = {0xaa, 0x55, 0xff, 0x00}; |
502 | const unsigned int *pattern; | |
1c29b097 | 503 | int i, try, got, nr_pattern, pat_idx; |
879ac920 | 504 | unsigned int bb_count = 0; |
3839e657 | 505 | |
1c29b097 TT |
506 | buffer = allocate_buffer(2 * blocks_at_once * block_size); |
507 | read_buffer = buffer + blocks_at_once * block_size; | |
efc6f628 | 508 | |
1c29b097 | 509 | if (!buffer) { |
d9c56d3c | 510 | com_err (program_name, ENOMEM, _("while allocating buffers")); |
3839e657 TT |
511 | exit (1); |
512 | } | |
513 | ||
4d404547 | 514 | flush_bufs(); |
a418d3ad | 515 | |
19c78dc0 | 516 | if (v_flag) { |
efc6f628 | 517 | fputs(_("Checking for bad blocks in read-write mode\n"), |
54434927 | 518 | stderr); |
d9c56d3c | 519 | fprintf(stderr, _("From block %lu to %lu\n"), |
efc6f628 | 520 | (unsigned long) first_block, |
f56f32b0 | 521 | (unsigned long) last_block - 1); |
19c78dc0 | 522 | } |
849b6bc8 TT |
523 | if (t_flag) { |
524 | pattern = t_patts; | |
525 | nr_pattern = t_flag; | |
526 | } else { | |
527 | pattern = patterns; | |
528 | nr_pattern = sizeof(patterns) / sizeof(patterns[0]); | |
529 | } | |
530 | for (pat_idx = 0; pat_idx < nr_pattern; pat_idx++) { | |
1c29b097 TT |
531 | pattern_fill(buffer, pattern[pat_idx], |
532 | blocks_at_once * block_size); | |
8938ce64 | 533 | num_blocks = last_block - 1; |
f56f32b0 | 534 | currently_testing = first_block; |
19c78dc0 | 535 | if (s_flag && v_flag <= 1) |
f3db3566 | 536 | alarm_intr(SIGALRM); |
1c29b097 TT |
537 | |
538 | try = blocks_at_once; | |
539 | while (currently_testing < last_block) { | |
931b0289 IP |
540 | if (max_bb && bb_count >= max_bb) { |
541 | if (s_flag || v_flag) { | |
542 | fputs(_("Too many bad blocks, aborting test\n"), stderr); | |
543 | } | |
544 | break; | |
545 | } | |
1c29b097 TT |
546 | if (currently_testing + try > last_block) |
547 | try = last_block - currently_testing; | |
548 | got = do_write(dev, buffer, try, block_size, | |
549 | currently_testing); | |
19c78dc0 TT |
550 | if (v_flag > 1) |
551 | print_status(); | |
1c29b097 TT |
552 | |
553 | currently_testing += got; | |
554 | if (got == try) { | |
555 | try = blocks_at_once; | |
1f9a60c2 | 556 | /* recover page-aligned offset for O_DIRECT */ |
acd77415 | 557 | if ( (blocks_at_once >= sys_page_size >> 9) |
efc6f628 | 558 | && (currently_testing % |
1f9a60c2 TT |
559 | (sys_page_size >> 9)!= 0)) |
560 | try -= (sys_page_size >> 9) | |
efc6f628 | 561 | - (currently_testing |
1f9a60c2 | 562 | % (sys_page_size >> 9)); |
1c29b097 TT |
563 | continue; |
564 | } else | |
565 | try = 1; | |
566 | if (got == 0) { | |
567 | bb_count += bb_output(currently_testing++); | |
568 | } | |
3839e657 | 569 | } |
efc6f628 | 570 | |
f3db3566 TT |
571 | num_blocks = 0; |
572 | alarm (0); | |
573 | if (s_flag | v_flag) | |
3ef681c5 | 574 | fputs(_(done_string), stderr); |
4d404547 | 575 | flush_bufs(); |
f3db3566 | 576 | if (s_flag | v_flag) |
54434927 | 577 | fputs(_("Reading and comparing: "), stderr); |
cd130a08 | 578 | num_blocks = last_block; |
f56f32b0 | 579 | currently_testing = first_block; |
19c78dc0 | 580 | if (s_flag && v_flag <= 1) |
f3db3566 | 581 | alarm_intr(SIGALRM); |
1c29b097 TT |
582 | |
583 | try = blocks_at_once; | |
584 | while (currently_testing < last_block) { | |
931b0289 IP |
585 | if (max_bb && bb_count >= max_bb) { |
586 | if (s_flag || v_flag) { | |
587 | fputs(_("Too many bad blocks, aborting test\n"), stderr); | |
588 | } | |
589 | break; | |
590 | } | |
1c29b097 TT |
591 | if (currently_testing + try > last_block) |
592 | try = last_block - currently_testing; | |
593 | got = do_read (dev, read_buffer, try, block_size, | |
594 | currently_testing); | |
595 | if (got == 0) { | |
596 | bb_count += bb_output(currently_testing++); | |
597 | continue; | |
598 | } | |
599 | for (i=0; i < got; i++) { | |
600 | if (memcmp(read_buffer + i * block_size, | |
601 | buffer + i * block_size, | |
602 | block_size)) | |
603 | bb_count += bb_output(currently_testing+i); | |
604 | } | |
605 | currently_testing += got; | |
1f9a60c2 | 606 | /* recover page-aligned offset for O_DIRECT */ |
acd77415 | 607 | if ( (blocks_at_once >= sys_page_size >> 9) |
1f9a60c2 TT |
608 | && (currently_testing % (sys_page_size >> 9)!= 0)) |
609 | try = blocks_at_once - (sys_page_size >> 9) | |
efc6f628 | 610 | - (currently_testing |
1f9a60c2 TT |
611 | % (sys_page_size >> 9)); |
612 | else | |
613 | try = blocks_at_once; | |
19c78dc0 TT |
614 | if (v_flag > 1) |
615 | print_status(); | |
3839e657 | 616 | } |
efc6f628 | 617 | |
f3db3566 TT |
618 | num_blocks = 0; |
619 | alarm (0); | |
620 | if (s_flag | v_flag) | |
3ef681c5 | 621 | fputs(_(done_string), stderr); |
4d404547 | 622 | flush_bufs(); |
3839e657 | 623 | } |
849b6bc8 | 624 | uncapture_terminate(); |
6d40f568 | 625 | free(buffer); |
879ac920 TT |
626 | return bb_count; |
627 | } | |
628 | ||
d49a22b7 TT |
629 | struct saved_blk_record { |
630 | blk_t block; | |
631 | int num; | |
632 | }; | |
633 | ||
acd77415 | 634 | static unsigned int test_nd (int dev, blk_t last_block, |
f56f32b0 | 635 | int block_size, blk_t first_block, |
acd77415 | 636 | unsigned int blocks_at_once) |
879ac920 | 637 | { |
48e6e813 | 638 | unsigned char *blkbuf, *save_ptr, *test_ptr, *read_ptr; |
1c29b097 | 639 | unsigned char *test_base, *save_base, *read_base; |
dd018f5a | 640 | int try, i; |
e9860ae9 TT |
641 | const unsigned int patterns[] = { ~0 }; |
642 | const unsigned int *pattern; | |
849b6bc8 | 643 | int nr_pattern, pat_idx; |
acd77415 TT |
644 | int got, used2, written; |
645 | blk_t save_currently_testing; | |
d49a22b7 | 646 | struct saved_blk_record *test_record; |
a551b783 TT |
647 | /* This is static to prevent being clobbered by the longjmp */ |
648 | static int num_saved; | |
879ac920 | 649 | jmp_buf terminate_env; |
879ac920 | 650 | errcode_t errcode; |
54434927 TT |
651 | unsigned long buf_used; |
652 | static unsigned int bb_count; | |
879ac920 | 653 | |
54434927 | 654 | bb_count = 0; |
879ac920 TT |
655 | errcode = ext2fs_badblocks_list_iterate_begin(bb_list,&bb_iter); |
656 | if (errcode) { | |
dd018f5a | 657 | com_err (program_name, errcode, |
d9c56d3c | 658 | _("while beginning bad block list iteration")); |
879ac920 TT |
659 | exit (1); |
660 | } | |
661 | do { | |
662 | ext2fs_badblocks_list_iterate (bb_iter, &next_bad); | |
f56f32b0 | 663 | } while (next_bad && next_bad < first_block); |
879ac920 | 664 | |
1c29b097 | 665 | blkbuf = allocate_buffer(3 * blocks_at_once * block_size); |
d49a22b7 TT |
666 | test_record = malloc (blocks_at_once*sizeof(struct saved_blk_record)); |
667 | if (!blkbuf || !test_record) { | |
d9c56d3c | 668 | com_err(program_name, ENOMEM, _("while allocating buffers")); |
879ac920 TT |
669 | exit (1); |
670 | } | |
1c29b097 TT |
671 | |
672 | save_base = blkbuf; | |
673 | test_base = blkbuf + (blocks_at_once * block_size); | |
674 | read_base = blkbuf + (2 * blocks_at_once * block_size); | |
efc6f628 | 675 | |
d49a22b7 | 676 | num_saved = 0; |
879ac920 | 677 | |
4d404547 | 678 | flush_bufs(); |
879ac920 | 679 | if (v_flag) { |
54434927 | 680 | fputs(_("Checking for bad blocks in non-destructive read-write mode\n"), stderr); |
efc6f628 | 681 | fprintf (stderr, _("From block %lu to %lu\n"), |
f56f32b0 TT |
682 | (unsigned long) first_block, |
683 | (unsigned long) last_block - 1); | |
879ac920 | 684 | } |
879ac920 | 685 | if (s_flag || v_flag > 1) { |
54434927 | 686 | fputs(_("Checking for bad blocks (non-destructive read-write test)\n"), stderr); |
879ac920 | 687 | } |
4d003982 TT |
688 | if (setjmp(terminate_env)) { |
689 | /* | |
690 | * Abnormal termination by a signal is handled here. | |
4d003982 | 691 | */ |
a551b783 | 692 | signal (SIGALRM, SIG_IGN); |
54434927 | 693 | fputs(_("\nInterrupt caught, cleaning up\n"), stderr); |
879ac920 | 694 | |
1c29b097 | 695 | save_ptr = save_base; |
d49a22b7 TT |
696 | for (i=0; i < num_saved; i++) { |
697 | do_write(dev, save_ptr, test_record[i].num, | |
698 | block_size, test_record[i].block); | |
699 | save_ptr += test_record[i].num * block_size; | |
700 | } | |
879ac920 | 701 | fflush (out); |
dd018f5a | 702 | exit(1); |
879ac920 | 703 | } |
efc6f628 | 704 | |
4d003982 TT |
705 | /* set up abend handler */ |
706 | capture_terminate(terminate_env); | |
707 | ||
849b6bc8 TT |
708 | if (t_flag) { |
709 | pattern = t_patts; | |
710 | nr_pattern = t_flag; | |
711 | } else { | |
712 | pattern = patterns; | |
713 | nr_pattern = sizeof(patterns) / sizeof(patterns[0]); | |
714 | } | |
715 | for (pat_idx = 0; pat_idx < nr_pattern; pat_idx++) { | |
1c29b097 TT |
716 | pattern_fill(test_base, pattern[pat_idx], |
717 | blocks_at_once * block_size); | |
4d003982 | 718 | |
849b6bc8 TT |
719 | buf_used = 0; |
720 | bb_count = 0; | |
1c29b097 TT |
721 | save_ptr = save_base; |
722 | test_ptr = test_base; | |
f56f32b0 | 723 | currently_testing = first_block; |
8938ce64 | 724 | num_blocks = last_block - 1; |
849b6bc8 TT |
725 | if (s_flag && v_flag <= 1) |
726 | alarm_intr(SIGALRM); | |
4d003982 | 727 | |
849b6bc8 | 728 | while (currently_testing < last_block) { |
931b0289 IP |
729 | if (max_bb && bb_count >= max_bb) { |
730 | if (s_flag || v_flag) { | |
731 | fputs(_("Too many bad blocks, aborting test\n"), stderr); | |
732 | } | |
733 | break; | |
734 | } | |
1c29b097 | 735 | got = try = blocks_at_once - buf_used; |
849b6bc8 TT |
736 | if (next_bad) { |
737 | if (currently_testing == next_bad) { | |
738 | /* fprintf (out, "%lu\n", nextbad); */ | |
739 | ext2fs_badblocks_list_iterate (bb_iter, &next_bad); | |
740 | currently_testing++; | |
741 | goto check_for_more; | |
742 | } | |
743 | else if (currently_testing + try > next_bad) | |
744 | try = next_bad - currently_testing; | |
d49a22b7 | 745 | } |
849b6bc8 TT |
746 | if (currently_testing + try > last_block) |
747 | try = last_block - currently_testing; | |
748 | got = do_read (dev, save_ptr, try, block_size, | |
749 | currently_testing); | |
750 | if (got == 0) { | |
751 | /* First block must have been bad. */ | |
752 | bb_count += bb_output(currently_testing++); | |
753 | goto check_for_more; | |
4d003982 | 754 | } |
4d003982 | 755 | |
849b6bc8 TT |
756 | /* |
757 | * Note the fact that we've saved this much data | |
758 | * *before* we overwrite it with test data | |
759 | */ | |
760 | test_record[num_saved].block = currently_testing; | |
761 | test_record[num_saved].num = got; | |
762 | num_saved++; | |
763 | ||
764 | /* Write the test data */ | |
765 | written = do_write (dev, test_ptr, got, block_size, | |
766 | currently_testing); | |
767 | if (written != got) | |
768 | com_err (program_name, errno, | |
769 | _("during test data write, block %lu"), | |
efc6f628 | 770 | (unsigned long) currently_testing + |
acd77415 | 771 | written); |
849b6bc8 TT |
772 | |
773 | buf_used += got; | |
4d003982 TT |
774 | save_ptr += got * block_size; |
775 | test_ptr += got * block_size; | |
849b6bc8 TT |
776 | currently_testing += got; |
777 | if (got != try) | |
778 | bb_count += bb_output(currently_testing++); | |
779 | ||
780 | check_for_more: | |
781 | /* | |
782 | * If there's room for more blocks to be tested this | |
783 | * around, and we're not done yet testing the disk, go | |
784 | * back and get some more blocks. | |
785 | */ | |
786 | if ((buf_used != blocks_at_once) && | |
787 | (currently_testing < last_block)) | |
788 | continue; | |
789 | ||
790 | flush_bufs(); | |
791 | save_currently_testing = currently_testing; | |
792 | ||
793 | /* | |
794 | * for each contiguous block that we read into the | |
795 | * buffer (and wrote test data into afterwards), read | |
796 | * it back (looping if necessary, to get past newly | |
797 | * discovered unreadable blocks, of which there should | |
798 | * be none, but with a hard drive which is unreliable, | |
799 | * it has happened), and compare with the test data | |
800 | * that was written; output to the bad block list if | |
801 | * it doesn't match. | |
802 | */ | |
803 | used2 = 0; | |
1c29b097 TT |
804 | save_ptr = save_base; |
805 | test_ptr = test_base; | |
806 | read_ptr = read_base; | |
849b6bc8 TT |
807 | try = 0; |
808 | ||
809 | while (1) { | |
810 | if (try == 0) { | |
811 | if (used2 >= num_saved) | |
812 | break; | |
813 | currently_testing = test_record[used2].block; | |
814 | try = test_record[used2].num; | |
815 | used2++; | |
816 | } | |
efc6f628 | 817 | |
849b6bc8 TT |
818 | got = do_read (dev, read_ptr, try, |
819 | block_size, currently_testing); | |
820 | ||
821 | /* test the comparison between all the | |
822 | blocks successfully read */ | |
823 | for (i = 0; i < got; ++i) | |
824 | if (memcmp (test_ptr+i*block_size, | |
825 | read_ptr+i*block_size, block_size)) | |
826 | bb_count += bb_output(currently_testing + i); | |
827 | if (got < try) { | |
828 | bb_count += bb_output(currently_testing + got); | |
829 | got++; | |
830 | } | |
efc6f628 | 831 | |
1c29b097 TT |
832 | /* write back original data */ |
833 | do_write (dev, save_ptr, got, | |
834 | block_size, currently_testing); | |
835 | save_ptr += got * block_size; | |
849b6bc8 TT |
836 | |
837 | currently_testing += got; | |
849b6bc8 TT |
838 | test_ptr += got * block_size; |
839 | read_ptr += got * block_size; | |
840 | try -= got; | |
841 | } | |
842 | ||
843 | /* empty the buffer so it can be reused */ | |
844 | num_saved = 0; | |
845 | buf_used = 0; | |
1c29b097 TT |
846 | save_ptr = save_base; |
847 | test_ptr = test_base; | |
849b6bc8 | 848 | currently_testing = save_currently_testing; |
4d003982 | 849 | } |
849b6bc8 TT |
850 | num_blocks = 0; |
851 | alarm(0); | |
852 | if (s_flag || v_flag > 1) | |
3ef681c5 | 853 | fputs(_(done_string), stderr); |
4d003982 | 854 | |
849b6bc8 | 855 | flush_bufs(); |
4d003982 | 856 | } |
4d003982 | 857 | uncapture_terminate(); |
dd018f5a TT |
858 | fflush(stderr); |
859 | free(blkbuf); | |
d49a22b7 | 860 | free(test_record); |
879ac920 TT |
861 | |
862 | ext2fs_badblocks_list_iterate_end(bb_iter); | |
863 | ||
864 | return bb_count; | |
3839e657 TT |
865 | } |
866 | ||
981dc56a TT |
867 | static void check_mount(char *device_name) |
868 | { | |
869 | errcode_t retval; | |
870 | int mount_flags; | |
871 | ||
872 | retval = ext2fs_check_if_mounted(device_name, &mount_flags); | |
873 | if (retval) { | |
874 | com_err("ext2fs_check_if_mount", retval, | |
875 | _("while determining whether %s is mounted."), | |
876 | device_name); | |
877 | return; | |
878 | } | |
2fa8f37f TT |
879 | if (mount_flags & EXT2_MF_MOUNTED) { |
880 | fprintf(stderr, _("%s is mounted; "), device_name); | |
881 | if (force) { | |
882 | fputs(_("badblocks forced anyway. " | |
883 | "Hope /etc/mtab is incorrect.\n"), stderr); | |
884 | return; | |
885 | } | |
886 | abort_badblocks: | |
887 | fputs(_("it's not safe to run badblocks!\n"), stderr); | |
888 | exit(1); | |
889 | } | |
981dc56a | 890 | |
f63978af | 891 | if ((mount_flags & EXT2_MF_BUSY) && !exclusive_ok) { |
2fa8f37f TT |
892 | fprintf(stderr, _("%s is apparently in use by the system; "), |
893 | device_name); | |
894 | if (force) | |
895 | fputs(_("badblocks forced anyway.\n"), stderr); | |
896 | else | |
897 | goto abort_badblocks; | |
981dc56a | 898 | } |
2fa8f37f | 899 | |
981dc56a TT |
900 | } |
901 | ||
d4be9fad TT |
902 | /* |
903 | * This function will convert a string to an unsigned long, printing | |
904 | * an error message if it fails, and returning success or failure in err. | |
905 | */ | |
906 | static unsigned int parse_uint(const char *str, const char *descr) | |
907 | { | |
908 | char *tmp; | |
909 | unsigned long ret; | |
efc6f628 | 910 | |
eb594251 | 911 | errno = 0; |
d4be9fad TT |
912 | ret = strtoul(str, &tmp, 0); |
913 | if (*tmp || errno || (ret > UINT_MAX) || | |
914 | (ret == ULONG_MAX && errno == ERANGE)) { | |
915 | com_err (program_name, 0, _("invalid %s - %s"), descr, str); | |
916 | exit (1); | |
917 | } | |
918 | return ret; | |
919 | } | |
981dc56a | 920 | |
00e5433e | 921 | int main (int argc, char ** argv) |
3839e657 | 922 | { |
519149fb | 923 | int c; |
3839e657 | 924 | char * device_name; |
879ac920 TT |
925 | char * host_device_name = NULL; |
926 | char * input_file = NULL; | |
3839e657 | 927 | char * output_file = NULL; |
879ac920 | 928 | FILE * in = NULL; |
dd018f5a | 929 | int block_size = 1024; |
acd77415 | 930 | unsigned int blocks_at_once = 64; |
f56f32b0 | 931 | blk_t last_block, first_block; |
879ac920 TT |
932 | int num_passes = 0; |
933 | int passes_clean = 0; | |
3839e657 | 934 | int dev; |
879ac920 | 935 | errcode_t errcode; |
e9860ae9 | 936 | unsigned int pattern; |
acd77415 TT |
937 | unsigned int (*test_func)(int, blk_t, |
938 | int, blk_t, | |
939 | unsigned int); | |
22301afb | 940 | int open_flag; |
1c29b097 | 941 | long sysval; |
3839e657 TT |
942 | |
943 | setbuf(stdout, NULL); | |
944 | setbuf(stderr, NULL); | |
d9c56d3c TT |
945 | #ifdef ENABLE_NLS |
946 | setlocale(LC_MESSAGES, ""); | |
14308a53 | 947 | setlocale(LC_CTYPE, ""); |
d9c56d3c TT |
948 | bindtextdomain(NLS_CAT_NAME, LOCALEDIR); |
949 | textdomain(NLS_CAT_NAME); | |
950 | #endif | |
6d40f568 | 951 | srandom((unsigned int)time(NULL)); /* simple randomness is enough */ |
4d003982 | 952 | test_func = test_ro; |
4d404547 | 953 | |
1c29b097 TT |
954 | /* Determine the system page size if possible */ |
955 | #ifdef HAVE_SYSCONF | |
956 | #if (!defined(_SC_PAGESIZE) && defined(_SC_PAGE_SIZE)) | |
957 | #define _SC_PAGESIZE _SC_PAGE_SIZE | |
958 | #endif | |
959 | #ifdef _SC_PAGESIZE | |
960 | sysval = sysconf(_SC_PAGESIZE); | |
961 | if (sysval > 0) | |
962 | sys_page_size = sysval; | |
963 | #endif /* _SC_PAGESIZE */ | |
964 | #endif /* HAVE_SYSCONF */ | |
efc6f628 | 965 | |
3839e657 TT |
966 | if (argc && *argv) |
967 | program_name = *argv; | |
264f64a5 | 968 | while ((c = getopt (argc, argv, "b:d:e:fi:o:svwnc:p:h:t:X")) != EOF) { |
3839e657 TT |
969 | switch (c) { |
970 | case 'b': | |
d4be9fad TT |
971 | block_size = parse_uint(optarg, "block size"); |
972 | if (block_size > 4096) { | |
3839e657 | 973 | com_err (program_name, 0, |
d9c56d3c | 974 | _("bad block size - %s"), optarg); |
3839e657 TT |
975 | exit (1); |
976 | } | |
977 | break; | |
981dc56a TT |
978 | case 'f': |
979 | force++; | |
980 | break; | |
879ac920 TT |
981 | case 'i': |
982 | input_file = optarg; | |
983 | break; | |
3839e657 TT |
984 | case 'o': |
985 | output_file = optarg; | |
986 | break; | |
987 | case 's': | |
988 | s_flag = 1; | |
989 | break; | |
990 | case 'v': | |
19c78dc0 | 991 | v_flag++; |
3839e657 TT |
992 | break; |
993 | case 'w': | |
4d003982 | 994 | if (w_flag) |
d8b5f777 | 995 | exclusive_usage(); |
4d003982 TT |
996 | test_func = test_rw; |
997 | w_flag = 1; | |
879ac920 TT |
998 | break; |
999 | case 'n': | |
4d003982 | 1000 | if (w_flag) |
d8b5f777 | 1001 | exclusive_usage(); |
4d003982 | 1002 | test_func = test_nd; |
879ac920 TT |
1003 | w_flag = 2; |
1004 | break; | |
1005 | case 'c': | |
d4be9fad | 1006 | blocks_at_once = parse_uint(optarg, "blocks at once"); |
879ac920 | 1007 | break; |
931b0289 IP |
1008 | case 'e': |
1009 | max_bb = parse_uint(optarg, "max bad block count"); | |
1010 | break; | |
264f64a5 IP |
1011 | case 'd': |
1012 | d_flag = parse_uint(optarg, "read delay factor"); | |
1013 | break; | |
879ac920 | 1014 | case 'p': |
efc6f628 | 1015 | num_passes = parse_uint(optarg, |
d4be9fad | 1016 | "number of clean passes"); |
879ac920 TT |
1017 | break; |
1018 | case 'h': | |
1019 | host_device_name = optarg; | |
3839e657 | 1020 | break; |
849b6bc8 TT |
1021 | case 't': |
1022 | if (t_flag + 1 > t_max) { | |
e9860ae9 | 1023 | unsigned int *t_patts_new; |
849b6bc8 | 1024 | |
efc6f628 | 1025 | t_patts_new = realloc(t_patts, sizeof(int) * |
69d81352 | 1026 | (t_max + T_INC)); |
849b6bc8 TT |
1027 | if (!t_patts_new) { |
1028 | com_err(program_name, ENOMEM, | |
1029 | _("can't allocate memory for " | |
1030 | "test_pattern - %s"), | |
1031 | optarg); | |
1032 | exit(1); | |
1033 | } | |
1034 | t_patts = t_patts_new; | |
1035 | t_max += T_INC; | |
1036 | } | |
84c05457 TT |
1037 | if (!strcmp(optarg, "r") || !strcmp(optarg,"random")) { |
1038 | t_patts[t_flag++] = ~0; | |
1039 | } else { | |
d4be9fad | 1040 | pattern = parse_uint(optarg, "test pattern"); |
e9860ae9 | 1041 | if (pattern == (unsigned int) ~0) |
84c05457 TT |
1042 | pattern = 0xffff; |
1043 | t_patts[t_flag++] = pattern; | |
849b6bc8 | 1044 | } |
849b6bc8 | 1045 | break; |
f63978af TT |
1046 | case 'X': |
1047 | exclusive_ok++; | |
1048 | break; | |
3839e657 | 1049 | default: |
818180cd | 1050 | usage(); |
3839e657 TT |
1051 | } |
1052 | } | |
849b6bc8 TT |
1053 | if (!w_flag) { |
1054 | if (t_flag > 1) { | |
1055 | com_err(program_name, 0, | |
1056 | _("Maximum of one test_pattern may be specified " | |
1057 | "in read-only mode")); | |
1058 | exit(1); | |
1059 | } | |
e9860ae9 | 1060 | if (t_patts && (t_patts[0] == (unsigned int) ~0)) { |
849b6bc8 TT |
1061 | com_err(program_name, 0, |
1062 | _("Random test_pattern is not allowed " | |
1063 | "in read-only mode")); | |
1064 | exit(1); | |
1065 | } | |
1066 | } | |
3839e657 | 1067 | if (optind > argc - 1) |
818180cd | 1068 | usage(); |
3839e657 | 1069 | device_name = argv[optind++]; |
35964b5c TT |
1070 | if (optind > argc - 1) { |
1071 | errcode = ext2fs_get_device_size(device_name, | |
1072 | block_size, | |
cd130a08 | 1073 | &last_block); |
35964b5c TT |
1074 | if (errcode == EXT2_ET_UNIMPLEMENTED) { |
1075 | com_err(program_name, 0, | |
1076 | _("Couldn't determine device size; you " | |
1077 | "must specify\nthe size manually\n")); | |
1078 | exit(1); | |
1079 | } | |
1080 | if (errcode) { | |
1081 | com_err(program_name, errcode, | |
1082 | _("while trying to determine device size")); | |
1083 | exit(1); | |
1084 | } | |
1085 | } else { | |
5267a520 | 1086 | errno = 0; |
f56f32b0 | 1087 | last_block = parse_uint(argv[optind], _("last block")); |
5267a520 | 1088 | last_block++; |
35964b5c | 1089 | optind++; |
3839e657 | 1090 | } |
35964b5c | 1091 | if (optind <= argc-1) { |
5267a520 | 1092 | errno = 0; |
f56f32b0 TT |
1093 | first_block = parse_uint(argv[optind], _("first block")); |
1094 | } else first_block = 0; | |
1095 | if (first_block >= last_block) { | |
d4e0b1c6 | 1096 | com_err (program_name, 0, _("invalid starting block (%lu): must be less than %lu"), |
f56f32b0 | 1097 | (unsigned long) first_block, (unsigned long) last_block); |
f3db3566 TT |
1098 | exit (1); |
1099 | } | |
981dc56a TT |
1100 | if (w_flag) |
1101 | check_mount(device_name); | |
efc6f628 | 1102 | |
22301afb | 1103 | open_flag = O_LARGEFILE | (w_flag ? O_RDWR : O_RDONLY); |
1c29b097 | 1104 | dev = open (device_name, open_flag); |
5493a27d | 1105 | if (dev == -1) { |
d9c56d3c | 1106 | com_err (program_name, errno, _("while trying to open %s"), |
3839e657 TT |
1107 | device_name); |
1108 | exit (1); | |
1109 | } | |
879ac920 | 1110 | if (host_device_name) { |
1c29b097 | 1111 | host_dev = open (host_device_name, open_flag); |
5493a27d | 1112 | if (host_dev == -1) { |
d9c56d3c TT |
1113 | com_err (program_name, errno, |
1114 | _("while trying to open %s"), | |
1115 | host_device_name); | |
879ac920 TT |
1116 | exit (1); |
1117 | } | |
1118 | } else | |
1119 | host_dev = dev; | |
3e699064 | 1120 | if (input_file) { |
879ac920 TT |
1121 | if (strcmp (input_file, "-") == 0) |
1122 | in = stdin; | |
1123 | else { | |
1124 | in = fopen (input_file, "r"); | |
1125 | if (in == NULL) | |
1126 | { | |
d9c56d3c TT |
1127 | com_err (program_name, errno, |
1128 | _("while trying to open %s"), | |
879ac920 TT |
1129 | input_file); |
1130 | exit (1); | |
1131 | } | |
1132 | } | |
3e699064 | 1133 | } |
3839e657 TT |
1134 | if (output_file && strcmp (output_file, "-") != 0) |
1135 | { | |
1136 | out = fopen (output_file, "w"); | |
1137 | if (out == NULL) | |
1138 | { | |
d9c56d3c TT |
1139 | com_err (program_name, errno, |
1140 | _("while trying to open %s"), | |
879ac920 | 1141 | output_file); |
3839e657 TT |
1142 | exit (1); |
1143 | } | |
1144 | } | |
1145 | else | |
1146 | out = stdout; | |
879ac920 TT |
1147 | |
1148 | errcode = ext2fs_badblocks_list_create(&bb_list,0); | |
1149 | if (errcode) { | |
d9c56d3c | 1150 | com_err (program_name, errcode, |
bb145b01 | 1151 | _("while creating in-memory bad blocks list")); |
879ac920 TT |
1152 | exit (1); |
1153 | } | |
1154 | ||
1155 | if (in) { | |
1156 | for(;;) { | |
a551b783 | 1157 | switch(fscanf (in, "%u\n", &next_bad)) { |
879ac920 TT |
1158 | case 0: |
1159 | com_err (program_name, 0, "input file - bad format"); | |
1160 | exit (1); | |
1161 | case EOF: | |
1162 | break; | |
1163 | default: | |
1164 | errcode = ext2fs_badblocks_list_add(bb_list,next_bad); | |
1165 | if (errcode) { | |
bb145b01 | 1166 | com_err (program_name, errcode, _("while adding to in-memory bad block list")); |
879ac920 TT |
1167 | exit (1); |
1168 | } | |
1169 | continue; | |
1170 | } | |
1171 | break; | |
1172 | } | |
1173 | ||
1174 | if (in != stdin) | |
1175 | fclose (in); | |
1176 | } | |
1177 | ||
1178 | do { | |
1179 | unsigned int bb_count; | |
1180 | ||
cd130a08 | 1181 | bb_count = test_func(dev, last_block, block_size, |
f56f32b0 | 1182 | first_block, blocks_at_once); |
4d003982 TT |
1183 | if (bb_count) |
1184 | passes_clean = 0; | |
1185 | else | |
1186 | ++passes_clean; | |
efc6f628 | 1187 | |
879ac920 | 1188 | if (v_flag) |
d9c56d3c | 1189 | fprintf(stderr, |
efc6f628 | 1190 | _("Pass completed, %u bad blocks found.\n"), |
d9c56d3c | 1191 | bb_count); |
879ac920 TT |
1192 | |
1193 | } while (passes_clean < num_passes); | |
1194 | ||
3839e657 TT |
1195 | close (dev); |
1196 | if (out != stdout) | |
1197 | fclose (out); | |
849b6bc8 TT |
1198 | if (t_patts) |
1199 | free(t_patts); | |
879ac920 | 1200 | return 0; |
3839e657 | 1201 | } |
d9c56d3c | 1202 |