1997-04-26 17:21:57 +04:00
|
|
|
/*
|
|
|
|
|
* badblocks.c - Bad blocks checker
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) 1992, 1993, 1994 Remy Card <card@masi.ibp.fr>
|
|
|
|
|
* Laboratoire MASI, Institut Blaise Pascal
|
|
|
|
|
* Universite Pierre et Marie Curie (Paris VI)
|
|
|
|
|
*
|
2000-02-07 02:57:07 +03:00
|
|
|
* Copyright 1995, 1996, 1997, 1998, 1999 by Theodore Ts'o
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
* Copyright 1999 by David Beattie
|
1997-04-29 20:17:09 +04:00
|
|
|
*
|
1997-04-26 17:21:57 +04:00
|
|
|
* This file is based on the minix file system programs fsck and mkfs
|
|
|
|
|
* written and copyrighted by Linus Torvalds <Linus.Torvalds@cs.helsinki.fi>
|
1997-04-29 20:17:09 +04:00
|
|
|
*
|
|
|
|
|
* %Begin-Header%
|
|
|
|
|
* This file may be redistributed under the terms of the GNU Public
|
|
|
|
|
* License.
|
|
|
|
|
* %End-Header%
|
1997-04-26 17:21:57 +04:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* History:
|
|
|
|
|
* 93/05/26 - Creation from e2fsck
|
|
|
|
|
* 94/02/27 - Made a separate bad blocks checker
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
* 99/06/30...99/07/26 - Added non-destructive write-testing,
|
2000-02-07 02:57:07 +03:00
|
|
|
* configurable blocks-at-once parameter,
|
|
|
|
|
* loading of badblocks list to avoid testing
|
|
|
|
|
* blocks known to be bad, multiple passes to
|
|
|
|
|
* make sure that no new blocks are added to the
|
|
|
|
|
* list. (Work done by David Beattie)
|
1997-04-26 17:21:57 +04:00
|
|
|
*/
|
|
|
|
|
|
2003-07-13 00:01:45 +04:00
|
|
|
#define _GNU_SOURCE /* for O_DIRECT */
|
|
|
|
|
|
1997-04-26 17:21:57 +04:00
|
|
|
#include <errno.h>
|
|
|
|
|
#include <fcntl.h>
|
1997-04-26 18:00:26 +04:00
|
|
|
#ifdef HAVE_GETOPT_H
|
1997-04-26 17:21:57 +04:00
|
|
|
#include <getopt.h>
|
Many files:
badblocks.c, dumpe2fs.c, e2label.c, mke2fs.c, tune2fs.c, uuidgen.c:
For platforms that don't define optarg.h, manually define optarg and
optind.
ChangeLog, main.c:
main.c: For platforms that don't define optarg.h, manually define
optarg and optind.
ChangeLog, unix.c:
unix.c: For platforms that don't define optarg.h, manually define
optarg and optind.
2000-04-03 20:22:35 +04:00
|
|
|
#else
|
|
|
|
|
extern char *optarg;
|
|
|
|
|
extern int optind;
|
1997-04-26 18:00:26 +04:00
|
|
|
#endif
|
1997-04-26 17:21:57 +04:00
|
|
|
#include <signal.h>
|
|
|
|
|
#include <stdio.h>
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
#include <string.h>
|
|
|
|
|
#include <unistd.h>
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
#include <setjmp.h>
|
2003-05-07 16:35:38 +04:00
|
|
|
#include <time.h>
|
2007-06-04 09:49:51 +04:00
|
|
|
#include <limits.h>
|
1997-04-26 17:21:57 +04:00
|
|
|
|
2008-06-19 00:26:26 +04:00
|
|
|
#include <sys/time.h>
|
1997-04-26 17:21:57 +04:00
|
|
|
#include <sys/ioctl.h>
|
1997-04-26 17:34:30 +04:00
|
|
|
#include <sys/types.h>
|
2008-07-07 02:36:56 +04:00
|
|
|
#include <sys/time.h>
|
1997-04-26 17:21:57 +04:00
|
|
|
|
|
|
|
|
#include "et/com_err.h"
|
1997-10-20 04:44:26 +04:00
|
|
|
#include "ext2fs/ext2_io.h"
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2image.c, findsuper.c, lsattr.c,
mke2fs.c, mklost+found.c, tune2fs.c, util.c: Change location of
ext2_fs.h to be ext2fs/ext2_fs.h
ChangeLog, Makefile.in, resize2fs.h:
resize2fs.h: Change location of ext2_fs.h to be ext2fs/ext2_fs.h
ChangeLog, Makefile.in, debugfs.h:
debugfs.h: Change location of ext2_fs.h to be ext2fs/ext2_fs.h
ChangeLog, Makefile.in, e2fsck.h, scantest.c:
e2fsck.h, scantest.c: Change location of ext2_fs.h to be
ext2fs/ext2_fs.h
ChangeLog, Makefile.in, tst_uuid.c, uuid_time.c:
tst_uuid.c, uuid_time.c: Remove unneeded #include of ext2_fs.h
ChangeLog, Makefile.in, e2p.h:
e2p.h: Change location of ext2_fs.h to be ext2fs/ext2_fs.h
ChangeLog, Makefile.in, test_icount.c, test_rel.c:
test_icount.c, test_rel.c: Change location of ext2_fs.h to be
ext2fs/ext2_fs.h
2001-05-14 15:45:38 +04:00
|
|
|
#include "ext2fs/ext2_fs.h"
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
#include "ext2fs/ext2fs.h"
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
#include "nls-enable.h"
|
1997-04-26 17:21:57 +04:00
|
|
|
|
|
|
|
|
const char * program_name = "badblocks";
|
2006-05-13 17:25:47 +04:00
|
|
|
const char * done_string = N_("done \n");
|
1997-04-26 17:21:57 +04:00
|
|
|
|
2000-04-03 20:01:11 +04:00
|
|
|
static int v_flag = 0; /* verbose */
|
|
|
|
|
static int w_flag = 0; /* do r/w test: 0=no, 1=yes,
|
|
|
|
|
* 2=non-destructive */
|
|
|
|
|
static int s_flag = 0; /* show progress of test */
|
2000-07-06 18:13:29 +04:00
|
|
|
static int force = 0; /* force check of mounted device */
|
2003-05-07 17:52:14 +04:00
|
|
|
static int t_flag = 0; /* number of test patterns */
|
|
|
|
|
static int t_max = 0; /* allocated test patterns */
|
2007-10-22 17:51:50 +04:00
|
|
|
static unsigned int *t_patts = NULL; /* test patterns */
|
2003-07-13 00:01:45 +04:00
|
|
|
static int current_O_DIRECT = 0; /* Current status of O_DIRECT flag */
|
2006-05-13 17:25:47 +04:00
|
|
|
static int exclusive_ok = 0;
|
2008-06-11 15:12:17 +04:00
|
|
|
static unsigned int max_bb = 0; /* Abort test if more than this number of bad blocks has been encountered */
|
badblocks: implement read throttling
Currently, badblocks will read as fast as it can from the drive. While
this is what one wants usually, if badblocks is run in read-only mode on
a drive that is in use, it will greatly degrade the other users of this
disk.
This patch adds a throttling mode for reads where each read will be
delayed by a percentage of the time the previous read took; i.e., an
invocation of '-d 100' will cause the sleep to be the same as the read
took, a value of 200 will cause the sleep to be twice as high, and a
value of 50 will cause it to be half. This will not be done if the
previous read had errors, since then the hardware will possibly have
timeouts and that would decrease the speed too much.
This algorithm helps when the disk is used by other processes as then,
due to the increased load, the time spent doing the reads will be
higher, and correspondingly badblocks will sleep even more and thus it
will use less of the drive's bandwidth. This is different from using
ionice, as it is a voluntary (and partial) throttling.
Signed-off-by: Iustin Pop <iustin@google.com>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
2008-06-12 11:30:04 +04:00
|
|
|
static unsigned int d_flag = 0; /* delay factor between reads */
|
2003-07-13 00:01:45 +04:00
|
|
|
|
2003-05-07 17:52:14 +04:00
|
|
|
#define T_INC 32
|
2000-04-03 20:01:11 +04:00
|
|
|
|
2007-10-22 18:09:05 +04:00
|
|
|
unsigned int sys_page_size = 4096;
|
2003-07-13 00:01:45 +04:00
|
|
|
|
2001-01-06 07:20:03 +03:00
|
|
|
static void usage(void)
|
1997-04-26 17:21:57 +04:00
|
|
|
{
|
2008-07-10 18:08:40 +04:00
|
|
|
fprintf(stderr, _("Usage: %s [-b block_size] [-i input_file] [-o output_file] [-svwnf]\n [-c blocks_at_once] [-p num_passes] [-e max_bad_blocks] [-d delay_factor_between_reads] [-t test_pattern [-t test_pattern [...]]]\n device [last_block [first_block]]\n"),
|
1997-04-26 17:21:57 +04:00
|
|
|
program_name);
|
|
|
|
|
exit (1);
|
|
|
|
|
}
|
|
|
|
|
|
2006-11-13 07:09:03 +03:00
|
|
|
static void exclusive_usage(void)
|
|
|
|
|
{
|
|
|
|
|
fprintf(stderr,
|
2006-11-18 07:00:19 +03:00
|
|
|
_("%s: The -n and -w options are mutually exclusive.\n\n"),
|
|
|
|
|
program_name);
|
|
|
|
|
exit(1);
|
2006-11-13 07:09:03 +03:00
|
|
|
}
|
|
|
|
|
|
2007-10-22 18:09:05 +04:00
|
|
|
static blk_t currently_testing = 0;
|
|
|
|
|
static blk_t num_blocks = 0;
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
static ext2_badblocks_list bb_list = NULL;
|
|
|
|
|
static FILE *out;
|
|
|
|
|
static blk_t next_bad = 0;
|
|
|
|
|
static ext2_badblocks_iterate bb_iter = NULL;
|
1997-04-29 20:17:09 +04:00
|
|
|
|
2003-07-13 00:01:45 +04:00
|
|
|
static void *allocate_buffer(size_t size)
|
|
|
|
|
{
|
|
|
|
|
void *ret = 0;
|
|
|
|
|
|
|
|
|
|
#ifdef HAVE_POSIX_MEMALIGN
|
|
|
|
|
if (posix_memalign(&ret, sys_page_size, size) < 0)
|
|
|
|
|
ret = 0;
|
|
|
|
|
#else
|
|
|
|
|
#ifdef HAVE_MEMALIGN
|
|
|
|
|
ret = memalign(sys_page_size, size);
|
|
|
|
|
#else
|
|
|
|
|
#ifdef HAVE_VALLOC
|
|
|
|
|
ret = valloc(size);
|
|
|
|
|
#endif /* HAVE_VALLOC */
|
|
|
|
|
#endif /* HAVE_MEMALIGN */
|
|
|
|
|
#endif /* HAVE_POSIX_MEMALIGN */
|
|
|
|
|
|
|
|
|
|
if (!ret)
|
|
|
|
|
ret = malloc(size);
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2000-02-07 02:57:07 +03:00
|
|
|
/*
|
|
|
|
|
* This routine reports a new bad block. If the bad block has already
|
|
|
|
|
* been seen before, then it returns 0; otherwise it returns 1.
|
|
|
|
|
*/
|
2007-10-22 18:09:05 +04:00
|
|
|
static int bb_output (blk_t bad)
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
{
|
|
|
|
|
errcode_t errcode;
|
|
|
|
|
|
2000-02-07 02:57:07 +03:00
|
|
|
if (ext2fs_badblocks_list_test(bb_list, bad))
|
|
|
|
|
return 0;
|
|
|
|
|
|
2007-10-22 18:09:05 +04:00
|
|
|
fprintf(out, "%lu\n", (unsigned long) bad);
|
2003-04-03 20:37:46 +04:00
|
|
|
fflush(out);
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
|
|
|
|
|
errcode = ext2fs_badblocks_list_add (bb_list, bad);
|
|
|
|
|
if (errcode) {
|
|
|
|
|
com_err (program_name, errcode, "adding to in-memory bad block list");
|
|
|
|
|
exit (1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* kludge:
|
|
|
|
|
increment the iteration through the bb_list if
|
|
|
|
|
an element was just added before the current iteration
|
|
|
|
|
position. This should not cause next_bad to change. */
|
|
|
|
|
if (bb_iter && bad < next_bad)
|
|
|
|
|
ext2fs_badblocks_list_iterate (bb_iter, &next_bad);
|
2000-02-07 02:57:07 +03:00
|
|
|
return 1;
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
}
|
|
|
|
|
|
2001-01-06 07:20:03 +03:00
|
|
|
static void print_status(void)
|
1997-04-29 20:17:09 +04:00
|
|
|
{
|
2007-10-22 18:09:05 +04:00
|
|
|
fprintf(stderr, "%15lu/%15lu", (unsigned long) currently_testing,
|
|
|
|
|
(unsigned long) num_blocks);
|
2005-01-06 22:48:59 +03:00
|
|
|
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);
|
1997-04-29 20:17:09 +04:00
|
|
|
fflush (stderr);
|
|
|
|
|
}
|
|
|
|
|
|
2003-12-07 09:28:50 +03:00
|
|
|
static void alarm_intr(int alnum EXT2FS_ATTR((unused)))
|
1997-04-29 20:17:09 +04:00
|
|
|
{
|
|
|
|
|
signal (SIGALRM, alarm_intr);
|
|
|
|
|
alarm(1);
|
|
|
|
|
if (!num_blocks)
|
|
|
|
|
return;
|
2005-01-06 22:48:59 +03:00
|
|
|
print_status();
|
1997-04-29 20:17:09 +04:00
|
|
|
}
|
|
|
|
|
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
static void *terminate_addr = NULL;
|
|
|
|
|
|
2003-12-07 09:28:50 +03:00
|
|
|
static void terminate_intr(int signo EXT2FS_ATTR((unused)))
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
{
|
|
|
|
|
if (terminate_addr)
|
|
|
|
|
longjmp(terminate_addr,1);
|
|
|
|
|
exit(1);
|
|
|
|
|
}
|
|
|
|
|
|
2000-07-06 18:13:29 +04:00
|
|
|
static void capture_terminate(jmp_buf term_addr)
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
{
|
|
|
|
|
terminate_addr = term_addr;
|
|
|
|
|
signal (SIGHUP, terminate_intr);
|
|
|
|
|
signal (SIGINT, terminate_intr);
|
|
|
|
|
signal (SIGPIPE, terminate_intr);
|
|
|
|
|
signal (SIGTERM, terminate_intr);
|
|
|
|
|
signal (SIGUSR1, terminate_intr);
|
|
|
|
|
signal (SIGUSR2, terminate_intr);
|
|
|
|
|
}
|
|
|
|
|
|
2001-01-06 07:20:03 +03:00
|
|
|
static void uncapture_terminate(void)
|
2000-04-03 20:01:11 +04:00
|
|
|
{
|
|
|
|
|
terminate_addr = NULL;
|
|
|
|
|
signal (SIGHUP, SIG_DFL);
|
|
|
|
|
signal (SIGINT, SIG_DFL);
|
|
|
|
|
signal (SIGPIPE, SIG_DFL);
|
|
|
|
|
signal (SIGTERM, SIG_DFL);
|
|
|
|
|
signal (SIGUSR1, SIG_DFL);
|
|
|
|
|
signal (SIGUSR2, SIG_DFL);
|
|
|
|
|
}
|
|
|
|
|
|
2003-08-01 08:58:00 +04:00
|
|
|
static void set_o_direct(int dev, unsigned char *buffer, size_t size,
|
2007-10-22 18:09:05 +04:00
|
|
|
blk_t current_block)
|
2003-07-13 00:01:45 +04:00
|
|
|
{
|
|
|
|
|
#ifdef O_DIRECT
|
|
|
|
|
int new_flag = O_DIRECT;
|
|
|
|
|
int flag;
|
|
|
|
|
|
|
|
|
|
if ((((unsigned long) buffer & (sys_page_size - 1)) != 0) ||
|
2003-08-01 08:58:00 +04:00
|
|
|
((size & (sys_page_size - 1)) != 0) ||
|
|
|
|
|
((current_block & ((sys_page_size >> 9)-1)) != 0))
|
2003-07-13 00:01:45 +04:00
|
|
|
new_flag = 0;
|
|
|
|
|
|
|
|
|
|
if (new_flag != current_O_DIRECT) {
|
2003-07-25 15:39:33 +04:00
|
|
|
/* printf("%s O_DIRECT\n", new_flag ? "Setting" : "Clearing"); */
|
2003-07-13 00:01:45 +04:00
|
|
|
flag = fcntl(dev, F_GETFL);
|
|
|
|
|
if (flag > 0) {
|
|
|
|
|
flag = (flag & ~O_DIRECT) | new_flag;
|
|
|
|
|
fcntl(dev, F_SETFL, flag);
|
|
|
|
|
}
|
|
|
|
|
current_O_DIRECT = new_flag;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2007-10-22 17:51:50 +04:00
|
|
|
static void pattern_fill(unsigned char *buffer, unsigned int pattern,
|
2003-05-18 09:11:52 +04:00
|
|
|
size_t n)
|
2003-05-07 17:52:14 +04:00
|
|
|
{
|
2003-12-07 09:28:50 +03:00
|
|
|
unsigned int i, nb;
|
2003-05-18 09:11:52 +04:00
|
|
|
unsigned char bpattern[sizeof(pattern)], *ptr;
|
2003-05-07 17:52:14 +04:00
|
|
|
|
2007-10-22 17:51:50 +04:00
|
|
|
if (pattern == (unsigned int) ~0) {
|
2003-05-07 17:52:14 +04:00
|
|
|
for (ptr = buffer; ptr < buffer + n; ptr++) {
|
|
|
|
|
(*ptr) = random() % (1 << (8 * sizeof(char)));
|
|
|
|
|
}
|
|
|
|
|
if (s_flag | v_flag)
|
2003-12-07 09:28:50 +03:00
|
|
|
fputs(_("Testing with random pattern: "), stderr);
|
2003-05-07 17:52:14 +04:00
|
|
|
} else {
|
|
|
|
|
bpattern[0] = 0;
|
|
|
|
|
for (i = 0; i < sizeof(bpattern); i++) {
|
|
|
|
|
if (pattern == 0)
|
|
|
|
|
break;
|
|
|
|
|
bpattern[i] = pattern & 0xFF;
|
|
|
|
|
pattern = pattern >> 8;
|
|
|
|
|
}
|
|
|
|
|
nb = i ? (i-1) : 0;
|
|
|
|
|
for (ptr = buffer, i = nb; ptr < buffer + n; ptr++) {
|
2003-12-07 09:28:50 +03:00
|
|
|
*ptr = bpattern[i];
|
|
|
|
|
if (i == 0)
|
2003-05-07 17:52:14 +04:00
|
|
|
i = nb;
|
2003-12-07 09:28:50 +03:00
|
|
|
else
|
|
|
|
|
i--;
|
2003-05-07 17:52:14 +04:00
|
|
|
}
|
2003-05-18 09:11:52 +04:00
|
|
|
if (s_flag | v_flag) {
|
2003-12-07 09:28:50 +03:00
|
|
|
fputs(_("Testing with pattern 0x"), stderr);
|
2003-05-18 09:11:52 +04:00
|
|
|
for (i = 0; i <= nb; i++)
|
|
|
|
|
fprintf(stderr, "%02x", buffer[i]);
|
2003-12-07 09:28:50 +03:00
|
|
|
fputs(": ", stderr);
|
2003-05-18 09:11:52 +04:00
|
|
|
}
|
2003-05-07 17:52:14 +04:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
1997-04-26 17:21:57 +04:00
|
|
|
/*
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
* Perform a read of a sequence of blocks; return the number of blocks
|
|
|
|
|
* successfully sequentially read.
|
1997-04-26 17:21:57 +04:00
|
|
|
*/
|
2007-10-22 18:09:05 +04:00
|
|
|
static int do_read (int dev, unsigned char * buffer, int try, int block_size,
|
|
|
|
|
blk_t current_block)
|
1997-04-26 17:21:57 +04:00
|
|
|
{
|
|
|
|
|
long got;
|
badblocks: implement read throttling
Currently, badblocks will read as fast as it can from the drive. While
this is what one wants usually, if badblocks is run in read-only mode on
a drive that is in use, it will greatly degrade the other users of this
disk.
This patch adds a throttling mode for reads where each read will be
delayed by a percentage of the time the previous read took; i.e., an
invocation of '-d 100' will cause the sleep to be the same as the read
took, a value of 200 will cause the sleep to be twice as high, and a
value of 50 will cause it to be half. This will not be done if the
previous read had errors, since then the hardware will possibly have
timeouts and that would decrease the speed too much.
This algorithm helps when the disk is used by other processes as then,
due to the increased load, the time spent doing the reads will be
higher, and correspondingly badblocks will sleep even more and thus it
will use less of the drive's bandwidth. This is different from using
ionice, as it is a voluntary (and partial) throttling.
Signed-off-by: Iustin Pop <iustin@google.com>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
2008-06-12 11:30:04 +04:00
|
|
|
struct timeval tv1, tv2;
|
|
|
|
|
#define NANOSEC (1000000000L)
|
|
|
|
|
#define MILISEC (1000L)
|
1997-04-26 17:21:57 +04:00
|
|
|
|
2003-08-01 08:58:00 +04:00
|
|
|
set_o_direct(dev, buffer, try * block_size, current_block);
|
2003-07-13 00:01:45 +04:00
|
|
|
|
1997-04-29 20:17:09 +04:00
|
|
|
if (v_flag > 1)
|
|
|
|
|
print_status();
|
|
|
|
|
|
1997-04-26 17:21:57 +04:00
|
|
|
/* Seek to the correct loc. */
|
1997-04-29 20:17:09 +04:00
|
|
|
if (ext2fs_llseek (dev, (ext2_loff_t) current_block * block_size,
|
1997-04-26 17:34:30 +04:00
|
|
|
SEEK_SET) != (ext2_loff_t) current_block * block_size)
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
com_err (program_name, errno, _("during seek"));
|
1997-04-26 17:21:57 +04:00
|
|
|
|
|
|
|
|
/* Try the read */
|
badblocks: implement read throttling
Currently, badblocks will read as fast as it can from the drive. While
this is what one wants usually, if badblocks is run in read-only mode on
a drive that is in use, it will greatly degrade the other users of this
disk.
This patch adds a throttling mode for reads where each read will be
delayed by a percentage of the time the previous read took; i.e., an
invocation of '-d 100' will cause the sleep to be the same as the read
took, a value of 200 will cause the sleep to be twice as high, and a
value of 50 will cause it to be half. This will not be done if the
previous read had errors, since then the hardware will possibly have
timeouts and that would decrease the speed too much.
This algorithm helps when the disk is used by other processes as then,
due to the increased load, the time spent doing the reads will be
higher, and correspondingly badblocks will sleep even more and thus it
will use less of the drive's bandwidth. This is different from using
ionice, as it is a voluntary (and partial) throttling.
Signed-off-by: Iustin Pop <iustin@google.com>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
2008-06-12 11:30:04 +04:00
|
|
|
if (d_flag)
|
2008-06-19 00:26:26 +04:00
|
|
|
gettimeofday(&tv1, NULL);
|
1997-04-26 17:21:57 +04:00
|
|
|
got = read (dev, buffer, try * block_size);
|
badblocks: implement read throttling
Currently, badblocks will read as fast as it can from the drive. While
this is what one wants usually, if badblocks is run in read-only mode on
a drive that is in use, it will greatly degrade the other users of this
disk.
This patch adds a throttling mode for reads where each read will be
delayed by a percentage of the time the previous read took; i.e., an
invocation of '-d 100' will cause the sleep to be the same as the read
took, a value of 200 will cause the sleep to be twice as high, and a
value of 50 will cause it to be half. This will not be done if the
previous read had errors, since then the hardware will possibly have
timeouts and that would decrease the speed too much.
This algorithm helps when the disk is used by other processes as then,
due to the increased load, the time spent doing the reads will be
higher, and correspondingly badblocks will sleep even more and thus it
will use less of the drive's bandwidth. This is different from using
ionice, as it is a voluntary (and partial) throttling.
Signed-off-by: Iustin Pop <iustin@google.com>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
2008-06-12 11:30:04 +04:00
|
|
|
if (d_flag)
|
2008-06-19 00:26:26 +04:00
|
|
|
gettimeofday(&tv2, NULL);
|
1997-04-26 17:21:57 +04:00
|
|
|
if (got < 0)
|
|
|
|
|
got = 0;
|
1999-07-16 14:41:36 +04:00
|
|
|
if (got & 511)
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
fprintf(stderr, _("Weird value (%ld) in do_read\n"), got);
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
got /= block_size;
|
badblocks: implement read throttling
Currently, badblocks will read as fast as it can from the drive. While
this is what one wants usually, if badblocks is run in read-only mode on
a drive that is in use, it will greatly degrade the other users of this
disk.
This patch adds a throttling mode for reads where each read will be
delayed by a percentage of the time the previous read took; i.e., an
invocation of '-d 100' will cause the sleep to be the same as the read
took, a value of 200 will cause the sleep to be twice as high, and a
value of 50 will cause it to be half. This will not be done if the
previous read had errors, since then the hardware will possibly have
timeouts and that would decrease the speed too much.
This algorithm helps when the disk is used by other processes as then,
due to the increased load, the time spent doing the reads will be
higher, and correspondingly badblocks will sleep even more and thus it
will use less of the drive's bandwidth. This is different from using
ionice, as it is a voluntary (and partial) throttling.
Signed-off-by: Iustin Pop <iustin@google.com>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
2008-06-12 11:30:04 +04:00
|
|
|
if (d_flag && got == try) {
|
|
|
|
|
struct timespec ts;
|
|
|
|
|
ts.tv_sec = tv2.tv_sec - tv1.tv_sec;
|
|
|
|
|
ts.tv_nsec = (tv2.tv_usec - tv1.tv_usec) * MILISEC;
|
|
|
|
|
if (ts.tv_nsec < 0) {
|
|
|
|
|
ts.tv_nsec += NANOSEC;
|
|
|
|
|
ts.tv_sec -= 1;
|
|
|
|
|
}
|
|
|
|
|
/* increase/decrease the sleep time based on d_flag value */
|
|
|
|
|
ts.tv_sec = ts.tv_sec * d_flag / 100;
|
|
|
|
|
ts.tv_nsec = ts.tv_nsec * d_flag / 100;
|
|
|
|
|
if (ts.tv_nsec > NANOSEC) {
|
|
|
|
|
ts.tv_sec += ts.tv_nsec / NANOSEC;
|
|
|
|
|
ts.tv_nsec %= NANOSEC;
|
|
|
|
|
}
|
|
|
|
|
if (ts.tv_sec || ts.tv_nsec)
|
|
|
|
|
nanosleep(&ts, NULL);
|
|
|
|
|
}
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
return got;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Perform a write of a sequence of blocks; return the number of blocks
|
|
|
|
|
* successfully sequentially written.
|
|
|
|
|
*/
|
2007-10-22 18:09:05 +04:00
|
|
|
static int do_write(int dev, unsigned char * buffer, int try, int block_size,
|
|
|
|
|
unsigned long current_block)
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
{
|
|
|
|
|
long got;
|
|
|
|
|
|
2003-08-01 08:58:00 +04:00
|
|
|
set_o_direct(dev, buffer, try * block_size, current_block);
|
2003-07-13 00:01:45 +04:00
|
|
|
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
if (v_flag > 1)
|
|
|
|
|
print_status();
|
|
|
|
|
|
|
|
|
|
/* Seek to the correct loc. */
|
|
|
|
|
if (ext2fs_llseek (dev, (ext2_loff_t) current_block * block_size,
|
|
|
|
|
SEEK_SET) != (ext2_loff_t) current_block * block_size)
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
com_err (program_name, errno, _("during seek"));
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
|
|
|
|
|
/* Try the write */
|
|
|
|
|
got = write (dev, buffer, try * block_size);
|
|
|
|
|
if (got < 0)
|
|
|
|
|
got = 0;
|
|
|
|
|
if (got & 511)
|
2003-12-07 09:28:50 +03:00
|
|
|
fprintf(stderr, "Weird value (%ld) in do_write\n", got);
|
1997-04-26 17:21:57 +04:00
|
|
|
got /= block_size;
|
|
|
|
|
return got;
|
|
|
|
|
}
|
|
|
|
|
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
static int host_dev;
|
|
|
|
|
|
2001-01-11 19:04:59 +03:00
|
|
|
static void flush_bufs(void)
|
1997-04-26 18:00:26 +04:00
|
|
|
{
|
2001-01-11 19:04:59 +03:00
|
|
|
errcode_t retval;
|
1997-04-26 18:00:26 +04:00
|
|
|
|
2001-01-11 19:04:59 +03:00
|
|
|
retval = ext2fs_sync_device(host_dev, 1);
|
|
|
|
|
if (retval)
|
|
|
|
|
com_err(program_name, retval, _("during ext2fs_sync_device"));
|
1997-04-26 18:00:26 +04:00
|
|
|
}
|
|
|
|
|
|
2007-10-22 18:09:05 +04:00
|
|
|
static unsigned int test_ro (int dev, blk_t last_block,
|
2008-07-10 18:08:40 +04:00
|
|
|
int block_size, blk_t first_block,
|
2007-10-22 18:09:05 +04:00
|
|
|
unsigned int blocks_at_once)
|
1997-04-26 17:21:57 +04:00
|
|
|
{
|
2003-07-06 08:36:48 +04:00
|
|
|
unsigned char * blkbuf;
|
1997-04-26 17:21:57 +04:00
|
|
|
int try;
|
2007-10-22 18:09:05 +04:00
|
|
|
int got;
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
unsigned int bb_count = 0;
|
|
|
|
|
errcode_t errcode;
|
1997-04-26 17:21:57 +04:00
|
|
|
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
errcode = ext2fs_badblocks_list_iterate_begin(bb_list,&bb_iter);
|
|
|
|
|
if (errcode) {
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
com_err (program_name, errcode,
|
|
|
|
|
_("while beginning bad block list iteration"));
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
exit (1);
|
|
|
|
|
}
|
|
|
|
|
do {
|
|
|
|
|
ext2fs_badblocks_list_iterate (bb_iter, &next_bad);
|
2008-07-10 18:08:40 +04:00
|
|
|
} while (next_bad && next_bad < first_block);
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
|
2003-05-07 17:52:14 +04:00
|
|
|
if (t_flag) {
|
2003-07-13 00:01:45 +04:00
|
|
|
blkbuf = allocate_buffer((blocks_at_once + 1) * block_size);
|
2003-05-07 17:52:14 +04:00
|
|
|
} else {
|
2003-07-13 00:01:45 +04:00
|
|
|
blkbuf = allocate_buffer(blocks_at_once * block_size);
|
2003-05-07 17:52:14 +04:00
|
|
|
}
|
1997-04-26 17:21:57 +04:00
|
|
|
if (!blkbuf)
|
|
|
|
|
{
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
com_err (program_name, ENOMEM, _("while allocating buffers"));
|
1997-04-26 17:21:57 +04:00
|
|
|
exit (1);
|
|
|
|
|
}
|
1997-04-26 17:34:30 +04:00
|
|
|
if (v_flag) {
|
2007-10-22 18:09:05 +04:00
|
|
|
fprintf (stderr, _("Checking blocks %lu to %lu\n"),
|
2008-07-10 18:08:40 +04:00
|
|
|
(unsigned long) first_block,
|
2007-10-22 18:09:05 +04:00
|
|
|
(unsigned long) last_block - 1);
|
1997-04-26 17:34:30 +04:00
|
|
|
}
|
2003-05-07 17:52:14 +04:00
|
|
|
if (t_flag) {
|
2003-12-07 09:28:50 +03:00
|
|
|
fputs(_("Checking for bad blocks in read-only mode\n"), stderr);
|
2003-05-07 17:52:14 +04:00
|
|
|
pattern_fill(blkbuf + blocks_at_once * block_size,
|
|
|
|
|
t_patts[0], block_size);
|
|
|
|
|
}
|
|
|
|
|
flush_bufs();
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
try = blocks_at_once;
|
2008-07-10 18:08:40 +04:00
|
|
|
currently_testing = first_block;
|
2006-10-04 07:35:57 +04:00
|
|
|
num_blocks = last_block - 1;
|
2003-05-07 17:52:14 +04:00
|
|
|
if (!t_flag && (s_flag || v_flag)) {
|
2003-12-07 09:28:50 +03:00
|
|
|
fputs(_("Checking for bad blocks (read-only test): "), stderr);
|
1997-04-29 20:17:09 +04:00
|
|
|
if (v_flag <= 1)
|
|
|
|
|
alarm_intr(SIGALRM);
|
1997-04-26 17:21:57 +04:00
|
|
|
}
|
2001-05-05 09:43:23 +04:00
|
|
|
while (currently_testing < last_block)
|
1997-04-26 17:21:57 +04:00
|
|
|
{
|
2008-06-11 15:12:17 +04:00
|
|
|
if (max_bb && bb_count >= max_bb) {
|
|
|
|
|
if (s_flag || v_flag) {
|
|
|
|
|
fputs(_("Too many bad blocks, aborting test\n"), stderr);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
if (next_bad) {
|
|
|
|
|
if (currently_testing == next_bad) {
|
|
|
|
|
/* fprintf (out, "%lu\n", nextbad); */
|
|
|
|
|
ext2fs_badblocks_list_iterate (bb_iter, &next_bad);
|
|
|
|
|
currently_testing++;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
else if (currently_testing + try > next_bad)
|
|
|
|
|
try = next_bad - currently_testing;
|
|
|
|
|
}
|
2001-05-05 09:43:23 +04:00
|
|
|
if (currently_testing + try > last_block)
|
|
|
|
|
try = last_block - currently_testing;
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
got = do_read (dev, blkbuf, try, block_size, currently_testing);
|
2003-05-07 17:52:14 +04:00
|
|
|
if (t_flag) {
|
|
|
|
|
/* test the comparison between all the
|
|
|
|
|
blocks successfully read */
|
|
|
|
|
int i;
|
|
|
|
|
for (i = 0; i < got; ++i)
|
|
|
|
|
if (memcmp (blkbuf+i*block_size,
|
|
|
|
|
blkbuf+blocks_at_once*block_size,
|
|
|
|
|
block_size))
|
|
|
|
|
bb_count += bb_output(currently_testing + i);
|
|
|
|
|
}
|
1997-04-26 17:21:57 +04:00
|
|
|
currently_testing += got;
|
|
|
|
|
if (got == try) {
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
try = blocks_at_once;
|
2003-08-01 08:58:00 +04:00
|
|
|
/* recover page-aligned offset for O_DIRECT */
|
2007-10-22 18:09:05 +04:00
|
|
|
if ( (blocks_at_once >= sys_page_size >> 9)
|
2003-08-01 08:58:00 +04:00
|
|
|
&& (currently_testing % (sys_page_size >> 9)!= 0))
|
|
|
|
|
try -= (sys_page_size >> 9)
|
|
|
|
|
- (currently_testing
|
|
|
|
|
% (sys_page_size >> 9));
|
1997-04-26 17:21:57 +04:00
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
try = 1;
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
if (got == 0) {
|
2000-02-07 02:57:07 +03:00
|
|
|
bb_count += bb_output(currently_testing++);
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
}
|
1997-04-26 17:21:57 +04:00
|
|
|
}
|
|
|
|
|
num_blocks = 0;
|
|
|
|
|
alarm(0);
|
2003-05-07 17:52:14 +04:00
|
|
|
if (s_flag || v_flag)
|
2004-09-19 16:04:44 +04:00
|
|
|
fputs(_(done_string), stderr);
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
|
1997-04-26 17:34:30 +04:00
|
|
|
fflush (stderr);
|
1997-04-26 17:21:57 +04:00
|
|
|
free (blkbuf);
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
|
|
|
|
|
ext2fs_badblocks_list_iterate_end(bb_iter);
|
|
|
|
|
|
|
|
|
|
return bb_count;
|
1997-04-26 17:21:57 +04:00
|
|
|
}
|
|
|
|
|
|
2007-10-22 18:09:05 +04:00
|
|
|
static unsigned int test_rw (int dev, blk_t last_block,
|
2008-07-10 18:08:40 +04:00
|
|
|
int block_size, blk_t first_block,
|
2007-10-22 18:09:05 +04:00
|
|
|
unsigned int blocks_at_once)
|
1997-04-26 17:21:57 +04:00
|
|
|
{
|
2003-07-13 00:01:45 +04:00
|
|
|
unsigned char *buffer, *read_buffer;
|
2007-10-22 17:51:50 +04:00
|
|
|
const unsigned int patterns[] = {0xaa, 0x55, 0xff, 0x00};
|
|
|
|
|
const unsigned int *pattern;
|
2003-07-13 00:01:45 +04:00
|
|
|
int i, try, got, nr_pattern, pat_idx;
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
unsigned int bb_count = 0;
|
1997-04-26 17:21:57 +04:00
|
|
|
|
2003-07-13 00:01:45 +04:00
|
|
|
buffer = allocate_buffer(2 * blocks_at_once * block_size);
|
|
|
|
|
read_buffer = buffer + blocks_at_once * block_size;
|
|
|
|
|
|
|
|
|
|
if (!buffer) {
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
com_err (program_name, ENOMEM, _("while allocating buffers"));
|
1997-04-26 17:21:57 +04:00
|
|
|
exit (1);
|
|
|
|
|
}
|
|
|
|
|
|
2001-01-11 19:04:59 +03:00
|
|
|
flush_bufs();
|
1997-04-26 18:00:26 +04:00
|
|
|
|
1997-04-29 20:17:09 +04:00
|
|
|
if (v_flag) {
|
2003-12-07 09:28:50 +03:00
|
|
|
fputs(_("Checking for bad blocks in read-write mode\n"),
|
|
|
|
|
stderr);
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
fprintf(stderr, _("From block %lu to %lu\n"),
|
2008-07-10 18:08:40 +04:00
|
|
|
(unsigned long) first_block,
|
|
|
|
|
(unsigned long) last_block - 1);
|
1997-04-29 20:17:09 +04:00
|
|
|
}
|
2003-05-07 17:52:14 +04:00
|
|
|
if (t_flag) {
|
|
|
|
|
pattern = t_patts;
|
|
|
|
|
nr_pattern = t_flag;
|
|
|
|
|
} else {
|
|
|
|
|
pattern = patterns;
|
|
|
|
|
nr_pattern = sizeof(patterns) / sizeof(patterns[0]);
|
|
|
|
|
}
|
|
|
|
|
for (pat_idx = 0; pat_idx < nr_pattern; pat_idx++) {
|
2003-07-13 00:01:45 +04:00
|
|
|
pattern_fill(buffer, pattern[pat_idx],
|
|
|
|
|
blocks_at_once * block_size);
|
2006-10-04 07:35:57 +04:00
|
|
|
num_blocks = last_block - 1;
|
2008-07-10 18:08:40 +04:00
|
|
|
currently_testing = first_block;
|
1997-04-29 20:17:09 +04:00
|
|
|
if (s_flag && v_flag <= 1)
|
1997-04-26 17:34:30 +04:00
|
|
|
alarm_intr(SIGALRM);
|
2003-07-13 00:01:45 +04:00
|
|
|
|
|
|
|
|
try = blocks_at_once;
|
|
|
|
|
while (currently_testing < last_block) {
|
2008-06-11 15:12:17 +04:00
|
|
|
if (max_bb && bb_count >= max_bb) {
|
|
|
|
|
if (s_flag || v_flag) {
|
|
|
|
|
fputs(_("Too many bad blocks, aborting test\n"), stderr);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
2003-07-13 00:01:45 +04:00
|
|
|
if (currently_testing + try > last_block)
|
|
|
|
|
try = last_block - currently_testing;
|
|
|
|
|
got = do_write(dev, buffer, try, block_size,
|
|
|
|
|
currently_testing);
|
1997-04-29 20:17:09 +04:00
|
|
|
if (v_flag > 1)
|
|
|
|
|
print_status();
|
2003-07-13 00:01:45 +04:00
|
|
|
|
|
|
|
|
currently_testing += got;
|
|
|
|
|
if (got == try) {
|
|
|
|
|
try = blocks_at_once;
|
2003-08-01 08:58:00 +04:00
|
|
|
/* recover page-aligned offset for O_DIRECT */
|
2007-10-22 18:09:05 +04:00
|
|
|
if ( (blocks_at_once >= sys_page_size >> 9)
|
2003-08-01 08:58:00 +04:00
|
|
|
&& (currently_testing %
|
|
|
|
|
(sys_page_size >> 9)!= 0))
|
|
|
|
|
try -= (sys_page_size >> 9)
|
|
|
|
|
- (currently_testing
|
|
|
|
|
% (sys_page_size >> 9));
|
2003-07-13 00:01:45 +04:00
|
|
|
continue;
|
|
|
|
|
} else
|
|
|
|
|
try = 1;
|
|
|
|
|
if (got == 0) {
|
|
|
|
|
bb_count += bb_output(currently_testing++);
|
|
|
|
|
}
|
1997-04-26 17:21:57 +04:00
|
|
|
}
|
2003-07-13 00:01:45 +04:00
|
|
|
|
1997-04-26 17:34:30 +04:00
|
|
|
num_blocks = 0;
|
|
|
|
|
alarm (0);
|
|
|
|
|
if (s_flag | v_flag)
|
2004-09-19 16:04:44 +04:00
|
|
|
fputs(_(done_string), stderr);
|
2001-01-11 19:04:59 +03:00
|
|
|
flush_bufs();
|
1997-04-26 17:34:30 +04:00
|
|
|
if (s_flag | v_flag)
|
2003-12-07 09:28:50 +03:00
|
|
|
fputs(_("Reading and comparing: "), stderr);
|
2001-05-05 09:43:23 +04:00
|
|
|
num_blocks = last_block;
|
2008-07-10 18:08:40 +04:00
|
|
|
currently_testing = first_block;
|
1997-04-29 20:17:09 +04:00
|
|
|
if (s_flag && v_flag <= 1)
|
1997-04-26 17:34:30 +04:00
|
|
|
alarm_intr(SIGALRM);
|
2003-07-13 00:01:45 +04:00
|
|
|
|
|
|
|
|
try = blocks_at_once;
|
|
|
|
|
while (currently_testing < last_block) {
|
2008-06-11 15:12:17 +04:00
|
|
|
if (max_bb && bb_count >= max_bb) {
|
|
|
|
|
if (s_flag || v_flag) {
|
|
|
|
|
fputs(_("Too many bad blocks, aborting test\n"), stderr);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
2003-07-13 00:01:45 +04:00
|
|
|
if (currently_testing + try > last_block)
|
|
|
|
|
try = last_block - currently_testing;
|
|
|
|
|
got = do_read (dev, read_buffer, try, block_size,
|
|
|
|
|
currently_testing);
|
|
|
|
|
if (got == 0) {
|
|
|
|
|
bb_count += bb_output(currently_testing++);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
for (i=0; i < got; i++) {
|
|
|
|
|
if (memcmp(read_buffer + i * block_size,
|
|
|
|
|
buffer + i * block_size,
|
|
|
|
|
block_size))
|
|
|
|
|
bb_count += bb_output(currently_testing+i);
|
|
|
|
|
}
|
|
|
|
|
currently_testing += got;
|
2003-08-01 08:58:00 +04:00
|
|
|
/* recover page-aligned offset for O_DIRECT */
|
2007-10-22 18:09:05 +04:00
|
|
|
if ( (blocks_at_once >= sys_page_size >> 9)
|
2003-08-01 08:58:00 +04:00
|
|
|
&& (currently_testing % (sys_page_size >> 9)!= 0))
|
|
|
|
|
try = blocks_at_once - (sys_page_size >> 9)
|
|
|
|
|
- (currently_testing
|
|
|
|
|
% (sys_page_size >> 9));
|
|
|
|
|
else
|
|
|
|
|
try = blocks_at_once;
|
1997-04-29 20:17:09 +04:00
|
|
|
if (v_flag > 1)
|
|
|
|
|
print_status();
|
1997-04-26 17:21:57 +04:00
|
|
|
}
|
2003-07-13 00:01:45 +04:00
|
|
|
|
1997-04-26 17:34:30 +04:00
|
|
|
num_blocks = 0;
|
|
|
|
|
alarm (0);
|
|
|
|
|
if (s_flag | v_flag)
|
2004-09-19 16:04:44 +04:00
|
|
|
fputs(_(done_string), stderr);
|
2001-01-11 19:04:59 +03:00
|
|
|
flush_bufs();
|
1997-04-26 17:21:57 +04:00
|
|
|
}
|
2003-05-07 17:52:14 +04:00
|
|
|
uncapture_terminate();
|
2003-05-07 16:35:38 +04:00
|
|
|
free(buffer);
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
return bb_count;
|
|
|
|
|
}
|
|
|
|
|
|
2000-07-06 04:31:27 +04:00
|
|
|
struct saved_blk_record {
|
|
|
|
|
blk_t block;
|
|
|
|
|
int num;
|
|
|
|
|
};
|
|
|
|
|
|
2007-10-22 18:09:05 +04:00
|
|
|
static unsigned int test_nd (int dev, blk_t last_block,
|
2008-07-10 18:08:40 +04:00
|
|
|
int block_size, blk_t first_block,
|
2007-10-22 18:09:05 +04:00
|
|
|
unsigned int blocks_at_once)
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
{
|
2003-07-06 08:36:48 +04:00
|
|
|
unsigned char *blkbuf, *save_ptr, *test_ptr, *read_ptr;
|
2003-07-13 00:01:45 +04:00
|
|
|
unsigned char *test_base, *save_base, *read_base;
|
2000-02-07 02:57:07 +03:00
|
|
|
int try, i;
|
2007-10-22 17:51:50 +04:00
|
|
|
const unsigned int patterns[] = { ~0 };
|
|
|
|
|
const unsigned int *pattern;
|
2003-05-07 17:52:14 +04:00
|
|
|
int nr_pattern, pat_idx;
|
2007-10-22 18:09:05 +04:00
|
|
|
int got, used2, written;
|
|
|
|
|
blk_t save_currently_testing;
|
2000-07-06 04:31:27 +04:00
|
|
|
struct saved_blk_record *test_record;
|
2000-07-14 02:05:31 +04:00
|
|
|
/* This is static to prevent being clobbered by the longjmp */
|
|
|
|
|
static int num_saved;
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
jmp_buf terminate_env;
|
|
|
|
|
errcode_t errcode;
|
2003-12-07 09:28:50 +03:00
|
|
|
unsigned long buf_used;
|
|
|
|
|
static unsigned int bb_count;
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
|
2003-12-07 09:28:50 +03:00
|
|
|
bb_count = 0;
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
errcode = ext2fs_badblocks_list_iterate_begin(bb_list,&bb_iter);
|
|
|
|
|
if (errcode) {
|
2000-02-07 02:57:07 +03:00
|
|
|
com_err (program_name, errcode,
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
_("while beginning bad block list iteration"));
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
exit (1);
|
|
|
|
|
}
|
|
|
|
|
do {
|
|
|
|
|
ext2fs_badblocks_list_iterate (bb_iter, &next_bad);
|
2008-07-10 18:08:40 +04:00
|
|
|
} while (next_bad && next_bad < first_block);
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
|
2003-07-13 00:01:45 +04:00
|
|
|
blkbuf = allocate_buffer(3 * blocks_at_once * block_size);
|
2000-07-06 04:31:27 +04:00
|
|
|
test_record = malloc (blocks_at_once*sizeof(struct saved_blk_record));
|
|
|
|
|
if (!blkbuf || !test_record) {
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
com_err(program_name, ENOMEM, _("while allocating buffers"));
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
exit (1);
|
|
|
|
|
}
|
2003-07-13 00:01:45 +04:00
|
|
|
|
|
|
|
|
save_base = blkbuf;
|
|
|
|
|
test_base = blkbuf + (blocks_at_once * block_size);
|
|
|
|
|
read_base = blkbuf + (2 * blocks_at_once * block_size);
|
|
|
|
|
|
2000-07-06 04:31:27 +04:00
|
|
|
num_saved = 0;
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
|
2001-01-11 19:04:59 +03:00
|
|
|
flush_bufs();
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
if (v_flag) {
|
2003-12-07 09:28:50 +03:00
|
|
|
fputs(_("Checking for bad blocks in non-destructive read-write mode\n"), stderr);
|
2007-10-22 18:09:05 +04:00
|
|
|
fprintf (stderr, _("From block %lu to %lu\n"),
|
2008-07-10 18:08:40 +04:00
|
|
|
(unsigned long) first_block,
|
|
|
|
|
(unsigned long) last_block - 1);
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
}
|
|
|
|
|
if (s_flag || v_flag > 1) {
|
2003-12-07 09:28:50 +03:00
|
|
|
fputs(_("Checking for bad blocks (non-destructive read-write test)\n"), stderr);
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
}
|
2000-04-03 20:01:11 +04:00
|
|
|
if (setjmp(terminate_env)) {
|
|
|
|
|
/*
|
|
|
|
|
* Abnormal termination by a signal is handled here.
|
|
|
|
|
*/
|
2000-07-14 02:05:31 +04:00
|
|
|
signal (SIGALRM, SIG_IGN);
|
2003-12-07 09:28:50 +03:00
|
|
|
fputs(_("\nInterrupt caught, cleaning up\n"), stderr);
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
|
2003-07-13 00:01:45 +04:00
|
|
|
save_ptr = save_base;
|
2000-07-06 04:31:27 +04:00
|
|
|
for (i=0; i < num_saved; i++) {
|
|
|
|
|
do_write(dev, save_ptr, test_record[i].num,
|
|
|
|
|
block_size, test_record[i].block);
|
|
|
|
|
save_ptr += test_record[i].num * block_size;
|
|
|
|
|
}
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
fflush (out);
|
2000-02-07 02:57:07 +03:00
|
|
|
exit(1);
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
}
|
2000-04-03 20:01:11 +04:00
|
|
|
|
|
|
|
|
/* set up abend handler */
|
|
|
|
|
capture_terminate(terminate_env);
|
|
|
|
|
|
2003-05-07 17:52:14 +04:00
|
|
|
if (t_flag) {
|
|
|
|
|
pattern = t_patts;
|
|
|
|
|
nr_pattern = t_flag;
|
|
|
|
|
} else {
|
|
|
|
|
pattern = patterns;
|
|
|
|
|
nr_pattern = sizeof(patterns) / sizeof(patterns[0]);
|
|
|
|
|
}
|
|
|
|
|
for (pat_idx = 0; pat_idx < nr_pattern; pat_idx++) {
|
2003-07-13 00:01:45 +04:00
|
|
|
pattern_fill(test_base, pattern[pat_idx],
|
|
|
|
|
blocks_at_once * block_size);
|
2000-04-03 20:01:11 +04:00
|
|
|
|
2003-05-07 17:52:14 +04:00
|
|
|
buf_used = 0;
|
|
|
|
|
bb_count = 0;
|
2003-07-13 00:01:45 +04:00
|
|
|
save_ptr = save_base;
|
|
|
|
|
test_ptr = test_base;
|
2008-07-10 18:08:40 +04:00
|
|
|
currently_testing = first_block;
|
2006-10-04 07:35:57 +04:00
|
|
|
num_blocks = last_block - 1;
|
2003-05-07 17:52:14 +04:00
|
|
|
if (s_flag && v_flag <= 1)
|
|
|
|
|
alarm_intr(SIGALRM);
|
2000-04-03 20:01:11 +04:00
|
|
|
|
2003-05-07 17:52:14 +04:00
|
|
|
while (currently_testing < last_block) {
|
2008-06-11 15:12:17 +04:00
|
|
|
if (max_bb && bb_count >= max_bb) {
|
|
|
|
|
if (s_flag || v_flag) {
|
|
|
|
|
fputs(_("Too many bad blocks, aborting test\n"), stderr);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
2003-07-13 00:01:45 +04:00
|
|
|
got = try = blocks_at_once - buf_used;
|
2003-05-07 17:52:14 +04:00
|
|
|
if (next_bad) {
|
|
|
|
|
if (currently_testing == next_bad) {
|
|
|
|
|
/* fprintf (out, "%lu\n", nextbad); */
|
|
|
|
|
ext2fs_badblocks_list_iterate (bb_iter, &next_bad);
|
|
|
|
|
currently_testing++;
|
|
|
|
|
goto check_for_more;
|
|
|
|
|
}
|
|
|
|
|
else if (currently_testing + try > next_bad)
|
|
|
|
|
try = next_bad - currently_testing;
|
2000-07-06 04:31:27 +04:00
|
|
|
}
|
2003-05-07 17:52:14 +04:00
|
|
|
if (currently_testing + try > last_block)
|
|
|
|
|
try = last_block - currently_testing;
|
|
|
|
|
got = do_read (dev, save_ptr, try, block_size,
|
|
|
|
|
currently_testing);
|
|
|
|
|
if (got == 0) {
|
|
|
|
|
/* First block must have been bad. */
|
|
|
|
|
bb_count += bb_output(currently_testing++);
|
|
|
|
|
goto check_for_more;
|
2000-04-03 20:01:11 +04:00
|
|
|
}
|
|
|
|
|
|
2003-05-07 17:52:14 +04:00
|
|
|
/*
|
|
|
|
|
* Note the fact that we've saved this much data
|
|
|
|
|
* *before* we overwrite it with test data
|
|
|
|
|
*/
|
|
|
|
|
test_record[num_saved].block = currently_testing;
|
|
|
|
|
test_record[num_saved].num = got;
|
|
|
|
|
num_saved++;
|
|
|
|
|
|
|
|
|
|
/* Write the test data */
|
|
|
|
|
written = do_write (dev, test_ptr, got, block_size,
|
|
|
|
|
currently_testing);
|
|
|
|
|
if (written != got)
|
|
|
|
|
com_err (program_name, errno,
|
|
|
|
|
_("during test data write, block %lu"),
|
2007-10-22 18:09:05 +04:00
|
|
|
(unsigned long) currently_testing +
|
|
|
|
|
written);
|
2003-05-07 17:52:14 +04:00
|
|
|
|
|
|
|
|
buf_used += got;
|
2000-04-03 20:01:11 +04:00
|
|
|
save_ptr += got * block_size;
|
|
|
|
|
test_ptr += got * block_size;
|
2003-05-07 17:52:14 +04:00
|
|
|
currently_testing += got;
|
|
|
|
|
if (got != try)
|
|
|
|
|
bb_count += bb_output(currently_testing++);
|
|
|
|
|
|
|
|
|
|
check_for_more:
|
|
|
|
|
/*
|
|
|
|
|
* If there's room for more blocks to be tested this
|
|
|
|
|
* around, and we're not done yet testing the disk, go
|
|
|
|
|
* back and get some more blocks.
|
|
|
|
|
*/
|
|
|
|
|
if ((buf_used != blocks_at_once) &&
|
|
|
|
|
(currently_testing < last_block))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
flush_bufs();
|
|
|
|
|
save_currently_testing = currently_testing;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* for each contiguous block that we read into the
|
|
|
|
|
* buffer (and wrote test data into afterwards), read
|
|
|
|
|
* it back (looping if necessary, to get past newly
|
|
|
|
|
* discovered unreadable blocks, of which there should
|
|
|
|
|
* be none, but with a hard drive which is unreliable,
|
|
|
|
|
* it has happened), and compare with the test data
|
|
|
|
|
* that was written; output to the bad block list if
|
|
|
|
|
* it doesn't match.
|
|
|
|
|
*/
|
|
|
|
|
used2 = 0;
|
2003-07-13 00:01:45 +04:00
|
|
|
save_ptr = save_base;
|
|
|
|
|
test_ptr = test_base;
|
|
|
|
|
read_ptr = read_base;
|
2003-05-07 17:52:14 +04:00
|
|
|
try = 0;
|
|
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
|
if (try == 0) {
|
|
|
|
|
if (used2 >= num_saved)
|
|
|
|
|
break;
|
|
|
|
|
currently_testing = test_record[used2].block;
|
|
|
|
|
try = test_record[used2].num;
|
|
|
|
|
used2++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
got = do_read (dev, read_ptr, try,
|
|
|
|
|
block_size, currently_testing);
|
|
|
|
|
|
|
|
|
|
/* test the comparison between all the
|
|
|
|
|
blocks successfully read */
|
|
|
|
|
for (i = 0; i < got; ++i)
|
|
|
|
|
if (memcmp (test_ptr+i*block_size,
|
|
|
|
|
read_ptr+i*block_size, block_size))
|
|
|
|
|
bb_count += bb_output(currently_testing + i);
|
|
|
|
|
if (got < try) {
|
|
|
|
|
bb_count += bb_output(currently_testing + got);
|
|
|
|
|
got++;
|
|
|
|
|
}
|
|
|
|
|
|
2003-07-13 00:01:45 +04:00
|
|
|
/* write back original data */
|
|
|
|
|
do_write (dev, save_ptr, got,
|
|
|
|
|
block_size, currently_testing);
|
|
|
|
|
save_ptr += got * block_size;
|
2003-05-07 17:52:14 +04:00
|
|
|
|
|
|
|
|
currently_testing += got;
|
|
|
|
|
test_ptr += got * block_size;
|
|
|
|
|
read_ptr += got * block_size;
|
|
|
|
|
try -= got;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* empty the buffer so it can be reused */
|
|
|
|
|
num_saved = 0;
|
|
|
|
|
buf_used = 0;
|
2003-07-13 00:01:45 +04:00
|
|
|
save_ptr = save_base;
|
|
|
|
|
test_ptr = test_base;
|
2003-05-07 17:52:14 +04:00
|
|
|
currently_testing = save_currently_testing;
|
2000-04-03 20:01:11 +04:00
|
|
|
}
|
2003-05-07 17:52:14 +04:00
|
|
|
num_blocks = 0;
|
|
|
|
|
alarm(0);
|
|
|
|
|
if (s_flag || v_flag > 1)
|
2004-09-19 16:04:44 +04:00
|
|
|
fputs(_(done_string), stderr);
|
2000-04-03 20:01:11 +04:00
|
|
|
|
2003-05-07 17:52:14 +04:00
|
|
|
flush_bufs();
|
2000-04-03 20:01:11 +04:00
|
|
|
}
|
|
|
|
|
uncapture_terminate();
|
2000-02-07 02:57:07 +03:00
|
|
|
fflush(stderr);
|
|
|
|
|
free(blkbuf);
|
2000-07-06 04:31:27 +04:00
|
|
|
free(test_record);
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
|
|
|
|
|
ext2fs_badblocks_list_iterate_end(bb_iter);
|
|
|
|
|
|
|
|
|
|
return bb_count;
|
1997-04-26 17:21:57 +04:00
|
|
|
}
|
|
|
|
|
|
2000-07-06 18:13:29 +04:00
|
|
|
static void check_mount(char *device_name)
|
|
|
|
|
{
|
|
|
|
|
errcode_t retval;
|
|
|
|
|
int mount_flags;
|
|
|
|
|
|
|
|
|
|
retval = ext2fs_check_if_mounted(device_name, &mount_flags);
|
|
|
|
|
if (retval) {
|
|
|
|
|
com_err("ext2fs_check_if_mount", retval,
|
|
|
|
|
_("while determining whether %s is mounted."),
|
|
|
|
|
device_name);
|
|
|
|
|
return;
|
|
|
|
|
}
|
2005-06-06 00:05:22 +04:00
|
|
|
if (mount_flags & EXT2_MF_MOUNTED) {
|
|
|
|
|
fprintf(stderr, _("%s is mounted; "), device_name);
|
|
|
|
|
if (force) {
|
|
|
|
|
fputs(_("badblocks forced anyway. "
|
|
|
|
|
"Hope /etc/mtab is incorrect.\n"), stderr);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
abort_badblocks:
|
|
|
|
|
fputs(_("it's not safe to run badblocks!\n"), stderr);
|
|
|
|
|
exit(1);
|
|
|
|
|
}
|
2000-07-06 18:13:29 +04:00
|
|
|
|
2006-05-13 17:25:47 +04:00
|
|
|
if ((mount_flags & EXT2_MF_BUSY) && !exclusive_ok) {
|
2005-06-06 00:05:22 +04:00
|
|
|
fprintf(stderr, _("%s is apparently in use by the system; "),
|
|
|
|
|
device_name);
|
|
|
|
|
if (force)
|
|
|
|
|
fputs(_("badblocks forced anyway.\n"), stderr);
|
|
|
|
|
else
|
|
|
|
|
goto abort_badblocks;
|
2000-07-06 18:13:29 +04:00
|
|
|
}
|
2005-06-06 00:05:22 +04:00
|
|
|
|
2000-07-06 18:13:29 +04:00
|
|
|
}
|
|
|
|
|
|
2007-10-22 18:19:20 +04:00
|
|
|
/*
|
|
|
|
|
* This function will convert a string to an unsigned long, printing
|
|
|
|
|
* an error message if it fails, and returning success or failure in err.
|
|
|
|
|
*/
|
|
|
|
|
static unsigned int parse_uint(const char *str, const char *descr)
|
|
|
|
|
{
|
|
|
|
|
char *tmp;
|
|
|
|
|
unsigned long ret;
|
|
|
|
|
|
2008-06-11 19:55:18 +04:00
|
|
|
errno = 0;
|
2007-10-22 18:19:20 +04:00
|
|
|
ret = strtoul(str, &tmp, 0);
|
|
|
|
|
if (*tmp || errno || (ret > UINT_MAX) ||
|
|
|
|
|
(ret == ULONG_MAX && errno == ERANGE)) {
|
|
|
|
|
com_err (program_name, 0, _("invalid %s - %s"), descr, str);
|
|
|
|
|
exit (1);
|
|
|
|
|
}
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
2000-07-06 18:13:29 +04:00
|
|
|
|
1997-09-16 06:13:52 +04:00
|
|
|
int main (int argc, char ** argv)
|
1997-04-26 17:21:57 +04:00
|
|
|
{
|
1997-10-25 07:49:49 +04:00
|
|
|
int c;
|
1997-04-26 17:21:57 +04:00
|
|
|
char * device_name;
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
char * host_device_name = NULL;
|
|
|
|
|
char * input_file = NULL;
|
1997-04-26 17:21:57 +04:00
|
|
|
char * output_file = NULL;
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
FILE * in = NULL;
|
2000-02-07 02:57:07 +03:00
|
|
|
int block_size = 1024;
|
2007-10-22 18:09:05 +04:00
|
|
|
unsigned int blocks_at_once = 64;
|
2008-07-10 18:08:40 +04:00
|
|
|
blk_t last_block, first_block;
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
int num_passes = 0;
|
|
|
|
|
int passes_clean = 0;
|
1997-04-26 17:21:57 +04:00
|
|
|
int dev;
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
errcode_t errcode;
|
2007-10-22 17:51:50 +04:00
|
|
|
unsigned int pattern;
|
2007-10-22 18:09:05 +04:00
|
|
|
unsigned int (*test_func)(int, blk_t,
|
|
|
|
|
int, blk_t,
|
|
|
|
|
unsigned int);
|
2003-07-13 00:01:45 +04:00
|
|
|
int open_flag = 0;
|
|
|
|
|
long sysval;
|
1997-04-26 17:21:57 +04:00
|
|
|
|
|
|
|
|
setbuf(stdout, NULL);
|
|
|
|
|
setbuf(stderr, NULL);
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
#ifdef ENABLE_NLS
|
|
|
|
|
setlocale(LC_MESSAGES, "");
|
2002-03-05 11:26:52 +03:00
|
|
|
setlocale(LC_CTYPE, "");
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
bindtextdomain(NLS_CAT_NAME, LOCALEDIR);
|
|
|
|
|
textdomain(NLS_CAT_NAME);
|
|
|
|
|
#endif
|
2003-05-07 16:35:38 +04:00
|
|
|
srandom((unsigned int)time(NULL)); /* simple randomness is enough */
|
2000-04-03 20:01:11 +04:00
|
|
|
test_func = test_ro;
|
2001-01-11 19:04:59 +03:00
|
|
|
|
2003-07-13 00:01:45 +04:00
|
|
|
/* Determine the system page size if possible */
|
|
|
|
|
#ifdef HAVE_SYSCONF
|
|
|
|
|
#if (!defined(_SC_PAGESIZE) && defined(_SC_PAGE_SIZE))
|
|
|
|
|
#define _SC_PAGESIZE _SC_PAGE_SIZE
|
|
|
|
|
#endif
|
|
|
|
|
#ifdef _SC_PAGESIZE
|
|
|
|
|
sysval = sysconf(_SC_PAGESIZE);
|
|
|
|
|
if (sysval > 0)
|
|
|
|
|
sys_page_size = sysval;
|
|
|
|
|
#endif /* _SC_PAGESIZE */
|
|
|
|
|
#endif /* HAVE_SYSCONF */
|
|
|
|
|
|
1997-04-26 17:21:57 +04:00
|
|
|
if (argc && *argv)
|
|
|
|
|
program_name = *argv;
|
badblocks: implement read throttling
Currently, badblocks will read as fast as it can from the drive. While
this is what one wants usually, if badblocks is run in read-only mode on
a drive that is in use, it will greatly degrade the other users of this
disk.
This patch adds a throttling mode for reads where each read will be
delayed by a percentage of the time the previous read took; i.e., an
invocation of '-d 100' will cause the sleep to be the same as the read
took, a value of 200 will cause the sleep to be twice as high, and a
value of 50 will cause it to be half. This will not be done if the
previous read had errors, since then the hardware will possibly have
timeouts and that would decrease the speed too much.
This algorithm helps when the disk is used by other processes as then,
due to the increased load, the time spent doing the reads will be
higher, and correspondingly badblocks will sleep even more and thus it
will use less of the drive's bandwidth. This is different from using
ionice, as it is a voluntary (and partial) throttling.
Signed-off-by: Iustin Pop <iustin@google.com>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
2008-06-12 11:30:04 +04:00
|
|
|
while ((c = getopt (argc, argv, "b:d:e:fi:o:svwnc:p:h:t:X")) != EOF) {
|
1997-04-26 17:21:57 +04:00
|
|
|
switch (c) {
|
|
|
|
|
case 'b':
|
2007-10-22 18:19:20 +04:00
|
|
|
block_size = parse_uint(optarg, "block size");
|
|
|
|
|
if (block_size > 4096) {
|
1997-04-26 17:21:57 +04:00
|
|
|
com_err (program_name, 0,
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
_("bad block size - %s"), optarg);
|
1997-04-26 17:21:57 +04:00
|
|
|
exit (1);
|
|
|
|
|
}
|
|
|
|
|
break;
|
2000-07-06 18:13:29 +04:00
|
|
|
case 'f':
|
|
|
|
|
force++;
|
|
|
|
|
break;
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
case 'i':
|
|
|
|
|
input_file = optarg;
|
|
|
|
|
break;
|
1997-04-26 17:21:57 +04:00
|
|
|
case 'o':
|
|
|
|
|
output_file = optarg;
|
|
|
|
|
break;
|
|
|
|
|
case 's':
|
|
|
|
|
s_flag = 1;
|
|
|
|
|
break;
|
|
|
|
|
case 'v':
|
1997-04-29 20:17:09 +04:00
|
|
|
v_flag++;
|
1997-04-26 17:21:57 +04:00
|
|
|
break;
|
|
|
|
|
case 'w':
|
2000-04-03 20:01:11 +04:00
|
|
|
if (w_flag)
|
2006-11-13 07:09:03 +03:00
|
|
|
exclusive_usage();
|
2000-04-03 20:01:11 +04:00
|
|
|
test_func = test_rw;
|
|
|
|
|
w_flag = 1;
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
break;
|
|
|
|
|
case 'n':
|
2000-04-03 20:01:11 +04:00
|
|
|
if (w_flag)
|
2006-11-13 07:09:03 +03:00
|
|
|
exclusive_usage();
|
2000-04-03 20:01:11 +04:00
|
|
|
test_func = test_nd;
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
w_flag = 2;
|
|
|
|
|
break;
|
|
|
|
|
case 'c':
|
2007-10-22 18:19:20 +04:00
|
|
|
blocks_at_once = parse_uint(optarg, "blocks at once");
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
break;
|
2008-06-11 15:12:17 +04:00
|
|
|
case 'e':
|
|
|
|
|
max_bb = parse_uint(optarg, "max bad block count");
|
|
|
|
|
break;
|
badblocks: implement read throttling
Currently, badblocks will read as fast as it can from the drive. While
this is what one wants usually, if badblocks is run in read-only mode on
a drive that is in use, it will greatly degrade the other users of this
disk.
This patch adds a throttling mode for reads where each read will be
delayed by a percentage of the time the previous read took; i.e., an
invocation of '-d 100' will cause the sleep to be the same as the read
took, a value of 200 will cause the sleep to be twice as high, and a
value of 50 will cause it to be half. This will not be done if the
previous read had errors, since then the hardware will possibly have
timeouts and that would decrease the speed too much.
This algorithm helps when the disk is used by other processes as then,
due to the increased load, the time spent doing the reads will be
higher, and correspondingly badblocks will sleep even more and thus it
will use less of the drive's bandwidth. This is different from using
ionice, as it is a voluntary (and partial) throttling.
Signed-off-by: Iustin Pop <iustin@google.com>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
2008-06-12 11:30:04 +04:00
|
|
|
case 'd':
|
|
|
|
|
d_flag = parse_uint(optarg, "read delay factor");
|
|
|
|
|
break;
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
case 'p':
|
2007-10-22 18:19:20 +04:00
|
|
|
num_passes = parse_uint(optarg,
|
|
|
|
|
"number of clean passes");
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
break;
|
|
|
|
|
case 'h':
|
|
|
|
|
host_device_name = optarg;
|
1997-04-26 17:21:57 +04:00
|
|
|
break;
|
2003-05-07 17:52:14 +04:00
|
|
|
case 't':
|
|
|
|
|
if (t_flag + 1 > t_max) {
|
2007-10-22 17:51:50 +04:00
|
|
|
unsigned int *t_patts_new;
|
2003-05-07 17:52:14 +04:00
|
|
|
|
2008-07-07 02:50:44 +04:00
|
|
|
t_patts_new = realloc(t_patts, sizeof(int) *
|
|
|
|
|
(t_max + T_INC));
|
2003-05-07 17:52:14 +04:00
|
|
|
if (!t_patts_new) {
|
|
|
|
|
com_err(program_name, ENOMEM,
|
|
|
|
|
_("can't allocate memory for "
|
|
|
|
|
"test_pattern - %s"),
|
|
|
|
|
optarg);
|
|
|
|
|
exit(1);
|
|
|
|
|
}
|
|
|
|
|
t_patts = t_patts_new;
|
|
|
|
|
t_max += T_INC;
|
|
|
|
|
}
|
2003-05-18 09:11:52 +04:00
|
|
|
if (!strcmp(optarg, "r") || !strcmp(optarg,"random")) {
|
|
|
|
|
t_patts[t_flag++] = ~0;
|
|
|
|
|
} else {
|
2007-10-22 18:19:20 +04:00
|
|
|
pattern = parse_uint(optarg, "test pattern");
|
2007-10-22 17:51:50 +04:00
|
|
|
if (pattern == (unsigned int) ~0)
|
2003-05-18 09:11:52 +04:00
|
|
|
pattern = 0xffff;
|
|
|
|
|
t_patts[t_flag++] = pattern;
|
2003-05-07 17:52:14 +04:00
|
|
|
}
|
|
|
|
|
break;
|
2006-05-13 17:25:47 +04:00
|
|
|
case 'X':
|
|
|
|
|
exclusive_ok++;
|
|
|
|
|
break;
|
1997-04-26 17:21:57 +04:00
|
|
|
default:
|
ChangeLog, debugfs.8.in, debugfs.c:
Add a -V option which displays the current version.
ChangeLog, unix.c:
unix.c (e2fsck_update_progress): Remove unused variables.
ChangeLog, inode.c:
inode.c (get_next_blockgroup): Fix bug where if get_next_blockgroup()
is called early because of a missing inode table in a block group, the
current_inode counter wasn't incremented correctly.
ChangeLog, tst_uuid.c:
tst_uuid.c (main): Fixed bogus declaration of the main's argv parameter.
ChangeLog, test_icount.c:
test_icount.c (main): Fix main() declaration so that it returns int,
not void.
Many files:
fsck.c (ignore): Remove unused variable cp.
chattr.c (fatal_error):
tune2fs.c (usage):
lsattr.c (usage):
dumpe2fs.c (usage):
badblocks.c (usage): Remove volatile from declaration.
fsck.c: Change use of strdup to be string_copy, since we don't trust
what glibc is doing with strdup. (Whatever it is, it isn't pretty.)
1998-06-27 09:11:14 +04:00
|
|
|
usage();
|
1997-04-26 17:21:57 +04:00
|
|
|
}
|
|
|
|
|
}
|
2003-05-07 17:52:14 +04:00
|
|
|
if (!w_flag) {
|
|
|
|
|
if (t_flag > 1) {
|
|
|
|
|
com_err(program_name, 0,
|
|
|
|
|
_("Maximum of one test_pattern may be specified "
|
|
|
|
|
"in read-only mode"));
|
|
|
|
|
exit(1);
|
|
|
|
|
}
|
2007-10-22 17:51:50 +04:00
|
|
|
if (t_patts && (t_patts[0] == (unsigned int) ~0)) {
|
2003-05-07 17:52:14 +04:00
|
|
|
com_err(program_name, 0,
|
|
|
|
|
_("Random test_pattern is not allowed "
|
|
|
|
|
"in read-only mode"));
|
|
|
|
|
exit(1);
|
|
|
|
|
}
|
|
|
|
|
}
|
1997-04-26 17:21:57 +04:00
|
|
|
if (optind > argc - 1)
|
ChangeLog, debugfs.8.in, debugfs.c:
Add a -V option which displays the current version.
ChangeLog, unix.c:
unix.c (e2fsck_update_progress): Remove unused variables.
ChangeLog, inode.c:
inode.c (get_next_blockgroup): Fix bug where if get_next_blockgroup()
is called early because of a missing inode table in a block group, the
current_inode counter wasn't incremented correctly.
ChangeLog, tst_uuid.c:
tst_uuid.c (main): Fixed bogus declaration of the main's argv parameter.
ChangeLog, test_icount.c:
test_icount.c (main): Fix main() declaration so that it returns int,
not void.
Many files:
fsck.c (ignore): Remove unused variable cp.
chattr.c (fatal_error):
tune2fs.c (usage):
lsattr.c (usage):
dumpe2fs.c (usage):
badblocks.c (usage): Remove volatile from declaration.
fsck.c: Change use of strdup to be string_copy, since we don't trust
what glibc is doing with strdup. (Whatever it is, it isn't pretty.)
1998-06-27 09:11:14 +04:00
|
|
|
usage();
|
1997-04-26 17:21:57 +04:00
|
|
|
device_name = argv[optind++];
|
2000-07-06 17:19:43 +04:00
|
|
|
if (optind > argc - 1) {
|
|
|
|
|
errcode = ext2fs_get_device_size(device_name,
|
|
|
|
|
block_size,
|
2001-05-05 09:43:23 +04:00
|
|
|
&last_block);
|
2000-07-06 17:19:43 +04:00
|
|
|
if (errcode == EXT2_ET_UNIMPLEMENTED) {
|
|
|
|
|
com_err(program_name, 0,
|
|
|
|
|
_("Couldn't determine device size; you "
|
|
|
|
|
"must specify\nthe size manually\n"));
|
|
|
|
|
exit(1);
|
|
|
|
|
}
|
|
|
|
|
if (errcode) {
|
|
|
|
|
com_err(program_name, errcode,
|
|
|
|
|
_("while trying to determine device size"));
|
|
|
|
|
exit(1);
|
|
|
|
|
}
|
|
|
|
|
} else {
|
2007-06-04 09:49:51 +04:00
|
|
|
errno = 0;
|
2008-07-10 18:08:40 +04:00
|
|
|
last_block = parse_uint(argv[optind], _("last block"));
|
2007-06-04 09:49:51 +04:00
|
|
|
last_block++;
|
2000-07-06 17:19:43 +04:00
|
|
|
optind++;
|
1997-04-26 17:21:57 +04:00
|
|
|
}
|
2000-07-06 17:19:43 +04:00
|
|
|
if (optind <= argc-1) {
|
2007-06-04 09:49:51 +04:00
|
|
|
errno = 0;
|
2008-07-10 18:08:40 +04:00
|
|
|
first_block = parse_uint(argv[optind], _("first block"));
|
|
|
|
|
} else first_block = 0;
|
|
|
|
|
if (first_block >= last_block) {
|
2007-08-04 02:56:01 +04:00
|
|
|
com_err (program_name, 0, _("invalid starting block (%lu): must be less than %lu"),
|
2008-07-10 18:08:40 +04:00
|
|
|
(unsigned long) first_block, (unsigned long) last_block);
|
1997-04-26 17:34:30 +04:00
|
|
|
exit (1);
|
|
|
|
|
}
|
2000-07-06 18:13:29 +04:00
|
|
|
if (w_flag)
|
|
|
|
|
check_mount(device_name);
|
|
|
|
|
|
2003-07-13 00:01:45 +04:00
|
|
|
open_flag = w_flag ? O_RDWR : O_RDONLY;
|
|
|
|
|
dev = open (device_name, open_flag);
|
2002-01-02 22:15:35 +03:00
|
|
|
if (dev == -1) {
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
com_err (program_name, errno, _("while trying to open %s"),
|
1997-04-26 17:21:57 +04:00
|
|
|
device_name);
|
|
|
|
|
exit (1);
|
|
|
|
|
}
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
if (host_device_name) {
|
2003-07-13 00:01:45 +04:00
|
|
|
host_dev = open (host_device_name, open_flag);
|
2002-01-02 22:15:35 +03:00
|
|
|
if (host_dev == -1) {
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
com_err (program_name, errno,
|
|
|
|
|
_("while trying to open %s"),
|
|
|
|
|
host_device_name);
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
exit (1);
|
|
|
|
|
}
|
|
|
|
|
} else
|
|
|
|
|
host_dev = dev;
|
2002-10-14 07:56:28 +04:00
|
|
|
if (input_file) {
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
if (strcmp (input_file, "-") == 0)
|
|
|
|
|
in = stdin;
|
|
|
|
|
else {
|
|
|
|
|
in = fopen (input_file, "r");
|
|
|
|
|
if (in == NULL)
|
|
|
|
|
{
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
com_err (program_name, errno,
|
|
|
|
|
_("while trying to open %s"),
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
input_file);
|
|
|
|
|
exit (1);
|
|
|
|
|
}
|
|
|
|
|
}
|
2002-10-14 07:56:28 +04:00
|
|
|
}
|
1997-04-26 17:21:57 +04:00
|
|
|
if (output_file && strcmp (output_file, "-") != 0)
|
|
|
|
|
{
|
|
|
|
|
out = fopen (output_file, "w");
|
|
|
|
|
if (out == NULL)
|
|
|
|
|
{
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
com_err (program_name, errno,
|
|
|
|
|
_("while trying to open %s"),
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
output_file);
|
1997-04-26 17:21:57 +04:00
|
|
|
exit (1);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
out = stdout;
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
|
|
|
|
|
errcode = ext2fs_badblocks_list_create(&bb_list,0);
|
|
|
|
|
if (errcode) {
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
com_err (program_name, errcode,
|
2005-06-20 16:35:27 +04:00
|
|
|
_("while creating in-memory bad blocks list"));
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
exit (1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (in) {
|
|
|
|
|
for(;;) {
|
2000-07-14 02:05:31 +04:00
|
|
|
switch(fscanf (in, "%u\n", &next_bad)) {
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
case 0:
|
|
|
|
|
com_err (program_name, 0, "input file - bad format");
|
|
|
|
|
exit (1);
|
|
|
|
|
case EOF:
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
errcode = ext2fs_badblocks_list_add(bb_list,next_bad);
|
|
|
|
|
if (errcode) {
|
2005-06-20 16:35:27 +04:00
|
|
|
com_err (program_name, errcode, _("while adding to in-memory bad block list"));
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
exit (1);
|
|
|
|
|
}
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (in != stdin)
|
|
|
|
|
fclose (in);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
do {
|
|
|
|
|
unsigned int bb_count;
|
|
|
|
|
|
2001-05-05 09:43:23 +04:00
|
|
|
bb_count = test_func(dev, last_block, block_size,
|
2008-07-10 18:08:40 +04:00
|
|
|
first_block, blocks_at_once);
|
2000-04-03 20:01:11 +04:00
|
|
|
if (bb_count)
|
|
|
|
|
passes_clean = 0;
|
|
|
|
|
else
|
|
|
|
|
++passes_clean;
|
|
|
|
|
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
if (v_flag)
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
fprintf(stderr,
|
|
|
|
|
_("Pass completed, %u bad blocks found.\n"),
|
|
|
|
|
bb_count);
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
|
|
|
|
|
} while (passes_clean < num_passes);
|
|
|
|
|
|
1997-04-26 17:21:57 +04:00
|
|
|
close (dev);
|
|
|
|
|
if (out != stdout)
|
|
|
|
|
fclose (out);
|
2003-05-07 17:52:14 +04:00
|
|
|
if (t_patts)
|
|
|
|
|
free(t_patts);
|
ChangeLog, badblocks.c:
badblocks.c: Folded in patches David Beattie <dbeattie@usa.net>. Need
to do cleanup before release: use of GCC extensions (dynamic arrays);
unclean coding tricks (use of || instead of if statements, etc.).
Comments from David Beattie:
"I added non-destructive write-testing, and quite a few other
features. The non-destructive write testing, triggered by new "-n"
command-line option, will write test patterns to the disk, but only
after reading data off the disk into memory. Then, comparing the test
patterns gives a result as to whether or not those sectors are
reliable. Finally, the original data is written back.
To streamline this operation, I added another option, "-c
blocks_at_once", which will give the number of disk blocks to process
at one time (mnemonic--"count"). I made this default to 16 (as in the
read-only testing mode), and also affect the read-only testing mode.
Of course, read-only mode needs (count * block_size) amount of memory,
and non-destructive read-write needs 3 times that much, so it makes
sense to do the calculations and not overrun available RAM...I would
have liked to implement and auto-memory-usage heuristic, but I have no
idea if it's even possible to determine the amount of free memory on a
Unix system except by reading /proc entries, and that didn't seem
portable. I did NOT make this blocks_at_once affect the behavior of
the test_rw routine, as it is processing the whole disk at once,
anyway.
I *think* that I got higher detection rates on my hard drive using
random test data than patterned test data, so my non-destructive mode
initializes its test data buffer randomly.
I fixed a typo in flush_bufs that caused the ioctl BLKFLSBUF to never
get compiled into the program.
Also, I added an "undocumented" (I didn't put it into the usage
message; you can if you think it's useful) "-h" option to specify the
host device to flush--useful if you want to test out my
"non-destructive" code on something other than a hard drive, such as a
file on a hard drive, and want the host hard drive to flush.
I provided support for an "input" file (via option "-i", similar to
the "-o" option)...containing a list of already-known bad blocks; it
will skip testing those blocks, thus adding speed to the bad block
scan (on my computer, hitting a physically bad block causes a
half-second-or-more freeze as the kernel waits for the hard drive to
give up and reset itself; pretty annoying when you already know the
block is bad from a previous scan).
Finally, the real killer, the persistent re-scan (option: "-p
num_passes") that I created will, if desired, persistently re-scan the
drive until it has completed a user-decidable number of passes in a
row during which no new bad blocks are found. On my drive, I would
see behavior that a certain percentage of bad blocks would be found
with each pass (it was not reliable in the defective areas!), so I
wanted it to check it over and over again until it didn't find any
more, several times. Perhaps this will be useful to others. Defaults
of course to zero, meaning it will stop after the first pass. I used
"-p 2" on my drive, and it ran for 2 1/2 days...then used "-p 3" a
couple days later and it ran for a few more hours, and since then the
rest of my drive has been completely reliable.
Implementation of these last two features, "-i" and "-p", I did using
a bb_list from libext2fs. I debated whether bad blocks input through
"-i" should be output into the "-o" file (or stdout, of course), and
decided against it, but left the code to do so in place, commented
out, just for your information.
In order to maintain data integrity upon interruption of a
non-destructive-write test, I created a signal handler which I install
which will write back whatever original disk data is in the buffers
upon any of the fatal signals (except SIGKILL, of course).
Of course, ideally, the new options would be reflected in the
badblocks manual page, but I am not experienced at manual page
modification; if you decide my patch to badblocks should be
incorporated into the distribution, I could learn how to update the
manpage and other documentation, or you could do it for me after
exercising your opinions, if you have any, on exactly what the
command-line parameters should be called and which ones should be in
the distribution."
2000-01-18 23:59:11 +03:00
|
|
|
return 0;
|
1997-04-26 17:21:57 +04:00
|
|
|
}
|
Many files:
badblocks.c, chattr.c, dumpe2fs.c, e2label.c, findsuper.c, fsck.c,
get_device_by_label.c, lsattr.c, mke2fs.c, mklost+found.c,
nls-enable.h, partinfo.c, tune2fs.c, uuidgen.c: Add
Internationalization support as suggested by Marco d'Itri
<md@linux.it>.
2000-02-08 03:47:55 +03:00
|
|
|
|