X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=e2fsck%2Funix.c;h=bc18d41cfdb358a4532755dd68b9eaa496bf5003;hb=624e4a6466dba9889f5f80dc168f2bb7c2a3f5d0;hp=9e722f418732bf306d442aa500c8a3ca8e548bf3;hpb=8deb80a5d1078cbe43eaffcdeebf0a1a549d6a54;p=tools%2Fe2fsprogs.git diff --git a/e2fsck/unix.c b/e2fsck/unix.c index 9e722f4..bc18d41 100644 --- a/e2fsck/unix.c +++ b/e2fsck/unix.c @@ -1,6 +1,6 @@ /* * unix.c - The unix-specific code for e2fsck - * + * * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o. * * %Begin-Header% @@ -9,6 +9,8 @@ * %End-Header% */ +#define _XOPEN_SOURCE 600 /* for inclusion of sa_handler in Solaris */ + #include #ifdef HAVE_STDLIB_H #include @@ -46,14 +48,14 @@ extern int optind; #include #endif +#include "e2p/e2p.h" #include "et/com_err.h" +#include "e2p/e2p.h" #include "e2fsck.h" #include "problem.h" #include "../version.h" /* Command line options */ -static int swapfs; -static int normalize_swapfs; static int cflag; /* check disk */ static int show_version_only; static int verbose; @@ -71,7 +73,7 @@ int journal_enable_debug = -1; static void usage(e2fsck_t ctx) { fprintf(stderr, - _("Usage: %s [-panyrcdfvstDFSV] [-b superblock] [-B blocksize]\n" + _("Usage: %s [-panyrcdfvtDFV] [-b superblock] [-B blocksize]\n" "\t\t[-I inode_buffer_blocks] [-P process_inode_size]\n" "\t\t[-l|-L bad_blocks_file] [-C fd] [-j external_journal]\n" "\t\t[-E extended-options] device\n"), @@ -98,11 +100,12 @@ static void usage(e2fsck_t ctx) static void show_stats(e2fsck_t ctx) { ext2_filsys fs = ctx->fs; - int inodes, inodes_used; - blk_t blocks, blocks_used; - int dir_links; - int num_files, num_links; - int frag_percent; + ext2_ino_t inodes, inodes_used; + blk64_t blocks, blocks_used; + unsigned int dir_links; + unsigned int num_files, num_links; + int frag_percent_file, frag_percent_dir, frag_percent_total; + int i, j; dir_links = 2 * ctx->fs_directory_count - 1; num_files = ctx->fs_total_count - dir_links; @@ -110,57 +113,85 @@ static void show_stats(e2fsck_t ctx) inodes = fs->super->s_inodes_count; inodes_used = (fs->super->s_inodes_count - fs->super->s_free_inodes_count); - blocks = fs->super->s_blocks_count; - blocks_used = (fs->super->s_blocks_count - - fs->super->s_free_blocks_count); + blocks = ext2fs_blocks_count(fs->super); + blocks_used = (ext2fs_blocks_count(fs->super) - + ext2fs_free_blocks_count(fs->super)); + + frag_percent_file = (10000 * ctx->fs_fragmented) / inodes_used; + frag_percent_file = (frag_percent_file + 5) / 10; + + frag_percent_dir = (10000 * ctx->fs_fragmented_dir) / inodes_used; + frag_percent_dir = (frag_percent_dir + 5) / 10; + + frag_percent_total = ((10000 * (ctx->fs_fragmented + + ctx->fs_fragmented_dir)) + / inodes_used); + frag_percent_total = (frag_percent_total + 5) / 10; - frag_percent = (10000 * ctx->fs_fragmented) / inodes_used; - frag_percent = (frag_percent + 5) / 10; - if (!verbose) { - printf(_("%s: %d/%d files (%0d.%d%% non-contiguous), %u/%u blocks\n"), + printf(_("%s: %u/%u files (%0d.%d%% non-contiguous), %llu/%llu blocks\n"), ctx->device_name, inodes_used, inodes, - frag_percent / 10, frag_percent % 10, + frag_percent_total / 10, frag_percent_total % 10, blocks_used, blocks); return; } - printf (P_("\n%8d inode used (%d%%)\n", "\n%8d inodes used (%d%%)\n", - inodes_used), inodes_used, 100 * inodes_used / inodes); - printf (P_("%8d non-contiguous inode (%0d.%d%%)\n", - "%8d non-contiguous inodes (%0d.%d%%)\n", + printf (P_("\n%8u inode used (%2.2f%%)\n", "\n%8u inodes used (%2.2f%%)\n", + inodes_used), inodes_used, 100.0 * inodes_used / inodes); + printf (P_("%8u non-contiguous file (%0d.%d%%)\n", + "%8u non-contiguous files (%0d.%d%%)\n", ctx->fs_fragmented), - ctx->fs_fragmented, frag_percent / 10, frag_percent % 10); - printf (_(" # of inodes with ind/dind/tind blocks: %d/%d/%d\n"), + ctx->fs_fragmented, frag_percent_file / 10, + frag_percent_file % 10); + printf (P_("%8u non-contiguous directory (%0d.%d%%)\n", + "%8u non-contiguous directories (%0d.%d%%)\n", + ctx->fs_fragmented_dir), + ctx->fs_fragmented_dir, frag_percent_dir / 10, + frag_percent_dir % 10); + printf (_(" # of inodes with ind/dind/tind blocks: %u/%u/%u\n"), ctx->fs_ind_count, ctx->fs_dind_count, ctx->fs_tind_count); - printf (P_("%8u block used (%d%%)\n", "%8u blocks used (%d%%)\n", - blocks_used), - blocks_used, (int) ((long long) 100 * blocks_used / blocks)); - printf (P_("%8d bad block\n", "%8d bad blocks\n", + + for (j=MAX_EXTENT_DEPTH_COUNT-1; j >=0; j--) + if (ctx->extent_depth_count[j]) + break; + if (++j) { + printf (_(" Extent depth histogram: ")); + for (i=0; i < j; i++) { + if (i) + fputc('/', stdout); + printf("%u", ctx->extent_depth_count[i]); + } + fputc('\n', stdout); + } + + printf (P_("%8llu block used (%2.2f%%)\n", + "%8llu blocks used (%2.2f%%)\n", + blocks_used), blocks_used, 100.0 * blocks_used / blocks); + printf (P_("%8u bad block\n", "%8u bad blocks\n", ctx->fs_badblocks_count), ctx->fs_badblocks_count); - printf (P_("%8d large file\n", "%8d large files\n", + printf (P_("%8u large file\n", "%8u large files\n", ctx->large_files), ctx->large_files); - printf (P_("\n%8d regular file\n", "\n%8d regular files\n", + printf (P_("\n%8u regular file\n", "\n%8u regular files\n", ctx->fs_regular_count), ctx->fs_regular_count); - printf (P_("%8d directory\n", "%8d directories\n", + printf (P_("%8u directory\n", "%8u directories\n", ctx->fs_directory_count), ctx->fs_directory_count); - printf (P_("%8d character device file\n", - "%8d character device files\n", ctx->fs_chardev_count), + printf (P_("%8u character device file\n", + "%8u character device files\n", ctx->fs_chardev_count), ctx->fs_chardev_count); - printf (P_("%8d block device file\n", "%8d block device files\n", + printf (P_("%8u block device file\n", "%8u block device files\n", ctx->fs_blockdev_count), ctx->fs_blockdev_count); - printf (P_("%8d fifo\n", "%8d fifos\n", ctx->fs_fifo_count), + printf (P_("%8u fifo\n", "%8u fifos\n", ctx->fs_fifo_count), ctx->fs_fifo_count); - printf (P_("%8d link\n", "%8d links\n", + printf (P_("%8u link\n", "%8u links\n", ctx->fs_links_count - dir_links), ctx->fs_links_count - dir_links); - printf (P_("%8d symbolic link", "%8d symbolic links", + printf (P_("%8u symbolic link", "%8u symbolic links", ctx->fs_symlinks_count), ctx->fs_symlinks_count); - printf (P_(" (%d fast symbolic link)\n", " (%d fast symbolic links)\n", + printf (P_(" (%u fast symbolic link)\n", " (%u fast symbolic links)\n", ctx->fs_fast_symlinks_count), ctx->fs_fast_symlinks_count); - printf (P_("%8d socket\n", "%8d sockets\n", ctx->fs_sockets_count), + printf (P_("%8u socket\n", "%8u sockets\n", ctx->fs_sockets_count), ctx->fs_sockets_count); printf ("--------\n"); - printf (P_("%8d file\n", "%8d files\n", + printf (P_("%8u file\n", "%8u files\n", ctx->fs_total_count - dir_links), ctx->fs_total_count - dir_links); } @@ -200,9 +231,9 @@ static void check_mount(e2fsck_t ctx) if (!ctx->interactive) fatal_error(ctx, _("Cannot continue, aborting.\n\n")); printf(_("\n\n\007\007\007\007WARNING!!! " - "Running e2fsck on a mounted filesystem may cause\n" - "SEVERE filesystem damage.\007\007\007\n\n")); - cont = ask_yn(_("Do you really want to continue"), -1); + "The filesystem is mounted. If you continue you ***WILL***\n" + "cause ***SEVERE*** filesystem damage.\007\007\007\n\n")); + cont = ask_yn(_("Do you really want to continue"), 0); if (!cont) { printf (_("check aborted.\n")); exit (0); @@ -220,7 +251,7 @@ static int is_on_batt(void) f = fopen("/proc/apm", "r"); if (f) { - if (fscanf(f, "%s %s %s %x", tmp, tmp, tmp, &acflag) != 4) + if (fscanf(f, "%s %s %s %x", tmp, tmp, tmp, &acflag) != 4) acflag = 1; fclose(f); return (acflag != 1); @@ -230,7 +261,7 @@ static int is_on_batt(void) while ((de=readdir(d)) != NULL) { if (!strncmp(".", de->d_name, 1)) continue; - snprintf(fname, 80, "/proc/acpi/ac_adapter/%s/state", + snprintf(fname, 80, "/proc/acpi/ac_adapter/%s/state", de->d_name); f = fopen(fname, "r"); if (!f) @@ -256,41 +287,60 @@ static int is_on_batt(void) static void check_if_skip(e2fsck_t ctx) { ext2_filsys fs = ctx->fs; + struct problem_context pctx; const char *reason = NULL; unsigned int reason_arg = 0; long next_check; int batt = is_on_batt(); int defer_check_on_battery; + int broken_system_clock; + time_t lastcheck; + profile_get_boolean(ctx->profile, "options", "broken_system_clock", + 0, 0, &broken_system_clock); + if (ctx->flags & E2F_FLAG_TIME_INSANE) + broken_system_clock = 1; profile_get_boolean(ctx->profile, "options", - "defer_check_on_battery", 0, 1, + "defer_check_on_battery", 0, 1, &defer_check_on_battery); if (!defer_check_on_battery) batt = 0; - if ((ctx->options & E2F_OPT_FORCE) || bad_blocks_file || - cflag || swapfs) + if ((ctx->options & E2F_OPT_FORCE) || bad_blocks_file || cflag) return; - + + if (ctx->options & E2F_OPT_JOURNAL_ONLY) + goto skip; + + lastcheck = fs->super->s_lastcheck; + if (lastcheck > ctx->now) + lastcheck -= ctx->time_fudge; if ((fs->super->s_state & EXT2_ERROR_FS) || !ext2fs_test_valid(fs)) reason = _(" contains a file system with errors"); else if ((fs->super->s_state & EXT2_VALID_FS) == 0) reason = _(" was not cleanly unmounted"); + else if (check_backup_super_block(ctx)) + reason = _(" primary superblock features different from backup"); else if ((fs->super->s_max_mnt_count > 0) && (fs->super->s_mnt_count >= (unsigned) fs->super->s_max_mnt_count)) { reason = _(" has been mounted %u times without being checked"); reason_arg = fs->super->s_mnt_count; - if (batt && (fs->super->s_mnt_count < + if (batt && (fs->super->s_mnt_count < (unsigned) fs->super->s_max_mnt_count*2)) reason = 0; - } else if (fs->super->s_checkinterval && - ((ctx->now - fs->super->s_lastcheck) >= - fs->super->s_checkinterval)) { + } else if (!broken_system_clock && fs->super->s_checkinterval && + (ctx->now < lastcheck)) { + reason = _(" has filesystem last checked time in the future"); + if (batt) + reason = 0; + } else if (!broken_system_clock && fs->super->s_checkinterval && + ((ctx->now - lastcheck) >= + ((time_t) fs->super->s_checkinterval))) { reason = _(" has gone %u days without being checked"); reason_arg = (ctx->now - fs->super->s_lastcheck)/(3600*24); - if (batt && ((ctx->now - fs->super->s_lastcheck) < + if (batt && ((ctx->now - fs->super->s_lastcheck) < fs->super->s_checkinterval*2)) reason = 0; } @@ -300,23 +350,54 @@ static void check_if_skip(e2fsck_t ctx) fputs(_(", check forced.\n"), stdout); return; } - printf(_("%s: clean, %d/%d files, %u/%u blocks"), ctx->device_name, + + /* + * Update the global counts from the block group counts. This + * is needed since modern kernels don't update the global + * counts so as to avoid locking the entire file system. So + * if the filesystem is not unmounted cleanly, the global + * counts may not be accurate. Update them here if we can, + * for the benefit of users who might examine the file system + * using dumpe2fs. (This is for cosmetic reasons only.) + */ + clear_problem_context(&pctx); + pctx.ino = fs->super->s_free_inodes_count; + pctx.ino2 = ctx->free_inodes; + if ((pctx.ino != pctx.ino2) && + !(ctx->options & E2F_OPT_READONLY) && + fix_problem(ctx, PR_0_FREE_INODE_COUNT, &pctx)) { + fs->super->s_free_inodes_count = ctx->free_inodes; + ext2fs_mark_super_dirty(fs); + } + clear_problem_context(&pctx); + pctx.blk = ext2fs_free_blocks_count(fs->super); + pctx.blk2 = ctx->free_blocks; + if ((pctx.blk != pctx.blk2) && + !(ctx->options & E2F_OPT_READONLY) && + fix_problem(ctx, PR_0_FREE_BLOCK_COUNT, &pctx)) { + ext2fs_free_blocks_count_set(fs->super, ctx->free_blocks); + ext2fs_mark_super_dirty(fs); + } + + /* Print the summary message when we're skipping a full check */ + printf(_("%s: clean, %u/%u files, %llu/%llu blocks"), ctx->device_name, fs->super->s_inodes_count - fs->super->s_free_inodes_count, fs->super->s_inodes_count, - fs->super->s_blocks_count - fs->super->s_free_blocks_count, - fs->super->s_blocks_count); + ext2fs_blocks_count(fs->super) - + ext2fs_free_blocks_count(fs->super), + ext2fs_blocks_count(fs->super)); next_check = 100000; if (fs->super->s_max_mnt_count > 0) { next_check = fs->super->s_max_mnt_count - fs->super->s_mnt_count; - if (next_check <= 0) + if (next_check <= 0) next_check = 1; } - if (fs->super->s_checkinterval && + if (!broken_system_clock && fs->super->s_checkinterval && ((ctx->now - fs->super->s_lastcheck) >= fs->super->s_checkinterval)) next_check = 1; if (next_check <= 5) { if (next_check == 1) { - if (batt) + if (batt) fputs(_(" (check deferred; on battery)"), stdout); else @@ -325,6 +406,7 @@ static void check_if_skip(e2fsck_t ctx) printf(_(" (check in %ld mounts)"), next_check); } fputc('\n', stdout); +skip: ext2fs_close(fs); ctx->fs = NULL; e2fsck_free_context(ctx); @@ -347,7 +429,7 @@ static float calc_percent(struct percent_tbl *tbl, int pass, int curr, int max) { float percent; - + if (pass <= 0) return 0.0; if (pass > tbl->max_pass || max == 0) @@ -361,7 +443,7 @@ extern void e2fsck_clear_progbar(e2fsck_t ctx) { if (!(ctx->flags & E2F_FLAG_PROG_BAR)) return; - + printf("%s%s\r%s", ctx->start_meta, spaces + (sizeof(spaces) - 80), ctx->stop_meta); fflush(stdout); @@ -384,7 +466,7 @@ int e2fsck_simple_progress(e2fsck_t ctx, const char *label, float percent, /* * Calculate the new progress position. If the * percentage hasn't changed, then we skip out right - * away. + * away. */ fixed_percent = (int) ((10 * percent) + 0.5); if (ctx->progress_last_percent == fixed_percent) @@ -429,7 +511,7 @@ int e2fsck_simple_progress(e2fsck_t ctx, const char *label, float percent, else fputs(" \r", stdout); fputs(ctx->stop_meta, stdout); - + if (fixed_percent == 1000) e2fsck_clear_progbar(ctx); fflush(stdout); @@ -440,15 +522,16 @@ int e2fsck_simple_progress(e2fsck_t ctx, const char *label, float percent, static int e2fsck_update_progress(e2fsck_t ctx, int pass, unsigned long cur, unsigned long max) { - char buf[80]; + char buf[1024]; float percent; if (pass == 0) return 0; - + if (ctx->progress_fd) { - sprintf(buf, "%d %lu %lu\n", pass, cur, max); - write(ctx->progress_fd, buf, strlen(buf)); + snprintf(buf, sizeof(buf), "%d %lu %lu %s\n", + pass, cur, max, ctx->device_name); + write_all(ctx->progress_fd, buf, strlen(buf)); } else { percent = calc_percent(&e2fsck_tbl, pass, cur, max); e2fsck_simple_progress(ctx, ctx->device_name, @@ -486,7 +569,6 @@ static void signal_progress_on(int sig EXT2FS_ATTR((unused))) return; ctx->progress = e2fsck_update_progress; - ctx->progress_fd = 0; } static void signal_progress_off(int sig EXT2FS_ATTR((unused))) @@ -524,7 +606,7 @@ static void parse_extended_opts(e2fsck_t ctx, const char *opts) if (p) { *p = 0; next = p+1; - } + } arg = strchr(token, '='); if (arg) { *arg = 0; @@ -544,31 +626,53 @@ static void parse_extended_opts(e2fsck_t ctx, const char *opts) continue; } ctx->ext_attr_ver = ea_ver; + } else if (strcmp(token, "fragcheck") == 0) { + ctx->options |= E2F_OPT_FRAGCHECK; + continue; + } else if (strcmp(token, "journal_only") == 0) { + if (arg) { + extended_usage++; + continue; + } + ctx->options |= E2F_OPT_JOURNAL_ONLY; + } else if (strcmp(token, "discard") == 0) { + ctx->options |= E2F_OPT_DISCARD; + continue; + } else if (strcmp(token, "nodiscard") == 0) { + ctx->options &= ~E2F_OPT_DISCARD; + continue; } else { fprintf(stderr, _("Unknown extended option: %s\n"), token); extended_usage++; } } + free(buf); + if (extended_usage) { fputs(("\nExtended options are separated by commas, " "and may take an argument which\n" "is set off by an equals ('=') sign. " - "Valid extended options are:\n" - "\tea_ver=\n\n"), stderr); + "Valid extended options are:\n"), stderr); + fputs(("\tea_ver=\n"), stderr); + fputs(("\tfragcheck\n"), stderr); + fputs(("\tjournal_only\n"), stderr); + fputs(("\tdiscard\n"), stderr); + fputs(("\tnodiscard\n"), stderr); + fputc('\n', stderr); exit(1); } -} +} static void syntax_err_report(const char *filename, long err, int line_num) { - fprintf(stderr, + fprintf(stderr, _("Syntax error in e2fsck config file (%s, line #%d)\n\t%s\n"), filename, line_num, error_message(err)); exit(FSCK_ERROR); } -static const char *config_fn[] = { "/etc/e2fsck.conf", 0 }; +static const char *config_fn[] = { ROOT_SYSCONFDIR "/e2fsck.conf", 0 }; static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) { @@ -584,6 +688,10 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) #endif char *extended_opts = 0; char *cp; + int res; /* result of sscanf */ +#ifdef CONFIG_JBD_DEBUG + char *jbd_debug; +#endif retval = e2fsck_allocate_context(&ctx); if (retval) @@ -601,19 +709,27 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) } memset(bar, '=', sizeof(bar)-1); memset(spaces, ' ', sizeof(spaces)-1); - initialize_ext2_error_table(); - initialize_prof_error_table(); + add_error_table(&et_ext2_error_table); + add_error_table(&et_prof_error_table); blkid_get_cache(&ctx->blkid, NULL); - + if (argc && *argv) ctx->program_name = *argv; else ctx->program_name = "e2fsck"; + while ((c = getopt (argc, argv, "panyrcC:B:dE:fvtFVM:b:I:j:P:l:L:N:SsDk")) != EOF) switch (c) { case 'C': ctx->progress = e2fsck_update_progress; - ctx->progress_fd = atoi(optarg); + res = sscanf(optarg, "%d", &ctx->progress_fd); + if (res != 1) + goto sscanf_err; + + if (ctx->progress_fd < 0) { + ctx->progress = 0; + ctx->progress_fd = ctx->progress_fd * -1; + } if (!ctx->progress_fd) break; /* Validate the file descriptor to avoid disasters */ @@ -638,7 +754,7 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) case 'a': if (ctx->options & (E2F_OPT_YES|E2F_OPT_NO)) { conflict_opt: - fatal_error(ctx, + fatal_error(ctx, _("Only one of the options -p/-a, -n or -y may be specified.")); } ctx->options |= E2F_OPT_PREEN; @@ -673,20 +789,33 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) /* What we do by default, anyway! */ break; case 'b': - ctx->use_superblock = atoi(optarg); + res = sscanf(optarg, "%llu", &ctx->use_superblock); + if (res != 1) + goto sscanf_err; ctx->flags |= E2F_FLAG_SB_SPECIFIED; break; case 'B': ctx->blocksize = atoi(optarg); break; case 'I': - ctx->inode_buffer_blocks = atoi(optarg); + res = sscanf(optarg, "%d", &ctx->inode_buffer_blocks); + if (res != 1) + goto sscanf_err; break; case 'j': - ctx->journal_name = string_copy(ctx, optarg, 0); + ctx->journal_name = blkid_get_devname(ctx->blkid, + optarg, NULL); + if (!ctx->journal_name) { + com_err(ctx->program_name, 0, + _("Unable to resolve '%s'"), + optarg); + fatal_error(ctx, 0); + } break; case 'P': - ctx->process_inode_size = atoi(optarg); + res = sscanf(optarg, "%d", &ctx->process_inode_size); + if (res != 1) + goto sscanf_err; break; case 'L': replace_bad_blocks++; @@ -714,22 +843,8 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) break; #endif case 'N': - ctx->device_name = optarg; - break; -#ifdef ENABLE_SWAPFS - case 's': - normalize_swapfs = 1; - case 'S': - swapfs = 1; + ctx->device_name = string_copy(ctx, optarg, 0); break; -#else - case 's': - case 'S': - fprintf(stderr, _("Byte-swapping filesystems " - "not compiled in this version " - "of e2fsck\n")); - exit(1); -#endif case 'k': keep_bad_blocks++; break; @@ -740,15 +855,31 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) return 0; if (optind != argc - 1) usage(ctx); - if ((ctx->options & E2F_OPT_NO) && !bad_blocks_file && - !cflag && !swapfs && !(ctx->options & E2F_OPT_COMPRESS_DIRS)) + if ((ctx->options & E2F_OPT_NO) && + (ctx->options & E2F_OPT_COMPRESS_DIRS)) { + com_err(ctx->program_name, 0, + _("The -n and -D options are incompatible.")); + fatal_error(ctx, 0); + } + if ((ctx->options & E2F_OPT_NO) && cflag) { + com_err(ctx->program_name, 0, + _("The -n and -c options are incompatible.")); + fatal_error(ctx, 0); + } + if ((ctx->options & E2F_OPT_NO) && bad_blocks_file) { + com_err(ctx->program_name, 0, + _("The -n and -l/-L options are incompatible.")); + fatal_error(ctx, 0); + } + if (ctx->options & E2F_OPT_NO) ctx->options |= E2F_OPT_READONLY; + ctx->io_options = strchr(argv[optind], '?'); - if (ctx->io_options) + if (ctx->io_options) *ctx->io_options++ = 0; ctx->filesystem_name = blkid_get_devname(ctx->blkid, argv[optind], 0); if (!ctx->filesystem_name) { - com_err(ctx->program_name, 0, _("Unable to resolve '%s'"), + com_err(ctx->program_name, 0, _("Unable to resolve '%s'"), argv[optind]); fatal_error(ctx, 0); } @@ -776,15 +907,6 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) } close(fd); } -#ifdef ENABLE_SWAPFS - if (swapfs) { - if (cflag || bad_blocks_file) { - fprintf(stderr, _("Incompatible options not " - "allowed when byte-swapping.\n")); - exit(FSCK_USAGE); - } - } -#endif if (cflag && bad_blocks_file) { fprintf(stderr, _("The -c and the -l/-L options may " "not be both used at the same time.\n")); @@ -811,33 +933,80 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) /* Update our PATH to include /sbin if we need to run badblocks */ if (cflag) { char *oldpath = getenv("PATH"); + char *newpath; + int len = sizeof(PATH_SET) + 1; + + if (oldpath) + len += strlen(oldpath); + + newpath = malloc(len); + if (!newpath) + fatal_error(ctx, "Couldn't malloc() newpath"); + strcpy(newpath, PATH_SET); + if (oldpath) { - char *newpath; - - newpath = (char *) malloc(sizeof (PATH_SET) + 1 + - strlen (oldpath)); - if (!newpath) - fatal_error(ctx, "Couldn't malloc() newpath"); - strcpy (newpath, PATH_SET); - strcat (newpath, ":"); - strcat (newpath, oldpath); - putenv (newpath); - } else - putenv (PATH_SET); + strcat(newpath, ":"); + strcat(newpath, oldpath); + } + putenv(newpath); } #ifdef CONFIG_JBD_DEBUG - if (getenv("E2FSCK_JBD_DEBUG")) - journal_enable_debug = atoi(getenv("E2FSCK_JBD_DEBUG")); + jbd_debug = getenv("E2FSCK_JBD_DEBUG"); + if (jbd_debug) { + res = sscanf(jbd_debug, "%d", &journal_enable_debug); + if (res != 1) { + fprintf(stderr, + _("E2FSCK_JBD_DEBUG \"%s\" not an integer\n\n"), + jbd_debug); + exit (1); + } + } #endif return 0; + +sscanf_err: + fprintf(stderr, _("\nInvalid non-numeric argument to -%c (\"%s\")\n\n"), + c, optarg); + exit (1); +} + +static errcode_t try_open_fs(e2fsck_t ctx, int flags, io_manager io_ptr, + ext2_filsys *ret_fs) +{ + errcode_t retval; + + *ret_fs = NULL; + if (ctx->superblock && ctx->blocksize) { + retval = ext2fs_open2(ctx->filesystem_name, ctx->io_options, + flags, ctx->superblock, ctx->blocksize, + io_ptr, ret_fs); + } else if (ctx->superblock) { + int blocksize; + for (blocksize = EXT2_MIN_BLOCK_SIZE; + blocksize <= EXT2_MAX_BLOCK_SIZE; blocksize *= 2) { + if (*ret_fs) { + ext2fs_free(*ret_fs); + *ret_fs = NULL; + } + retval = ext2fs_open2(ctx->filesystem_name, + ctx->io_options, flags, + ctx->superblock, blocksize, + io_ptr, ret_fs); + if (!retval) + break; + } + } else + retval = ext2fs_open2(ctx->filesystem_name, ctx->io_options, + flags, 0, 0, io_ptr, ret_fs); + return retval; } static const char *my_ver_string = E2FSPROGS_VERSION; static const char *my_ver_date = E2FSPROGS_DATE; - + int main (int argc, char *argv[]) { - errcode_t retval = 0; + errcode_t retval = 0, retval2 = 0, orig_retval = 0; int exit_value = FSCK_OK; ext2_filsys fs = 0; io_manager io_ptr; @@ -845,10 +1014,17 @@ int main (int argc, char *argv[]) const char *lib_ver_date; int my_ver, lib_ver; e2fsck_t ctx; + blk_t orig_superblock; struct problem_context pctx; int flags, run_result; - + int journal_size; + int sysval, sys_page_size = 4096; + int old_bitmaps; + __u32 features[3]; + char *cp; + clear_problem_context(&pctx); + sigcatcher_setup(); #ifdef MTRACE mtrace(); #endif @@ -868,7 +1044,7 @@ int main (int argc, char *argv[]) "out of date!\n")); show_version_only++; } - + retval = PRS(argc, argv, &ctx); if (retval) { com_err("e2fsck", retval, @@ -876,11 +1052,8 @@ int main (int argc, char *argv[]) exit(FSCK_ERROR); } reserve_stdio_fds(); - -#ifdef RESOURCE_TRACK - init_resource_track(&ctx->global_rtrack); -#endif + init_resource_track(&ctx->global_rtrack, NULL); if (!(ctx->options & E2F_OPT_PREEN) || show_version_only) fprintf(stderr, "e2fsck %s (%s)\n", my_ver_string, my_ver_date); @@ -890,9 +1063,9 @@ int main (int argc, char *argv[]) error_message(EXT2_ET_BASE), lib_ver_date); exit(FSCK_OK); } - + check_mount(ctx); - + if (!(ctx->options & E2F_OPT_PREEN) && !(ctx->options & E2F_OPT_NO) && !(ctx->options & E2F_OPT_YES)) { @@ -903,50 +1076,77 @@ int main (int argc, char *argv[]) ctx->superblock = ctx->use_superblock; restart: #ifdef CONFIG_TESTIO_DEBUG - io_ptr = test_io_manager; - test_io_backing_manager = unix_io_manager; -#else - io_ptr = unix_io_manager; + if (getenv("TEST_IO_FLAGS") || getenv("TEST_IO_BLOCK")) { + io_ptr = test_io_manager; + test_io_backing_manager = unix_io_manager; + } else #endif - flags = 0; + io_ptr = unix_io_manager; + flags = EXT2_FLAG_NOFREE_ON_ERROR; + profile_get_boolean(ctx->profile, "options", "old_bitmaps", 0, 0, + &old_bitmaps); + if (!old_bitmaps) + flags |= EXT2_FLAG_64BITS; if ((ctx->options & E2F_OPT_READONLY) == 0) flags |= EXT2_FLAG_RW; if ((ctx->mount_flags & EXT2_MF_MOUNTED) == 0) flags |= EXT2_FLAG_EXCLUSIVE; - if (ctx->superblock && ctx->blocksize) { - retval = ext2fs_open2(ctx->filesystem_name, ctx->io_options, - flags, ctx->superblock, ctx->blocksize, - io_ptr, &fs); - } else if (ctx->superblock) { - int blocksize; - for (blocksize = EXT2_MIN_BLOCK_SIZE; - blocksize <= EXT2_MAX_BLOCK_SIZE; blocksize *= 2) { - retval = ext2fs_open2(ctx->filesystem_name, - ctx->io_options, flags, - ctx->superblock, blocksize, - io_ptr, &fs); - if (!retval) - break; - } - } else - retval = ext2fs_open2(ctx->filesystem_name, ctx->io_options, - flags, 0, 0, io_ptr, &fs); + retval = try_open_fs(ctx, flags, io_ptr, &fs); + if (!ctx->superblock && !(ctx->options & E2F_OPT_PREEN) && !(ctx->flags & E2F_FLAG_SB_SPECIFIED) && ((retval == EXT2_ET_BAD_MAGIC) || - ((retval == 0) && ext2fs_check_desc(fs)))) { + (retval == EXT2_ET_CORRUPT_SUPERBLOCK) || + ((retval == 0) && (retval2 = ext2fs_check_desc(fs))))) { + if (retval2 == ENOMEM) { + retval = retval2; + goto failure; + } + if (fs->flags & EXT2_FLAG_NOFREE_ON_ERROR) { + ext2fs_free(fs); + fs = NULL; + } if (!fs || (fs->group_desc_count > 1)) { - printf(_("%s trying backup blocks...\n"), - retval ? _("Couldn't find ext2 superblock,") : + printf(_("%s: %s trying backup blocks...\n"), + ctx->program_name, + retval ? _("Superblock invalid,") : _("Group descriptors look bad...")); + orig_superblock = ctx->superblock; get_backup_sb(ctx, fs, ctx->filesystem_name, io_ptr); if (fs) ext2fs_close(fs); - goto restart; + orig_retval = retval; + retval = try_open_fs(ctx, flags, io_ptr, &fs); + if ((orig_retval == 0) && retval != 0) { + if (fs) + ext2fs_close(fs); + com_err(ctx->program_name, retval, + "when using the backup blocks"); + printf(_("%s: going back to original " + "superblock\n"), ctx->program_name); + ctx->superblock = orig_superblock; + retval = try_open_fs(ctx, flags, io_ptr, &fs); + } } } + if (((retval == EXT2_ET_UNSUPP_FEATURE) || + (retval == EXT2_ET_RO_UNSUPP_FEATURE)) && + fs && fs->super) { + sb = fs->super; + features[0] = (sb->s_feature_compat & + ~EXT2_LIB_FEATURE_COMPAT_SUPP); + features[1] = (sb->s_feature_incompat & + ~EXT2_LIB_FEATURE_INCOMPAT_SUPP); + features[2] = (sb->s_feature_ro_compat & + ~EXT2_LIB_FEATURE_RO_COMPAT_SUPP); + if (features[0] || features[1] || features[2]) + goto print_unsupp_features; + } +failure: if (retval) { + if (orig_retval) + retval = orig_retval; com_err(ctx->program_name, retval, _("while trying to open %s"), ctx->filesystem_name); if (retval == EXT2_ET_REV_TOO_HIGH) { @@ -967,6 +1167,8 @@ restart: else if (retval == EBUSY) printf(_("Filesystem mounted or opened exclusively " "by another program?\n")); + else if (retval == ENOENT) + printf(_("Possibly non-existent device?\n")); #ifdef EROFS else if (retval == EROFS) printf(_("Disk write-protected; use the -n option " @@ -977,6 +1179,53 @@ restart: fix_problem(ctx, PR_0_SB_CORRUPT, &pctx); fatal_error(ctx, 0); } + /* + * We only update the master superblock because (a) paranoia; + * we don't want to corrupt the backup superblocks, and (b) we + * don't need to update the mount count and last checked + * fields in the backup superblock (the kernel doesn't update + * the backup superblocks anyway). With newer versions of the + * library this flag is set by ext2fs_open2(), but we set this + * here just to be sure. (No, we don't support e2fsck running + * with some other libext2fs than the one that it was shipped + * with, but just in case....) + */ + fs->flags |= EXT2_FLAG_MASTER_SB_ONLY; + + if (!(ctx->flags & E2F_FLAG_GOT_DEVSIZE)) { + __u32 blocksize = EXT2_BLOCK_SIZE(fs->super); + int need_restart = 0; + + pctx.errcode = ext2fs_get_device_size2(ctx->filesystem_name, + blocksize, + &ctx->num_blocks); + /* + * The floppy driver refuses to allow anyone else to + * open the device if has been opened with O_EXCL; + * this is unlike other block device drivers in Linux. + * To handle this, we close the filesystem and then + * reopen the filesystem after we get the device size. + */ + if (pctx.errcode == EBUSY) { + ext2fs_close(fs); + need_restart++; + pctx.errcode = + ext2fs_get_device_size2(ctx->filesystem_name, + blocksize, + &ctx->num_blocks); + } + if (pctx.errcode == EXT2_ET_UNIMPLEMENTED) + ctx->num_blocks = 0; + else if (pctx.errcode) { + fix_problem(ctx, PR_0_GETSIZE_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + fatal_error(ctx, 0); + } + ctx->flags |= E2F_FLAG_GOT_DEVSIZE; + if (need_restart) + goto restart; + } + ctx->fs = fs; fs->priv_data = ctx; fs->now = ctx->now; @@ -999,7 +1248,16 @@ restart: sizeof(sb->s_volume_name)); } if (ctx->device_name == 0) - ctx->device_name = ctx->filesystem_name; + ctx->device_name = string_copy(ctx, ctx->filesystem_name, 0); + for (cp = ctx->device_name; *cp; cp++) + if (isspace(*cp) || *cp == ':') + *cp = '_'; + + ehandler_init(fs->io); + + if ((ctx->mount_flags & EXT2_MF_MOUNTED) && + !(sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER)) + goto skip_journal; /* * Make sure the ext3 superblock fields are consistent. @@ -1048,19 +1306,31 @@ restart: } } +skip_journal: /* * Check for compatibility with the feature sets. We need to * be more stringent than ext2fs_open(). */ - if ((sb->s_feature_compat & ~EXT2_LIB_FEATURE_COMPAT_SUPP) || - (sb->s_feature_incompat & ~EXT2_LIB_FEATURE_INCOMPAT_SUPP)) { - com_err(ctx->program_name, EXT2_ET_UNSUPP_FEATURE, - "(%s)", ctx->device_name); - goto get_newer; - } - if (sb->s_feature_ro_compat & ~EXT2_LIB_FEATURE_RO_COMPAT_SUPP) { - com_err(ctx->program_name, EXT2_ET_RO_UNSUPP_FEATURE, - "(%s)", ctx->device_name); + features[0] = sb->s_feature_compat & ~EXT2_LIB_FEATURE_COMPAT_SUPP; + features[1] = sb->s_feature_incompat & ~EXT2_LIB_FEATURE_INCOMPAT_SUPP; + features[2] = (sb->s_feature_ro_compat & + ~EXT2_LIB_FEATURE_RO_COMPAT_SUPP); +print_unsupp_features: + if (features[0] || features[1] || features[2]) { + int i, j; + __u32 *mask = features, m; + + fprintf(stderr, _("%s has unsupported feature(s):"), + ctx->filesystem_name); + + for (i=0; i <3; i++,mask++) { + for (j=0,m=1; j < 32; j++, m<<=1) { + if (*mask & m) + fprintf(stderr, " %s", + e2p_feature2string(i, m)); + } + } + putc('\n', stderr); goto get_newer; } #ifdef ENABLE_COMPRESSION @@ -1088,15 +1358,18 @@ restart: ext2fs_mark_super_dirty(fs); /* - * We only update the master superblock because (a) paranoia; - * we don't want to corrupt the backup superblocks, and (b) we - * don't need to update the mount count and last checked - * fields in the backup superblock (the kernel doesn't - * update the backup superblocks anyway). + * Calculate the number of filesystem blocks per pagesize. If + * fs->blocksize > page_size, set the number of blocks per + * pagesize to 1 to avoid division by zero errors. */ - fs->flags |= EXT2_FLAG_MASTER_SB_ONLY; - - ehandler_init(fs->io); +#ifdef _SC_PAGESIZE + sysval = sysconf(_SC_PAGESIZE); + if (sysval > 0) + sys_page_size = sysval; +#endif /* _SC_PAGESIZE */ + ctx->blocks_per_page = sys_page_size / fs->blocksize; + if (ctx->blocks_per_page == 0) + ctx->blocks_per_page = 1; if (ctx->superblock) set_latch_flags(PR_LATCH_RELOC, PRL_LATCHED, 0); @@ -1105,27 +1378,13 @@ restart: if (ctx->flags & E2F_FLAG_SIGNAL_MASK) fatal_error(ctx, 0); check_if_skip(ctx); + check_resize_inode(ctx); if (bad_blocks_file) read_bad_blocks_file(ctx, bad_blocks_file, replace_bad_blocks); else if (cflag) read_bad_blocks_file(ctx, 0, !keep_bad_blocks); /* Test disk */ if (ctx->flags & E2F_FLAG_SIGNAL_MASK) fatal_error(ctx, 0); -#ifdef ENABLE_SWAPFS - if (normalize_swapfs) { - if ((fs->flags & EXT2_FLAG_SWAP_BYTES) == - ext2fs_native_flag()) { - fprintf(stderr, _("%s: Filesystem byte order " - "already normalized.\n"), ctx->device_name); - fatal_error(ctx, 0); - } - } - if (swapfs) { - swap_filesys(ctx); - if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - fatal_error(ctx, 0); - } -#endif /* * Mark the system as valid, 'til proven otherwise @@ -1141,8 +1400,66 @@ restart: " but we'll try to go on...\n")); } + /* + * Save the journal size in megabytes. + * Try and use the journal size from the backup else let e2fsck + * find the default journal size. + */ + if (sb->s_jnl_backup_type == EXT3_JNL_BACKUP_BLOCKS) + journal_size = (sb->s_jnl_blocks[15] << (32 - 20)) | + (sb->s_jnl_blocks[16] >> 20); + else + journal_size = -1; + + if (sb->s_feature_ro_compat & EXT4_FEATURE_RO_COMPAT_QUOTA) { + int qtype; + /* Quotas were enabled. Do quota accounting during fsck. */ + if ((sb->s_usr_quota_inum && sb->s_grp_quota_inum) || + (!sb->s_usr_quota_inum && !sb->s_grp_quota_inum)) + qtype = -1; + else + qtype = sb->s_usr_quota_inum ? USRQUOTA : GRPQUOTA; + + init_quota_context(&ctx->qctx, ctx->fs, qtype); + } + run_result = e2fsck_run(ctx); e2fsck_clear_progbar(ctx); + + if (ctx->flags & E2F_FLAG_JOURNAL_INODE) { + if (fix_problem(ctx, PR_6_RECREATE_JOURNAL, &pctx)) { + if (journal_size < 1024) + journal_size = ext2fs_default_journal_size(ext2fs_blocks_count(fs->super)); + if (journal_size < 0) { + fs->super->s_feature_compat &= + ~EXT3_FEATURE_COMPAT_HAS_JOURNAL; + fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; + com_err(ctx->program_name, 0, + _("Couldn't determine journal size")); + goto no_journal; + } + printf(_("Creating journal (%d blocks): "), + journal_size); + fflush(stdout); + retval = ext2fs_add_journal_inode(fs, + journal_size, 0); + if (retval) { + com_err("Error ", retval, + _("\n\twhile trying to create journal")); + goto no_journal; + } + printf(_(" Done.\n")); + printf(_("\n*** journal has been re-created - " + "filesystem is now ext3 again ***\n")); + } + } +no_journal: + + if (ctx->qctx) { + write_quota_inode(ctx->qctx, -1); + release_quota_context(&ctx->qctx); + } + if (run_result == E2F_FLAG_RESTART) { printf(_("Restarting e2fsck from the beginning...\n")); retval = e2fsck_reset_context(ctx); @@ -1161,6 +1478,10 @@ restart: } if (run_result & E2F_FLAG_ABORT) fatal_error(ctx, _("aborted")); + if (check_backup_super_block(ctx)) { + fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; + ext2fs_mark_super_dirty(fs); + } #ifdef MTRACE mtrace_print("Cleanup"); @@ -1177,7 +1498,7 @@ restart: } } if (!ext2fs_test_valid(fs) || - ((exit_value & FSCK_CANCELED) && + ((exit_value & FSCK_CANCELED) && (sb->s_state & EXT2_ERROR_FS))) { printf(_("\n%s: ********** WARNING: Filesystem still has " "errors **********\n\n"), ctx->device_name); @@ -1188,11 +1509,11 @@ restart: int allow_cancellation; profile_get_boolean(ctx->profile, "options", - "allow_cancellation", 0, 0, + "allow_cancellation", 0, 0, &allow_cancellation); exit_value &= ~FSCK_NONDESTRUCT; if (allow_cancellation && ext2fs_test_valid(fs) && - (sb->s_state & EXT2_VALID_FS) && + (sb->s_state & EXT2_VALID_FS) && !(sb->s_state & EXT2_ERROR_FS)) exit_value = 0; } else { @@ -1205,22 +1526,35 @@ restart: } else sb->s_state &= ~EXT2_VALID_FS; sb->s_mnt_count = 0; - sb->s_lastcheck = ctx->now; + if (!(ctx->flags & E2F_FLAG_TIME_INSANE)) + sb->s_lastcheck = ctx->now; + memset(((char *) sb) + EXT4_S_ERR_START, 0, + EXT4_S_ERR_LEN); ext2fs_mark_super_dirty(fs); } } + if ((run_result & E2F_FLAG_CANCEL) == 0 && + sb->s_feature_ro_compat & EXT4_FEATURE_RO_COMPAT_GDT_CSUM && + !(ctx->options & E2F_OPT_READONLY)) { + retval = ext2fs_set_gdt_csum(ctx->fs); + if (retval) { + com_err(ctx->program_name, retval, + _("while setting block group checksum info")); + fatal_error(ctx, 0); + } + } + e2fsck_write_bitmaps(ctx); - + io_channel_flush(ctx->fs->io); + print_resource_track(ctx, NULL, &ctx->global_rtrack, ctx->fs->io); + ext2fs_close(fs); ctx->fs = NULL; - free(ctx->filesystem_name); free(ctx->journal_name); -#ifdef RESOURCE_TRACK - if (ctx->options & E2F_OPT_TIME) - print_resource_track(NULL, &ctx->global_rtrack); -#endif e2fsck_free_context(ctx); + remove_error_table(&et_ext2_error_table); + remove_error_table(&et_prof_error_table); return exit_value; }