X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=e2fsck%2Funix.c;h=c95caddffd216915b794c499fd5ed59fe848998b;hb=4259052093da329907e255b11bf3e799872828c7;hp=4ab0802ebfb55db499f384d2dbafc2f2a3566836;hpb=2930dad2b20fe4b04ee3e9f5c7a76d8bf63342b0;p=tools%2Fe2fsprogs.git diff --git a/e2fsck/unix.c b/e2fsck/unix.c index 4ab0802..c95cadd 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,9 @@ * %End-Header% */ +#define _XOPEN_SOURCE 600 /* for inclusion of sa_handler in Solaris */ + +#include "config.h" #include #ifdef HAVE_STDLIB_H #include @@ -46,6 +49,7 @@ extern int optind; #include #endif +#include "e2p/e2p.h" #include "et/com_err.h" #include "e2p/e2p.h" #include "e2fsck.h" @@ -98,10 +102,11 @@ static void show_stats(e2fsck_t ctx) { ext2_filsys fs = ctx->fs; ext2_ino_t inodes, inodes_used; - blk_t blocks, blocks_used; - int dir_links; - int num_files, num_links; - int frag_percent; + 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; @@ -109,29 +114,58 @@ 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: %u/%u 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%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 inode (%0d.%d%%)\n", - "%8u non-contiguous inodes (%0d.%d%%)\n", + 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); + 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 (%2.2f%%)\n", "%8u blocks used (%2.2f%%)\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); @@ -198,9 +232,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); @@ -218,7 +252,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); @@ -228,7 +262,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) @@ -254,22 +288,31 @@ 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) return; - + + if (ctx->options & E2F_OPT_JOURNAL_ONLY) + goto skip; + lastcheck = fs->super->s_lastcheck; if (lastcheck > ctx->now) lastcheck -= ctx->time_fudge; @@ -285,14 +328,20 @@ static void check_if_skip(e2fsck_t ctx) (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 - 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; } @@ -302,23 +351,54 @@ static void check_if_skip(e2fsck_t ctx) fputs(_(", check forced.\n"), stdout); return; } - printf(_("%s: clean, %u/%u 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 @@ -327,6 +407,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); @@ -349,7 +430,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) @@ -363,7 +444,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); @@ -386,7 +467,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) @@ -431,7 +512,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); @@ -447,11 +528,11 @@ static int e2fsck_update_progress(e2fsck_t ctx, int pass, if (pass == 0) return 0; - + if (ctx->progress_fd) { - snprintf(buf, sizeof(buf), "%d %lu %lu %s\n", + snprintf(buf, sizeof(buf), "%d %lu %lu %s\n", pass, cur, max, ctx->device_name); - write(ctx->progress_fd, buf, strlen(buf)); + write_all(ctx->progress_fd, buf, strlen(buf)); } else { percent = calc_percent(&e2fsck_tbl, pass, cur, max); e2fsck_simple_progress(ctx, ctx->device_name, @@ -462,14 +543,16 @@ static int e2fsck_update_progress(e2fsck_t ctx, int pass, #define PATH_SET "PATH=/sbin" +/* + * Make sure 0,1,2 file descriptors are open, so that we don't open + * the filesystem using the same file descriptor as stdout or stderr. + */ static void reserve_stdio_fds(void) { - int fd; + int fd = 0; - while (1) { + while (fd <= 2) { fd = open("/dev/null", O_RDWR); - if (fd > 2) - break; if (fd < 0) { fprintf(stderr, _("ERROR: Couldn't open " "/dev/null (%s)\n"), @@ -477,7 +560,6 @@ static void reserve_stdio_fds(void) break; } } - close(fd); } #ifdef HAVE_SIGNAL_H @@ -546,6 +628,21 @@ 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); @@ -558,15 +655,20 @@ static void parse_extended_opts(e2fsck_t ctx, const char *opts) 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); @@ -612,11 +714,12 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) 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': @@ -653,7 +756,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; @@ -688,7 +791,7 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) /* What we do by default, anyway! */ break; case 'b': - res = sscanf(optarg, "%d", &ctx->use_superblock); + res = sscanf(optarg, "%llu", &ctx->use_superblock); if (res != 1) goto sscanf_err; ctx->flags |= E2F_FLAG_SB_SPECIFIED; @@ -702,7 +805,14 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) 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': res = sscanf(optarg, "%d", &ctx->process_inode_size); @@ -747,20 +857,34 @@ 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 && !(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); } - ctx->filesystem_name = string_copy(ctx, ctx->filesystem_name, 0); if (extended_opts) parse_extended_opts(ctx, extended_opts); @@ -848,12 +972,125 @@ sscanf_err: 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 e2fsck_check_mmp(ext2_filsys fs, e2fsck_t ctx) +{ + struct mmp_struct *mmp_s; + unsigned int mmp_check_interval; + errcode_t retval = 0; + struct problem_context pctx; + unsigned int wait_time = 0; + + clear_problem_context(&pctx); + if (fs->mmp_buf == NULL) { + retval = ext2fs_get_mem(fs->blocksize, &fs->mmp_buf); + if (retval) + goto check_error; + } + + retval = ext2fs_mmp_read(fs, fs->super->s_mmp_block, fs->mmp_buf); + if (retval) + goto check_error; + + mmp_s = fs->mmp_buf; + + mmp_check_interval = fs->super->s_mmp_update_interval; + if (mmp_check_interval < EXT4_MMP_MIN_CHECK_INTERVAL) + mmp_check_interval = EXT4_MMP_MIN_CHECK_INTERVAL; + + /* + * If check_interval in MMP block is larger, use that instead of + * check_interval from the superblock. + */ + if (mmp_s->mmp_check_interval > mmp_check_interval) + mmp_check_interval = mmp_s->mmp_check_interval; + + wait_time = mmp_check_interval * 2 + 1; + + if (mmp_s->mmp_seq == EXT4_MMP_SEQ_CLEAN) + retval = 0; + else if (mmp_s->mmp_seq == EXT4_MMP_SEQ_FSCK) + retval = EXT2_ET_MMP_FSCK_ON; + else if (mmp_s->mmp_seq > EXT4_MMP_SEQ_MAX) + retval = EXT2_ET_MMP_UNKNOWN_SEQ; + + if (retval) + goto check_error; + + /* Print warning if e2fck will wait for more than 20 secs. */ + if (verbose || wait_time > EXT4_MMP_MIN_CHECK_INTERVAL * 4) { + printf("MMP interval is %u seconds and total wait time is %u " + "seconds. Please wait...\n", + mmp_check_interval, wait_time * 2); + } + + return 0; + +check_error: + + if (retval == EXT2_ET_MMP_BAD_BLOCK) { + if (fix_problem(ctx, PR_0_MMP_INVALID_BLK, &pctx)) { + fs->super->s_mmp_block = 0; + ext2fs_mark_super_dirty(fs); + retval = 0; + } + } else if (retval == EXT2_ET_MMP_FAILED) { + com_err(ctx->program_name, retval, + _("while checking MMP block")); + dump_mmp_msg(fs->mmp_buf, NULL); + } else if (retval == EXT2_ET_MMP_FSCK_ON || + retval == EXT2_ET_MMP_UNKNOWN_SEQ) { + com_err(ctx->program_name, retval, + _("while checking MMP block")); + dump_mmp_msg(fs->mmp_buf, + _("If you are sure the filesystem is not " + "in use on any node, run:\n" + "'tune2fs -f -E clear_mmp {device}'\n")); + } else if (retval == EXT2_ET_MMP_MAGIC_INVALID) { + if (fix_problem(ctx, PR_0_MMP_INVALID_MAGIC, &pctx)) { + ext2fs_mmp_clear(fs); + retval = 0; + } + } + return retval; +} + int main (int argc, char *argv[]) { - errcode_t retval = 0, orig_retval = 0; + errcode_t retval = 0, retval2 = 0, orig_retval = 0; int exit_value = FSCK_OK; ext2_filsys fs = 0; io_manager io_ptr; @@ -861,14 +1098,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 @@ -888,7 +1128,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, @@ -896,11 +1136,8 @@ int main (int argc, char *argv[]) exit(FSCK_ERROR); } reserve_stdio_fds(); - -#ifdef RESOURCE_TRACK - init_resource_track(&ctx->global_rtrack, NULL); -#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); @@ -910,9 +1147,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)) { @@ -921,71 +1158,78 @@ int main (int argc, char *argv[]) _("need terminal for interactive repairs")); } ctx->superblock = ctx->use_superblock; + + flags = EXT2_FLAG_SKIP_MMP; 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 = EXT2_FLAG_NOFREE_ON_ERROR; + 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 == EXT2_ET_CORRUPT_SUPERBLOCK) || - ((retval == 0) && ext2fs_check_desc(fs)))) { + ((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: %s trying backup blocks...\n"), - ctx->program_name, + 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); orig_retval = retval; - goto restart; + 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 & + features[0] = (sb->s_feature_compat & ~EXT2_LIB_FEATURE_COMPAT_SUPP); - features[1] = (sb->s_feature_incompat & + features[1] = (sb->s_feature_incompat & ~EXT2_LIB_FEATURE_INCOMPAT_SUPP); - features[2] = (sb->s_feature_ro_compat & + 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; @@ -1009,6 +1253,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 " @@ -1036,9 +1282,9 @@ restart: __u32 blocksize = EXT2_BLOCK_SIZE(fs->super); int need_restart = 0; - pctx.errcode = ext2fs_get_device_size(ctx->filesystem_name, - blocksize, - &ctx->num_blocks); + 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; @@ -1049,10 +1295,10 @@ restart: if (pctx.errcode == EBUSY) { ext2fs_close(fs); need_restart++; - pctx.errcode = - ext2fs_get_device_size(ctx->filesystem_name, - blocksize, - &ctx->num_blocks); + pctx.errcode = + ext2fs_get_device_size2(ctx->filesystem_name, + blocksize, + &ctx->num_blocks); } if (pctx.errcode == EXT2_ET_UNIMPLEMENTED) ctx->num_blocks = 0; @@ -1093,6 +1339,28 @@ restart: if (isspace(*cp) || *cp == ':') *cp = '_'; + ehandler_init(fs->io); + + if ((fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_MMP) && + (flags & EXT2_FLAG_SKIP_MMP)) { + if (e2fsck_check_mmp(fs, ctx)) + fatal_error(ctx, 0); + } + + /* + * Restart in order to reopen fs but this time start mmp. + */ + if (flags & EXT2_FLAG_SKIP_MMP) { + ext2fs_close(fs); + ctx->fs = NULL; + flags &= ~EXT2_FLAG_SKIP_MMP; + goto restart; + } + + 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. */ @@ -1140,26 +1408,27 @@ restart: } } +skip_journal: /* * Check for compatibility with the feature sets. We need to * be more stringent than ext2fs_open(). */ 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 & + 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):"), + 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", + fprintf(stderr, " %s", e2p_feature2string(i, m)); } } @@ -1204,8 +1473,6 @@ print_unsupp_features: if (ctx->blocks_per_page == 0) ctx->blocks_per_page = 1; - ehandler_init(fs->io); - if (ctx->superblock) set_latch_flags(PR_LATCH_RELOC, PRL_LATCHED, 0); ext2fs_mark_valid(fs); @@ -1213,6 +1480,7 @@ print_unsupp_features: 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) @@ -1240,22 +1508,35 @@ print_unsupp_features: * find the default journal size. */ if (sb->s_jnl_backup_type == EXT3_JNL_BACKUP_BLOCKS) - journal_size = sb->s_jnl_blocks[16] >> 20; + 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(fs->super->s_blocks_count); + 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, + com_err(ctx->program_name, 0, _("Couldn't determine journal size")); goto no_journal; } @@ -1276,6 +1557,11 @@ print_unsupp_features: } 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); @@ -1314,7 +1600,7 @@ no_journal: } } 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); @@ -1325,11 +1611,11 @@ no_journal: 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 { @@ -1342,12 +1628,16 @@ no_journal: } 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 (sb->s_feature_ro_compat & EXT4_FEATURE_RO_COMPAT_GDT_CSUM && + 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) { @@ -1358,11 +1648,9 @@ no_journal: } e2fsck_write_bitmaps(ctx); -#ifdef RESOURCE_TRACK io_channel_flush(ctx->fs->io); - if (ctx->options & E2F_OPT_TIME) - print_resource_track(NULL, &ctx->global_rtrack, ctx->fs->io); -#endif + print_resource_track(ctx, NULL, &ctx->global_rtrack, ctx->fs->io); + ext2fs_close(fs); ctx->fs = NULL; free(ctx->journal_name);