misc/badblocks.c

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