X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=e2fsck%2Funix.c;h=7b662e49919057a8a4d2a3021847bb78d4842354;hb=49a7360ba6b986242d9f0f33e102291d2e0dfb47;hp=43a64b5ea48cb31ec9b128070d1aa02626666d6c;hpb=4b13704cbec7249ba223608143026142b8729318;p=tools%2Fe2fsprogs.git diff --git a/e2fsck/unix.c b/e2fsck/unix.c index 43a64b5..7b662e4 100644 --- a/e2fsck/unix.c +++ b/e2fsck/unix.c @@ -52,8 +52,6 @@ extern int optind; #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,9 +69,9 @@ 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 ext-journal]\n" + "\t\t[-l|-L bad_blocks_file] [-C fd] [-j external_journal]\n" "\t\t[-E extended-options] device\n"), ctx->program_name); @@ -87,7 +85,7 @@ static void usage(e2fsck_t ctx) " -v Be verbose\n" " -b superblock Use alternative superblock\n" " -B blocksize Force blocksize when looking for superblock\n" - " -j external-journal Set location of the external journal\n" + " -j external_journal Set location of the external journal\n" " -l bad_blocks_file Add to badblocks list\n" " -L bad_blocks_file Set badblocks list\n" )); @@ -98,7 +96,8 @@ static void usage(e2fsck_t ctx) static void show_stats(e2fsck_t ctx) { ext2_filsys fs = ctx->fs; - int inodes, inodes_used, blocks, blocks_used; + ext2_ino_t inodes, inodes_used; + blk_t blocks, blocks_used; int dir_links; int num_files, num_links; int frag_percent; @@ -117,49 +116,48 @@ static void show_stats(e2fsck_t ctx) frag_percent = (frag_percent + 5) / 10; if (!verbose) { - printf(_("%s: %d/%d files (%0d.%d%% non-contiguous), %d/%d blocks\n"), + printf(_("%s: %u/%u files (%0d.%d%% non-contiguous), %u/%u blocks\n"), ctx->device_name, inodes_used, inodes, frag_percent / 10, frag_percent % 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 inode (%0d.%d%%)\n", + "%8u non-contiguous inodes (%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"), + 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_("%8d block used (%d%%)\n", "%8d 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", + printf (P_("%8u block used (%2.2f%%)\n", "%8u 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); } @@ -179,15 +177,18 @@ static void check_mount(e2fsck_t ctx) } /* - * If the filesystem isn't mounted, or it's the root filesystem - * and it's mounted read-only, then everything's fine. + * If the filesystem isn't mounted, or it's the root + * filesystem and it's mounted read-only, and we're not doing + * a read/write check, then everything's fine. */ if ((!(ctx->mount_flags & EXT2_MF_MOUNTED)) || ((ctx->mount_flags & EXT2_MF_ISROOT) && - (ctx->mount_flags & EXT2_MF_READONLY))) + (ctx->mount_flags & EXT2_MF_READONLY) && + !(ctx->options & E2F_OPT_WRITECHECK))) return; - if (ctx->options & E2F_OPT_READONLY) { + if ((ctx->options & E2F_OPT_READONLY) && + !(ctx->options & E2F_OPT_WRITECHECK)) { printf(_("Warning! %s is mounted.\n"), ctx->filesystem_name); return; } @@ -222,24 +223,25 @@ static int is_on_batt(void) return (acflag != 1); } d = opendir("/proc/acpi/ac_adapter"); - while (d && (de=readdir(d))) { - if (!strncmp(".", de->d_name, 1)) - continue; - snprintf(fname, 80, "/proc/acpi/ac_adapter/%s/state", - de->d_name); - f = fopen(fname, "r"); - if (!f) - continue; - if (fscanf(f, "%s %s", tmp2, tmp) != 2) - tmp[0] = 0; - fclose(f); - if (strncmp(tmp, "off-line", 8) == 0) { - closedir(d); - return 1; + if (d) { + while ((de=readdir(d)) != NULL) { + if (!strncmp(".", de->d_name, 1)) + continue; + snprintf(fname, 80, "/proc/acpi/ac_adapter/%s/state", + de->d_name); + f = fopen(fname, "r"); + if (!f) + continue; + if (fscanf(f, "%s %s", tmp2, tmp) != 2) + tmp[0] = 0; + fclose(f); + if (strncmp(tmp, "off-line", 8) == 0) { + closedir(d); + return 1; + } } - } - if (d) closedir(d); + } return 0; } @@ -255,16 +257,28 @@ static void check_if_skip(e2fsck_t ctx) unsigned int reason_arg = 0; long next_check; int batt = is_on_batt(); - time_t now = time(0); - - if ((ctx->options & E2F_OPT_FORCE) || bad_blocks_file || - cflag || swapfs) + int defer_check_on_battery; + time_t lastcheck; + + profile_get_boolean(ctx->profile, "options", + "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 (fs->super->s_state & EXT2_ERROR_FS) + 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)) { @@ -274,11 +288,10 @@ static void check_if_skip(e2fsck_t ctx) (unsigned) fs->super->s_max_mnt_count*2)) reason = 0; } else if (fs->super->s_checkinterval && - ((now - fs->super->s_lastcheck) >= - fs->super->s_checkinterval)) { + ((ctx->now - lastcheck) >= fs->super->s_checkinterval)) { reason = _(" has gone %u days without being checked"); - reason_arg = (now - fs->super->s_lastcheck)/(3600*24); - if (batt && ((now - fs->super->s_lastcheck) < + reason_arg = (ctx->now - fs->super->s_lastcheck)/(3600*24); + if (batt && ((ctx->now - fs->super->s_lastcheck) < fs->super->s_checkinterval*2)) reason = 0; } @@ -288,7 +301,7 @@ static void check_if_skip(e2fsck_t ctx) fputs(_(", check forced.\n"), stdout); return; } - printf(_("%s: clean, %d/%d files, %d/%d blocks"), ctx->device_name, + printf(_("%s: clean, %u/%u files, %u/%u 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, @@ -300,12 +313,16 @@ static void check_if_skip(e2fsck_t ctx) next_check = 1; } if (fs->super->s_checkinterval && - ((now - fs->super->s_lastcheck) >= 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) - fputs(_(" (check after next mount)"), stdout); - else + if (next_check == 1) { + if (batt) + fputs(_(" (check deferred; on battery)"), + stdout); + else + fputs(_(" (check after next mount)"), stdout); + } else printf(_(" (check in %ld mounts)"), next_check); } fputc('\n', stdout); @@ -360,6 +377,7 @@ int e2fsck_simple_progress(e2fsck_t ctx, const char *label, float percent, unsigned int tick; struct timeval tv; int dpywidth; + int fixed_percent; if (ctx->flags & E2F_FLAG_PROG_SUPPRESS) return 0; @@ -369,9 +387,10 @@ int e2fsck_simple_progress(e2fsck_t ctx, const char *label, float percent, * percentage hasn't changed, then we skip out right * away. */ - if (ctx->progress_last_percent == (int) 10 * percent) + fixed_percent = (int) ((10 * percent) + 0.5); + if (ctx->progress_last_percent == fixed_percent) return 0; - ctx->progress_last_percent = (int) 10 * percent; + ctx->progress_last_percent = fixed_percent; /* * If we've already updated the spinner once within @@ -381,7 +400,7 @@ int e2fsck_simple_progress(e2fsck_t ctx, const char *label, float percent, gettimeofday(&tv, NULL); tick = (tv.tv_sec << 3) + (tv.tv_usec / (1000000 / 8)); if ((tick == ctx->progress_last_time) && - (percent != 0.0) && (percent != 100.0)) + (fixed_percent != 0) && (fixed_percent != 1000)) return 0; ctx->progress_last_time = tick; @@ -401,16 +420,18 @@ int e2fsck_simple_progress(e2fsck_t ctx, const char *label, float percent, printf("%s%s: |%s%s", ctx->start_meta, label, bar + (sizeof(bar) - (i+1)), spaces + (sizeof(spaces) - (dpywidth - i + 1))); - if (percent == 100.0) + if (fixed_percent == 1000) fputc('|', stdout); else fputc(spinner[ctx->progress_pos & 3], stdout); + printf(" %4.1f%% ", percent); if (dpynum) - printf(" %4.1f%% %u\r%s", percent, dpynum, ctx->stop_meta); + printf("%u\r", dpynum); else - printf(" %4.1f%% \r%s", percent, ctx->stop_meta); + fputs(" \r", stdout); + fputs(ctx->stop_meta, stdout); - if (percent == 100.0) + if (fixed_percent == 1000) e2fsck_clear_progbar(ctx); fflush(stdout); @@ -504,7 +525,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; @@ -524,19 +545,35 @@ static void parse_extended_opts(e2fsck_t ctx, const char *opts) continue; } ctx->ext_attr_ver = ea_ver; - } else + } else { + fprintf(stderr, _("Unknown extended option: %s\n"), + token); extended_usage++; + } } + free(buf); + if (extended_usage) { - fprintf(stderr, _("Extended options are separated by commas, " - "and may take an argument which\n" - "is set off by an equals ('=') sign. " - "Valid raid options are:\n" - "\tea_ver=blkid, NULL); if (argc && *argv) @@ -579,7 +622,10 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) 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) break; /* Validate the file descriptor to avoid disasters */ @@ -605,7 +651,7 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) if (ctx->options & (E2F_OPT_YES|E2F_OPT_NO)) { conflict_opt: fatal_error(ctx, - _("Only one the options -p/-a, -n or -y may be specified.")); + _("Only one of the options -p/-a, -n or -y may be specified.")); } ctx->options |= E2F_OPT_PREEN; break; @@ -639,20 +685,26 @@ 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, "%d", &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); 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++; @@ -682,20 +734,6 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) case 'N': ctx->device_name = optarg; break; -#ifdef ENABLE_SWAPFS - case 's': - normalize_swapfs = 1; - case 'S': - swapfs = 1; - 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; @@ -707,8 +745,9 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) if (optind != argc - 1) usage(ctx); if ((ctx->options & E2F_OPT_NO) && !bad_blocks_file && - !cflag && !swapfs && !(ctx->options & E2F_OPT_COMPRESS_DIRS)) + !cflag && !(ctx->options & E2F_OPT_COMPRESS_DIRS)) ctx->options |= E2F_OPT_READONLY; + ctx->io_options = strchr(argv[optind], '?'); if (ctx->io_options) *ctx->io_options++ = 0; @@ -720,7 +759,12 @@ static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx) } if (extended_opts) parse_extended_opts(ctx, extended_opts); - + + if ((cp = getenv("E2FSCK_CONFIG")) != NULL) + config_fn[0] = cp; + profile_set_syntax_err_cb(syntax_err_report); + profile_init(config_fn, &ctx->profile); + if (flush) { fd = open(ctx->filesystem_name, O_RDONLY, 0); if (fd < 0) { @@ -737,15 +781,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")); @@ -772,33 +807,49 @@ 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 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, orig_retval = 0; int exit_value = FSCK_OK; ext2_filsys fs = 0; io_manager io_ptr; @@ -808,6 +859,9 @@ int main (int argc, char *argv[]) e2fsck_t ctx; struct problem_context pctx; int flags, run_result; + int journal_size; + int sysval, sys_page_size = 4096; + __u32 features[3]; clear_problem_context(&pctx); #ifdef MTRACE @@ -839,7 +893,7 @@ int main (int argc, char *argv[]) reserve_stdio_fds(); #ifdef RESOURCE_TRACK - init_resource_track(&ctx->global_rtrack); + init_resource_track(&ctx->global_rtrack, NULL); #endif if (!(ctx->options & E2F_OPT_PREEN) || show_version_only) @@ -869,14 +923,11 @@ restart: #else io_ptr = unix_io_manager; #endif - flags = 0; + flags = EXT2_FLAG_NOFREE_ON_ERROR; if ((ctx->options & E2F_OPT_READONLY) == 0) flags |= EXT2_FLAG_RW; - - if (ctx->io_options) { - int len = strlen(ctx->filesystem_name) + - strlen(ctx->io_options) + 2; - } + 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, @@ -899,18 +950,40 @@ restart: 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)))) { + 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...")); get_backup_sb(ctx, fs, ctx->filesystem_name, io_ptr); if (fs) ext2fs_close(fs); + orig_retval = retval; goto restart; } } + 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; + } 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) { @@ -928,6 +1001,9 @@ restart: "r/o" : "r/w"); else if (retval == ENXIO) printf(_("Possibly non-existent or swap device?\n")); + else if (retval == EBUSY) + printf(_("Filesystem mounted or opened exclusively " + "by another program?\n")); #ifdef EROFS else if (retval == EROFS) printf(_("Disk write-protected; use the -n option " @@ -938,8 +1014,56 @@ 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_size(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_size(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; sb = fs->super; if (sb->s_rev_level > E2FSCK_CURRENT_REV) { com_err(ctx->program_name, EXT2_ET_REV_TOO_HIGH, @@ -1012,15 +1136,26 @@ restart: * 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 @@ -1048,18 +1183,24 @@ 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; +#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; ehandler_init(fs->io); if (ctx->superblock) set_latch_flags(PR_LATCH_RELOC, PRL_LATCHED, 0); + ext2fs_mark_valid(fs); check_super_block(ctx); if (ctx->flags & E2F_FLAG_SIGNAL_MASK) fatal_error(ctx, 0); @@ -1070,21 +1211,6 @@ restart: 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 @@ -1100,8 +1226,48 @@ 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[16] >> 20; + else + journal_size = -1; + 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); + 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 (run_result == E2F_FLAG_RESTART) { printf(_("Restarting e2fsck from the beginning...\n")); retval = e2fsck_reset_context(ctx); @@ -1120,6 +1286,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"); @@ -1135,15 +1305,26 @@ restart: exit_value |= FSCK_REBOOT; } } - if (!ext2fs_test_valid(fs)) { + if (!ext2fs_test_valid(fs) || + ((exit_value & FSCK_CANCELED) && + (sb->s_state & EXT2_ERROR_FS))) { printf(_("\n%s: ********** WARNING: Filesystem still has " "errors **********\n\n"), ctx->device_name); exit_value |= FSCK_UNCORRECTED; exit_value &= ~FSCK_NONDESTRUCT; } - if (exit_value & FSCK_CANCELED) + if (exit_value & FSCK_CANCELED) { + int allow_cancellation; + + profile_get_boolean(ctx->profile, "options", + "allow_cancellation", 0, 0, + &allow_cancellation); exit_value &= ~FSCK_NONDESTRUCT; - else { + if (allow_cancellation && ext2fs_test_valid(fs) && + (sb->s_state & EXT2_VALID_FS) && + !(sb->s_state & EXT2_ERROR_FS)) + exit_value = 0; + } else { show_stats(ctx); if (!(ctx->options & E2F_OPT_READONLY)) { if (ext2fs_test_valid(fs)) { @@ -1153,23 +1334,28 @@ restart: } else sb->s_state &= ~EXT2_VALID_FS; sb->s_mnt_count = 0; - sb->s_lastcheck = time(NULL); + sb->s_lastcheck = ctx->now; ext2fs_mark_super_dirty(fs); } } + if (sb->s_feature_ro_compat & EXT4_FEATURE_RO_COMPAT_GDT_CSUM && + !(ctx->options & E2F_OPT_READONLY)) + ext2fs_set_gdt_csum(ctx->fs); + 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 ext2fs_close(fs); ctx->fs = NULL; free(ctx->filesystem_name); free(ctx->journal_name); - e2fsck_free_context(ctx); - -#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; }