← Back to branch summary

~ubuntu-branches/ubuntu/edgy/e2fsprogs/edgy-security

« back to all changes in this revision

Viewing changes to misc/badblocks.c

  • Committer: Bazaar Package Importer
  • Author(s): Tollef Fog Heen
  • Date: 2005-08-23 10:42:10 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20050823104210-t15igvmgrkzea0dq
Tags: 1.38-2ubuntu1
* Merge with Debian.  (Ubuntu #13757)
* Remove tests/f_bad_disconnected_inode/image.gz to be able to build the
  package.  This will (hopefully) be in the next upstream version and is
  just used for testing.

Show diffs side-by-side

added added

removed removed

Lines of Context:
misc/badblocks.c
141
141
 
142
142
static void print_status(void)
143
143
{
144
 
        fprintf(stderr, "%9ld/%9ld", currently_testing, num_blocks);
145
 
        fprintf(stderr, "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b");
 
144
        fprintf(stderr, "%15ld/%15ld", currently_testing, num_blocks);
 
145
        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);
146
146
        fflush (stderr);
147
147
}
148
148
 
152
152
        alarm(1);
153
153
        if (!num_blocks)
154
154
                return;
155
 
        fprintf(stderr, "%9ld/%9ld", currently_testing, num_blocks);
156
 
        fprintf(stderr, "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b");
157
 
        fflush (stderr);
 
155
        print_status();
158
156
}
159
157
 
160
158
static void *terminate_addr = NULL;
412
410
        num_blocks = 0;
413
411
        alarm(0);
414
412
        if (s_flag || v_flag)
415
 
                fputs(done_string, stderr);
 
413
                fputs(_(done_string), stderr);
416
414
 
417
415
        fflush (stderr);
418
416
        free (blkbuf);
493
491
                num_blocks = 0;
494
492
                alarm (0);
495
493
                if (s_flag | v_flag)
496
 
                        fputs(done_string, stderr);
 
494
                        fputs(_(done_string), stderr);
497
495
                flush_bufs();
498
496
                if (s_flag | v_flag)
499
497
                        fputs(_("Reading and comparing: "), stderr);
534
532
                num_blocks = 0;
535
533
                alarm (0);
536
534
                if (s_flag | v_flag)
537
 
                        fputs(done_string, stderr);
 
535
                        fputs(_(done_string), stderr);
538
536
                flush_bufs();
539
537
        }
540
538
        uncapture_terminate();
756
754
                num_blocks = 0;
757
755
                alarm(0);
758
756
                if (s_flag || v_flag > 1)
759
 
                        fputs(done_string, stderr);
 
757
                        fputs(_(done_string), stderr);
760
758
 
761
759
                flush_bufs();
762
760
        }
782
780
                        device_name);
783
781
                return;
784
782
        }
785
 
        if (!(mount_flags & EXT2_MF_MOUNTED))
786
 
                return;
787
 
 
788
 
        fprintf(stderr, _("%s is mounted; "), device_name);
789
 
        if (force) {
790
 
                fputs(_("badblocks forced anyway.  "
791
 
                        "Hope /etc/mtab is incorrect.\n"), stderr);
792
 
                return;
793
 
        }
794
 
        fputs(_("it's not safe to run badblocks!\n"), stderr);
795
 
        exit(1);
 
783
        if (mount_flags & EXT2_MF_MOUNTED) {
 
784
                fprintf(stderr, _("%s is mounted; "), device_name);
 
785
                if (force) {
 
786
                        fputs(_("badblocks forced anyway.  "
 
787
                                "Hope /etc/mtab is incorrect.\n"), stderr);
 
788
                        return;
 
789
                }
 
790
        abort_badblocks:
 
791
                fputs(_("it's not safe to run badblocks!\n"), stderr);
 
792
                exit(1);
 
793
        }
 
794
 
 
795
        if (mount_flags & EXT2_MF_BUSY) {
 
796
                fprintf(stderr, _("%s is apparently in use by the system; "),
 
797
                        device_name);
 
798
                if (force)
 
799
                        fputs(_("badblocks forced anyway.\n"), stderr);
 
800
                else
 
801
                        goto abort_badblocks;
 
802
        }
 
803
 
796
804
}
797
805
 
798
806
 
969
977
        } else {
970
978
                last_block = strtoul (argv[optind], &tmp, 0);
971
979
                if (*tmp) {
972
 
                        com_err (program_name, 0, _("bad blocks count - %s"),
 
980
                        com_err (program_name, 0, _("invalid blocks count - %s"),
973
981
                                 argv[optind]);
974
982
                        exit (1);
975
983
                }
978
986
        if (optind <= argc-1) {
979
987
                from_count = strtoul (argv[optind], &tmp, 0);
980
988
                if (*tmp) {
981
 
                        com_err (program_name, 0, _("bad starting block - %s"),
 
989
                        com_err (program_name, 0, _("invalid starting block - %s"),
982
990
                                 argv[optind]);
983
991
                        exit (1);
984
992
                }
985
993
        } else from_count = 0;
986
994
        if (from_count >= last_block) {
987
 
            com_err (program_name, 0, _("bad blocks range: %lu-%lu"),
 
995
            com_err (program_name, 0, _("invalid blocks range: %lu-%lu"),
988
996
                     (unsigned long) from_count, (unsigned long) last_block);
989
997
            exit (1);
990
998
        }
1039
1047
        errcode = ext2fs_badblocks_list_create(&bb_list,0);
1040
1048
        if (errcode) {
1041
1049
                com_err (program_name, errcode,
1042
 
                         _("creating in-memory bad blocks list"));
 
1050
                         _("while creating in-memory bad blocks list"));
1043
1051
                exit (1);
1044
1052
        }
1045
1053
 
1054
1062
                                default:
1055
1063
                                        errcode = ext2fs_badblocks_list_add(bb_list,next_bad);
1056
1064
                                        if (errcode) {
1057
 
                                                com_err (program_name, errcode, _("adding to in-memory bad block list"));
 
1065
                                                com_err (program_name, errcode, _("while adding to in-memory bad block list"));
1058
1066
                                                exit (1);
1059
1067
                                        }
1060
1068
                                        continue;