misc: handle very large files with filefrag

[tools/e2fsprogs.git] / misc / badblocks.c

diff --git a/misc/badblocks.c b/misc/badblocks.c
index 912ef28..abf315c 100644 (file)
--- a/misc/badblocks.c
+++ b/misc/badblocks.c
@@ -50,6 +50,9 @@ extern int optind;
 #include <setjmp.h>
 #include <time.h>
 #include <limits.h>
+#ifdef HAVE_MBSTOWCS
+#include <wchar.h>
+#endif
 
 #include <sys/time.h>
 #include <sys/ioctl.h>
@@ -59,12 +62,15 @@ extern int optind;
 #include "ext2fs/ext2_io.h"
 #include "ext2fs/ext2_fs.h"
 #include "ext2fs/ext2fs.h"
-#include "nls-enable.h"
+#include "support/nls-enable.h"
 
 #ifndef O_LARGEFILE
 #define O_LARGEFILE 0
 #endif
 
+/* Maximum number of bad blocks we support */
+#define MAX_BAD_BLOCKS (INT_MAX/2)
+
 static const char * program_name = "badblocks";
 static const char * done_string = N_("done                                                 \n");
 
@@ -78,7 +84,9 @@ static int t_max;                     /* allocated test patterns */
 static unsigned int *t_patts;          /* test patterns */
 static int use_buffered_io;
 static int exclusive_ok;
-static unsigned int max_bb;            /* Abort test if more than this number of bad blocks has been encountered */
+static unsigned int max_bb = MAX_BAD_BLOCKS;   /* Abort test if more than this
+                                                * number of bad blocks has been
+                                                * encountered */
 static unsigned int d_flag;            /* delay factor between reads */
 static struct timeval time_start;
 
@@ -89,7 +97,7 @@ static unsigned int sys_page_size = 4096;
 static void usage(void)
 {
        fprintf(stderr, _(
-"Usage: %s [-b block_size] [-i input_file] [-o output_file] [-svwnf]\n"
+"Usage: %s [-b block_size] [-i input_file] [-o output_file] [-svwnfBX]\n"
 "       [-c blocks_at_once] [-d delay_factor_between_reads] [-e max_bad_blocks]\n"
 "       [-p num_passes] [-t test_pattern [-t test_pattern [...]]]\n"
 "       device [last_block [first_block]]\n"),
@@ -122,7 +130,7 @@ static void *allocate_buffer(size_t size)
        void    *ret = 0;
 
 #ifdef HAVE_POSIX_MEMALIGN
-       if (posix_memalign(&ret, sys_page_size, size) < 0)
+       if (posix_memalign(&ret, sys_page_size, size) != 0)
                ret = 0;
 #else
 #ifdef HAVE_MEMALIGN
@@ -211,6 +219,9 @@ static void print_status(void)
 {
        struct timeval time_end;
        char diff_buf[32], line_buf[128];
+#ifdef HAVE_MBSTOWCS
+       wchar_t wline_buf[128];
+#endif
        int len;
 
        gettimeofday(&time_end, 0);
@@ -224,7 +235,10 @@ static void print_status(void)
                       num_write_errors,
                       num_corruption_errors);
 #ifdef HAVE_MBSTOWCS
-       len = mbstowcs(NULL, line_buf, sizeof(line_buf));
+       mbstowcs(wline_buf, line_buf, sizeof(line_buf));
+       len = wcswidth(wline_buf, sizeof(line_buf));
+       if (len < 0)
+               len = strlen(line_buf); /* Should never happen... */
 #endif
        fputs(line_buf, stderr);
        memset(line_buf, '\b', len);
@@ -300,7 +314,8 @@ static void set_o_direct(int dev, unsigned char *buffer, size_t size,
                flag = fcntl(dev, F_GETFL);
                if (flag > 0) {
                        flag = (flag & ~O_DIRECT) | new_flag;
-                       fcntl(dev, F_SETFL, flag);
+                       if (fcntl(dev, F_SETFL, flag) < 0)
+                               perror("set_o_direct");
                }
                current_O_DIRECT = new_flag;
        }
@@ -525,7 +540,7 @@ static unsigned int test_ro (int dev, blk_t last_block,
                alarm_intr(SIGALRM);
        while (currently_testing < last_block)
        {
-               if (max_bb && bb_count >= max_bb) {
+               if (bb_count >= max_bb) {
                        if (s_flag || v_flag) {
                                fputs(_("Too many bad blocks, aborting test\n"), stderr);
                        }
@@ -632,7 +647,7 @@ static unsigned int test_rw (int dev, blk_t last_block,
 
                try = blocks_at_once;
                while (currently_testing < last_block) {
-                       if (max_bb && bb_count >= max_bb) {
+                       if (bb_count >= max_bb) {
                                if (s_flag || v_flag) {
                                        fputs(_("Too many bad blocks, aborting test\n"), stderr);
                                }
@@ -674,7 +689,7 @@ static unsigned int test_rw (int dev, blk_t last_block,
 
                try = blocks_at_once;
                while (currently_testing < last_block) {
-                       if (max_bb && bb_count >= max_bb) {
+                       if (bb_count >= max_bb) {
                                if (s_flag || v_flag) {
                                        fputs(_("Too many bad blocks, aborting test\n"), stderr);
                                }
@@ -821,7 +836,7 @@ static unsigned int test_nd (int dev, blk_t last_block,
                        alarm_intr(SIGALRM);
 
                while (currently_testing < last_block) {
-                       if (max_bb && bb_count >= max_bb) {
+                       if (bb_count >= max_bb) {
                                if (s_flag || v_flag) {
                                        fputs(_("Too many bad blocks, aborting test\n"), stderr);
                                }
@@ -1116,6 +1131,16 @@ int main (int argc, char ** argv)
                        break;
                case 'e':
                        max_bb = parse_uint(optarg, "max bad block count");
+                       if (max_bb > MAX_BAD_BLOCKS) {
+                               com_err (program_name, 0,
+                                        _("Too big max bad blocks count %u - "
+                                          "maximum is %u"), max_bb,
+                                          MAX_BAD_BLOCKS);
+                               exit (1);
+                       }
+                       /* 0 really means unlimited but we cannot do that much... */
+                       if (max_bb == 0)
+                               max_bb = MAX_BAD_BLOCKS;
                        break;
                case 'd':
                        d_flag = parse_uint(optarg, "read delay factor");