X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=misc%2Ftune2fs.c;h=7d2d38d7d4b7b02c59335b576521201414842ec2;hb=28887533bb64db318e74c38cd9c0ad6d0bb2ced2;hp=c63ead646e87e103e86f96a5cb48e8d913ae354b;hpb=080e09b46ff1f6b00b26231868002e781e98adf2;p=tools%2Fe2fsprogs.git diff --git a/misc/tune2fs.c b/misc/tune2fs.c index c63ead6..7d2d38d 100644 --- a/misc/tune2fs.c +++ b/misc/tune2fs.c @@ -44,6 +44,7 @@ extern int optind; #include /* for strcasecmp() */ #else #define _BSD_SOURCE /* for inclusion of strcasecmp() via */ +#define _DEFAULT_SOURCE /* since glibc 2.20 _BSD_SOURCE is deprecated */ #endif #include #include @@ -113,25 +114,31 @@ struct blk_move { blk64_t new_loc; }; +errcode_t ext2fs_run_ext3_journal(ext2_filsys *fs); -static const char *please_fsck = N_("Please run e2fsck on the filesystem.\n"); +static const char *fsck_explain = N_("\nThis operation requires a freshly checked filesystem.\n"); + +static const char *please_fsck = N_("Please run e2fsck -f on the filesystem.\n"); static const char *please_dir_fsck = - N_("Please run e2fsck -D on the filesystem.\n"); + N_("Please run e2fsck -fD on the filesystem.\n"); #ifdef CONFIG_BUILD_FINDFS void do_findfs(int argc, char **argv); #endif +#ifdef CONFIG_JBD_DEBUG /* Enabled by configure --enable-jbd-debug */ +int journal_enable_debug = -1; +#endif + static void usage(void) { fprintf(stderr, - _("Usage: %s [-c max_mounts_count] [-e errors_behavior] " + _("Usage: %s [-c max_mounts_count] [-e errors_behavior] [-f] " "[-g group]\n" "\t[-i interval[d|m|w]] [-j] [-J journal_options] [-l]\n" "\t[-m reserved_blocks_percent] [-o [^]mount_options[,...]]\n" - "\t[-p mmp_update_interval] [-r reserved_blocks_count] " - "[-u user]\n" - "\t[-C mount_count] [-L volume_label] [-M last_mounted_dir]\n" + "\t[-r reserved_blocks_count] [-u user] [-C mount_count]\n" + "\t[-L volume_label] [-M last_mounted_dir]\n" "\t[-O [^]feature[,...]] [-Q quota_options]\n" "\t[-E extended-option[,...]] [-T last_check_time] " "[-U UUID]\n\t[-I new_inode_size] [-z undo_file] device\n"), @@ -147,9 +154,12 @@ static __u32 ok_features[3] = { EXT2_FEATURE_INCOMPAT_FILETYPE | EXT3_FEATURE_INCOMPAT_EXTENTS | EXT4_FEATURE_INCOMPAT_FLEX_BG | + EXT4_FEATURE_INCOMPAT_EA_INODE| EXT4_FEATURE_INCOMPAT_MMP | EXT4_FEATURE_INCOMPAT_64BIT | - EXT4_FEATURE_INCOMPAT_ENCRYPT, + EXT4_FEATURE_INCOMPAT_ENCRYPT | + EXT4_FEATURE_INCOMPAT_CSUM_SEED | + EXT4_FEATURE_INCOMPAT_LARGEDIR, /* R/O compat */ EXT2_FEATURE_RO_COMPAT_LARGE_FILE | EXT4_FEATURE_RO_COMPAT_HUGE_FILE| @@ -160,7 +170,8 @@ static __u32 ok_features[3] = { EXT4_FEATURE_RO_COMPAT_QUOTA | EXT4_FEATURE_RO_COMPAT_METADATA_CSUM | EXT4_FEATURE_RO_COMPAT_READONLY | - EXT4_FEATURE_RO_COMPAT_PROJECT + EXT4_FEATURE_RO_COMPAT_PROJECT | + EXT4_FEATURE_RO_COMPAT_VERITY }; static __u32 clear_ok_features[3] = { @@ -172,7 +183,8 @@ static __u32 clear_ok_features[3] = { EXT2_FEATURE_INCOMPAT_FILETYPE | EXT4_FEATURE_INCOMPAT_FLEX_BG | EXT4_FEATURE_INCOMPAT_MMP | - EXT4_FEATURE_INCOMPAT_64BIT, + EXT4_FEATURE_INCOMPAT_64BIT | + EXT4_FEATURE_INCOMPAT_CSUM_SEED, /* R/O compat */ EXT2_FEATURE_RO_COMPAT_LARGE_FILE | EXT4_FEATURE_RO_COMPAT_HUGE_FILE| @@ -180,6 +192,7 @@ static __u32 clear_ok_features[3] = { EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE| EXT4_FEATURE_RO_COMPAT_GDT_CSUM | EXT4_FEATURE_RO_COMPAT_QUOTA | + EXT4_FEATURE_RO_COMPAT_PROJECT | EXT4_FEATURE_RO_COMPAT_METADATA_CSUM | EXT4_FEATURE_RO_COMPAT_READONLY }; @@ -279,6 +292,12 @@ static int remove_journal_device(ext2_filsys fs) jsb = (journal_superblock_t *) buf; /* Find the filesystem UUID */ nr_users = ntohl(jsb->s_nr_users); + if (nr_users > JFS_USERS_MAX) { + fprintf(stderr, _("Journal superblock is corrupted, nr_users\n" + "is too high (%d).\n"), nr_users); + commit_remove_journal = 1; + goto no_valid_journal; + } if (!journal_user(fs->super->s_uuid, jsb->s_users, nr_users)) { fputs(_("Filesystem's UUID not found on journal device.\n"), @@ -404,14 +423,25 @@ static int update_mntopts(ext2_filsys fs, char *mntopts) return 0; } -static int check_fsck_needed(ext2_filsys fs) +static void check_fsck_needed(ext2_filsys fs, const char *prompt) { - if (fs->super->s_state & EXT2_VALID_FS) - return 0; - printf("\n%s\n", _(please_fsck)); - if (mount_flags & EXT2_MF_READONLY) - printf("%s", _("(and reboot afterwards!)\n")); - return 1; + /* Refuse to modify anything but a freshly checked valid filesystem. */ + if (!(fs->super->s_state & EXT2_VALID_FS) || + (fs->super->s_state & EXT2_ERROR_FS) || + (fs->super->s_lastcheck < fs->super->s_mtime)) { + puts(_(fsck_explain)); + puts(_(please_fsck)); + if (mount_flags & EXT2_MF_READONLY) + printf("%s", _("(and reboot afterwards!)\n")); + exit(1); + } + + /* Give the admin a few seconds to bail out of a dangerous op. */ + if (!getenv("TUNE2FS_FORCE_PROMPT") && (!isatty(0) || !isatty(1))) + return; + + puts(prompt); + proceed_question(5); } static void request_dir_fsck_afterwards(ext2_filsys fs) @@ -422,7 +452,8 @@ static void request_dir_fsck_afterwards(ext2_filsys fs) return; fsck_requested++; fs->super->s_state &= ~EXT2_VALID_FS; - printf("\n%s\n", _(please_dir_fsck)); + puts(_(fsck_explain)); + puts(_(please_dir_fsck)); if (mount_flags & EXT2_MF_READONLY) printf("%s", _("(and reboot afterwards!)\n")); } @@ -442,9 +473,6 @@ static void request_fsck_afterwards(ext2_filsys fs) static void convert_64bit(ext2_filsys fs, int direction) { - if (!direction) - return; - /* * Is resize2fs going to demand a fsck run? Might as well tell the * user now. @@ -469,64 +497,6 @@ static void convert_64bit(ext2_filsys fs, int direction) fprintf(stderr, _("' to disable 64-bit mode.\n")); } -/* Rewrite extents */ -static errcode_t rewrite_extents(ext2_filsys fs, ext2_ino_t ino, - struct ext2_inode *inode) -{ - ext2_extent_handle_t handle; - struct ext2fs_extent extent; - errcode_t errcode; - struct ext2_extent_info info; - - if (!(inode->i_flags & EXT4_EXTENTS_FL) || - !ext2fs_has_feature_metadata_csum(fs->super)) - return 0; - - errcode = ext2fs_extent_open(fs, ino, &handle); - if (errcode) - return errcode; - - errcode = ext2fs_extent_get(handle, EXT2_EXTENT_ROOT, &extent); - if (errcode) - goto out; - - do { - errcode = ext2fs_extent_get_info(handle, &info); - if (errcode) - break; - - /* - * If this is the first extent in an extent block that we - * haven't visited, rewrite the extent to force the ETB - * checksum to be rewritten. - */ - if (info.curr_entry == 1 && info.curr_level != 0 && - !(extent.e_flags & EXT2_EXTENT_FLAGS_SECOND_VISIT)) { - errcode = ext2fs_extent_replace(handle, 0, &extent); - if (errcode) - break; - } - - /* Skip to the end of a block of leaf nodes */ - if (extent.e_flags & EXT2_EXTENT_FLAGS_LEAF) { - errcode = ext2fs_extent_get(handle, - EXT2_EXTENT_LAST_SIB, - &extent); - if (errcode) - break; - } - - errcode = ext2fs_extent_get(handle, EXT2_EXTENT_NEXT, &extent); - } while (errcode == 0); - -out: - /* Ok if we run off the end */ - if (errcode == EXT2_ET_EXTENT_NO_NEXT) - errcode = 0; - ext2fs_extent_free(handle); - return errcode; -} - /* * Rewrite directory blocks with checksums */ @@ -698,114 +668,226 @@ static errcode_t rewrite_directory(ext2_filsys fs, ext2_ino_t dir, } /* - * Forcibly set checksums in all inodes. + * Context information that does not change across rewrite_one_inode() + * invocations. */ -static void rewrite_inodes(ext2_filsys fs) +struct rewrite_context { + ext2_filsys fs; + struct ext2_inode *zero_inode; + char *ea_buf; + int inode_size; +}; + +#define fatal_err(code, args...) \ + do { \ + com_err(__func__, code, args); \ + exit(1); \ + } while (0); + +static void update_ea_inode_hash(struct rewrite_context *ctx, ext2_ino_t ino, + struct ext2_inode *inode) { - int length = EXT2_INODE_SIZE(fs->super); - struct ext2_inode *inode, *zero; - char *ea_buf; - ext2_inode_scan scan; - errcode_t retval; - ext2_ino_t ino; - blk64_t file_acl_block; - int inode_dirty; + errcode_t retval; + ext2_file_t file; + __u32 hash; - if (fs->super->s_creator_os != EXT2_OS_LINUX) - return; + retval = ext2fs_file_open(ctx->fs, ino, 0, &file); + if (retval) + fatal_err(retval, "open ea_inode"); + retval = ext2fs_file_read(file, ctx->ea_buf, inode->i_size, + NULL); + if (retval) + fatal_err(retval, "read ea_inode"); + retval = ext2fs_file_close(file); + if (retval) + fatal_err(retval, "close ea_inode"); - retval = ext2fs_open_inode_scan(fs, 0, &scan); - if (retval) { - com_err("set_csum", retval, "while opening inode scan"); - exit(1); - } + hash = ext2fs_crc32c_le(ctx->fs->csum_seed, + (unsigned char *) ctx->ea_buf, inode->i_size); + ext2fs_set_ea_inode_hash(inode, hash); +} - retval = ext2fs_get_mem(length, &inode); - if (retval) { - com_err("set_csum", retval, "while allocating memory"); - exit(1); +static int update_xattr_entry_hashes(ext2_filsys fs, + struct ext2_ext_attr_entry *entry, + struct ext2_ext_attr_entry *end) +{ + int modified = 0; + errcode_t retval; + + while (entry < end && !EXT2_EXT_IS_LAST_ENTRY(entry)) { + if (entry->e_value_inum) { + retval = ext2fs_ext_attr_hash_entry2(fs, entry, NULL, + &entry->e_hash); + if (retval) + fatal_err(retval, "hash ea_inode entry"); + modified = 1; + } + entry = EXT2_EXT_ATTR_NEXT(entry); } + return modified; +} - retval = ext2fs_get_memzero(length, &zero); - if (retval) { - com_err("set_csum", retval, "while allocating memory"); - exit(1); +static void update_inline_xattr_hashes(struct rewrite_context *ctx, + struct ext2_inode_large *inode) +{ + struct ext2_ext_attr_entry *start, *end; + __u32 *ea_magic; + + if (inode->i_extra_isize == 0) + return; + + if (inode->i_extra_isize & 3 || + inode->i_extra_isize > ctx->inode_size - EXT2_GOOD_OLD_INODE_SIZE) + fatal_err(EXT2_ET_INODE_CORRUPTED, "bad i_extra_isize") + + ea_magic = (__u32 *)((char *)inode + EXT2_GOOD_OLD_INODE_SIZE + + inode->i_extra_isize); + if (*ea_magic != EXT2_EXT_ATTR_MAGIC) + return; + + start = (struct ext2_ext_attr_entry *)(ea_magic + 1); + end = (struct ext2_ext_attr_entry *)((char *)inode + ctx->inode_size); + + update_xattr_entry_hashes(ctx->fs, start, end); +} + +static void update_block_xattr_hashes(struct rewrite_context *ctx, + char *block_buf) +{ + struct ext2_ext_attr_header *header; + struct ext2_ext_attr_entry *start, *end; + + header = (struct ext2_ext_attr_header *)block_buf; + if (header->h_magic != EXT2_EXT_ATTR_MAGIC) + return; + + start = (struct ext2_ext_attr_entry *)(header+1); + end = (struct ext2_ext_attr_entry *)(block_buf + ctx->fs->blocksize); + + if (update_xattr_entry_hashes(ctx->fs, start, end)) + ext2fs_ext_attr_block_rehash(header, end); +} + +static void rewrite_one_inode(struct rewrite_context *ctx, ext2_ino_t ino, + struct ext2_inode *inode) +{ + blk64_t file_acl_block; + errcode_t retval; + + if (!ext2fs_test_inode_bitmap2(ctx->fs->inode_map, ino)) { + if (!memcmp(inode, ctx->zero_inode, ctx->inode_size)) + return; + memset(inode, 0, ctx->inode_size); } - retval = ext2fs_get_mem(fs->blocksize, &ea_buf); - if (retval) { - com_err("set_csum", retval, "while allocating memory"); - exit(1); + if (inode->i_flags & EXT4_EA_INODE_FL) + update_ea_inode_hash(ctx, ino, inode); + + if (ctx->inode_size != EXT2_GOOD_OLD_INODE_SIZE) + update_inline_xattr_hashes(ctx, + (struct ext2_inode_large *)inode); + + retval = ext2fs_write_inode_full(ctx->fs, ino, inode, ctx->inode_size); + if (retval) + fatal_err(retval, "while writing inode"); + + retval = ext2fs_fix_extents_checksums(ctx->fs, ino, inode); + if (retval) + fatal_err(retval, "while rewriting extents"); + + if (LINUX_S_ISDIR(inode->i_mode) && + ext2fs_inode_has_valid_blocks2(ctx->fs, inode)) { + retval = rewrite_directory(ctx->fs, ino, inode); + if (retval) + fatal_err(retval, "while rewriting directories"); } - do { - retval = ext2fs_get_next_inode_full(scan, &ino, inode, length); - if (retval) { - com_err("set_csum", retval, "while getting next inode"); - exit(1); - } - if (!ino) - break; - if (ext2fs_test_inode_bitmap2(fs->inode_map, ino)) { - inode_dirty = 1; - } else { - if (memcmp(inode, zero, length) != 0) { - memset(inode, 0, length); - inode_dirty = 1; - } else { - inode_dirty = 0; - } - } + file_acl_block = ext2fs_file_acl_block(ctx->fs, inode); + if (!file_acl_block) + return; - if (inode_dirty) { - retval = ext2fs_write_inode_full(fs, ino, inode, - length); - if (retval) { - com_err("set_csum", retval, "while writing " - "inode"); - exit(1); - } - } + retval = ext2fs_read_ext_attr3(ctx->fs, file_acl_block, ctx->ea_buf, + ino); + if (retval) + fatal_err(retval, "while rewriting extended attribute"); - retval = rewrite_extents(fs, ino, inode); - if (retval) { - com_err("rewrite_extents", retval, - "while rewriting extents"); - exit(1); - } + update_block_xattr_hashes(ctx, ctx->ea_buf); + retval = ext2fs_write_ext_attr3(ctx->fs, file_acl_block, ctx->ea_buf, + ino); + if (retval) + fatal_err(retval, "while rewriting extended attribute"); +} - if (LINUX_S_ISDIR(inode->i_mode) && - ext2fs_inode_has_valid_blocks2(fs, inode)) { - retval = rewrite_directory(fs, ino, inode); - if (retval) { - com_err("rewrite_directory", retval, - "while rewriting directories"); - exit(1); - } - } +/* + * Forcibly set checksums in all inodes. + */ +static void rewrite_inodes(ext2_filsys fs) +{ + ext2_inode_scan scan; + errcode_t retval; + ext2_ino_t ino; + struct ext2_inode *inode; + int pass; + struct rewrite_context ctx = { + .fs = fs, + .inode_size = EXT2_INODE_SIZE(fs->super), + }; + + if (fs->super->s_creator_os == EXT2_OS_HURD) + return; - file_acl_block = ext2fs_file_acl_block(fs, inode); - if (!file_acl_block) - continue; - retval = ext2fs_read_ext_attr3(fs, file_acl_block, ea_buf, ino); - if (retval) { - com_err("rewrite_eablock", retval, - "while rewriting extended attribute"); - exit(1); - } - retval = ext2fs_write_ext_attr3(fs, file_acl_block, ea_buf, - ino); - if (retval) { - com_err("rewrite_eablock", retval, - "while rewriting extended attribute"); - exit(1); - } - } while (ino); + retval = ext2fs_get_mem(ctx.inode_size, &inode); + if (retval) + fatal_err(retval, "while allocating memory"); + + retval = ext2fs_get_memzero(ctx.inode_size, &ctx.zero_inode); + if (retval) + fatal_err(retval, "while allocating memory"); - ext2fs_free_mem(&zero); + retval = ext2fs_get_mem(64 * 1024, &ctx.ea_buf); + if (retval) + fatal_err(retval, "while allocating memory"); + + /* + * Extended attribute inodes have a lookup hash that needs to be + * recalculated with the new csum_seed. Other inodes referencing xattr + * inodes need this value to be up to date. That's why we do two passes: + * + * pass 1: update xattr inodes to update their lookup hash as well as + * other checksums. + * + * pass 2: go over other inodes to update their checksums. + */ + if (ext2fs_has_feature_ea_inode(fs->super)) + pass = 1; + else + pass = 2; + for (;pass <= 2; pass++) { + retval = ext2fs_open_inode_scan(fs, 0, &scan); + if (retval) + fatal_err(retval, "while opening inode scan"); + + do { + retval = ext2fs_get_next_inode_full(scan, &ino, inode, + ctx.inode_size); + if (retval) + fatal_err(retval, "while getting next inode"); + if (!ino) + break; + + if (((pass == 1) && + (inode->i_flags & EXT4_EA_INODE_FL)) || + ((pass == 2) && + !(inode->i_flags & EXT4_EA_INODE_FL))) + rewrite_one_inode(&ctx, ino, inode); + } while (ino); + + ext2fs_close_inode_scan(scan); + } + + ext2fs_free_mem(&ctx.zero_inode); + ext2fs_free_mem(&ctx.ea_buf); ext2fs_free_mem(&inode); - ext2fs_free_mem(&ea_buf); - ext2fs_close_inode_scan(scan); } static void rewrite_metadata_checksums(ext2_filsys fs) @@ -818,11 +900,8 @@ static void rewrite_metadata_checksums(ext2_filsys fs) for (i = 0; i < fs->group_desc_count; i++) ext2fs_group_desc_csum_set(fs, i); retval = ext2fs_read_bitmaps(fs); - if (retval) { - com_err("rewrite_metadata_checksums", retval, - "while reading bitmaps"); - exit(1); - } + if (retval) + fatal_err(retval, "while reading bitmaps"); rewrite_inodes(fs); ext2fs_mark_ib_dirty(fs); ext2fs_mark_bb_dirty(fs); @@ -949,6 +1028,15 @@ static errcode_t disable_uninit_bg(ext2_filsys fs, __u32 csum_feature_flag) return 0; } +static void +try_confirm_csum_seed_support(void) +{ + if (access("/sys/fs/ext4/features/metadata_csum_seed", R_OK)) + fputs(_("WARNING: Could not confirm kernel support for " + "metadata_csum_seed.\n This requires Linux >= " + "v4.4.\n"), stderr); +} + /* * Update the feature set as provided by the user. */ @@ -1136,8 +1224,8 @@ mmp_error: if (FEATURE_ON(E2P_FEATURE_RO_INCOMPAT, EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) { - if (check_fsck_needed(fs)) - exit(1); + check_fsck_needed(fs, + _("Enabling checksums could take some time.")); if (mount_flags & EXT2_MF_MOUNTED) { fputs(_("Cannot enable metadata_csum on a mounted " "filesystem!\n"), stderr); @@ -1177,8 +1265,8 @@ mmp_error: EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) { __u32 test_features[3]; - if (check_fsck_needed(fs)) - exit(1); + check_fsck_needed(fs, + _("Disabling checksums could take some time.")); if (mount_flags & EXT2_MF_MOUNTED) { fputs(_("Cannot disable metadata_csum on a mounted " "filesystem!\n"), stderr); @@ -1214,6 +1302,8 @@ mmp_error: */ old_features[E2P_FEATURE_RO_INCOMPAT] |= EXT4_FEATURE_RO_COMPAT_GDT_CSUM; + fs->super->s_checksum_seed = 0; + ext2fs_clear_feature_csum_seed(fs->super); } if (FEATURE_ON(E2P_FEATURE_RO_INCOMPAT, @@ -1279,15 +1369,23 @@ mmp_error: } if (FEATURE_ON(E2P_FEATURE_RO_INCOMPAT, - EXT4_FEATURE_RO_COMPAT_PROJECT)) { - if (!Q_flag && !ext2fs_has_feature_quota(sb)) - fputs(_("\nWarning: enabled project without quota together\n"), - stderr); + EXT4_FEATURE_RO_COMPAT_PROJECT)) { + if (fs->super->s_inode_size == EXT2_GOOD_OLD_INODE_SIZE) { + fprintf(stderr, _("Cannot enable project feature; " + "inode size too small.\n")); + exit(1); + } Q_flag = 1; quota_enable[PRJQUOTA] = QOPT_ENABLE; } if (FEATURE_OFF(E2P_FEATURE_RO_INCOMPAT, + EXT4_FEATURE_RO_COMPAT_PROJECT)) { + Q_flag = 1; + quota_enable[PRJQUOTA] = QOPT_DISABLE; + } + + if (FEATURE_OFF(E2P_FEATURE_RO_INCOMPAT, EXT4_FEATURE_RO_COMPAT_QUOTA)) { /* * Set the Q_flag here and handle the quota options in the code @@ -1303,12 +1401,51 @@ mmp_error: } if (FEATURE_ON(E2P_FEATURE_INCOMPAT, EXT4_FEATURE_INCOMPAT_ENCRYPT)) { + if (ext2fs_has_feature_casefold(sb)) { + fputs(_("Cannot enable encrypt feature on filesystems " + "with the encoding feature enabled.\n"), + stderr); + return 1; + } fs->super->s_encrypt_algos[0] = EXT4_ENCRYPTION_MODE_AES_256_XTS; fs->super->s_encrypt_algos[1] = EXT4_ENCRYPTION_MODE_AES_256_CTS; } + if (FEATURE_ON(E2P_FEATURE_INCOMPAT, + EXT4_FEATURE_INCOMPAT_CSUM_SEED)) { + if (!ext2fs_has_feature_metadata_csum(sb)) { + fputs(_("Setting feature 'metadata_csum_seed' " + "is only supported\non filesystems with " + "the metadata_csum feature enabled.\n"), + stderr); + return 1; + } + try_confirm_csum_seed_support(); + fs->super->s_checksum_seed = fs->csum_seed; + } + + if (FEATURE_OFF(E2P_FEATURE_INCOMPAT, + EXT4_FEATURE_INCOMPAT_CSUM_SEED)) { + __le32 uuid_seed; + + uuid_seed = ext2fs_crc32c_le(~0, fs->super->s_uuid, + sizeof(fs->super->s_uuid)); + if (fs->super->s_checksum_seed != uuid_seed) { + if (mount_flags & (EXT2_MF_BUSY|EXT2_MF_MOUNTED)) { + fputs(_("UUID has changed since enabling " + "metadata_csum. Filesystem must be unmounted " + "\nto safely rewrite all metadata to match the new UUID.\n"), + stderr); + return 1; + } + check_fsck_needed(fs, _("Recalculating checksums " + "could take some time.")); + rewrite_checksums = 1; + } + } + if (sb->s_rev_level == EXT2_GOOD_OLD_REV && (sb->s_feature_compat || sb->s_feature_ro_compat || sb->s_feature_incompat)) @@ -1419,10 +1556,12 @@ err: static void handle_quota_options(ext2_filsys fs) { + errcode_t retval; quota_ctx_t qctx; ext2_ino_t qf_ino; enum quota_type qtype; - int enable = 0; + unsigned int qtype_bits = 0; + int need_dirty = 0; for (qtype = 0 ; qtype < MAXQUOTAS; qtype++) if (quota_enable[qtype] != 0) @@ -1431,47 +1570,91 @@ static void handle_quota_options(ext2_filsys fs) /* Nothing to do. */ return; - quota_init_context(&qctx, fs, QUOTA_ALL_BIT); - for (qtype = 0 ; qtype < MAXQUOTAS; qtype++) { - if (quota_enable[qtype] == QOPT_ENABLE) { - enable = 1; - break; - } + if (quota_enable[PRJQUOTA] == QOPT_ENABLE && + fs->super->s_inode_size == EXT2_GOOD_OLD_INODE_SIZE) { + fprintf(stderr, _("Cannot enable project quota; " + "inode size too small.\n")); + exit(1); } - if (enable) + + for (qtype = 0; qtype < MAXQUOTAS; qtype++) { + if (quota_enable[qtype] == QOPT_ENABLE) + qtype_bits |= 1 << qtype; + } + + retval = quota_init_context(&qctx, fs, qtype_bits); + if (retval) { + com_err(program_name, retval, + _("while initializing quota context in support library")); + exit(1); + } + + if (qtype_bits) quota_compute_usage(qctx); for (qtype = 0 ; qtype < MAXQUOTAS; qtype++) { if (quota_enable[qtype] == QOPT_ENABLE && *quota_sb_inump(fs->super, qtype) == 0) { - if ((qf_ino = quota_file_exists(fs, qtype)) > 0) - quota_update_limits(qctx, qf_ino, qtype); - quota_write_inode(qctx, 1 << qtype); + if ((qf_ino = quota_file_exists(fs, qtype)) > 0) { + retval = quota_update_limits(qctx, qf_ino, + qtype); + if (retval) { + com_err(program_name, retval, + _("while updating quota limits (%d)"), + qtype); + exit(1); + } + } + retval = quota_write_inode(qctx, 1 << qtype); + if (retval) { + com_err(program_name, retval, + _("while writing quota file (%d)"), + qtype); + exit(1); + } + /* Enable Quota feature if one of quota enabled */ + if (!ext2fs_has_feature_quota(fs->super)) { + ext2fs_set_feature_quota(fs->super); + need_dirty = 1; + } + if (qtype == PRJQUOTA && + !ext2fs_has_feature_project(fs->super)) { + ext2fs_set_feature_project(fs->super); + need_dirty = 1; + } } else if (quota_enable[qtype] == QOPT_DISABLE) { - quota_remove_inode(fs, qtype); + retval = quota_remove_inode(fs, qtype); + if (retval) { + com_err(program_name, retval, + _("while removing quota file (%d)"), + qtype); + exit(1); + } + if (qtype == PRJQUOTA) { + ext2fs_clear_feature_project(fs->super); + need_dirty = 1; + } } } quota_release_context(&qctx); - - if (enable) { - ext2fs_set_feature_quota(fs->super); - ext2fs_mark_super_dirty(fs); - } else { + /* Clear Quota feature if all quota types disabled. */ + if (!qtype_bits) { for (qtype = 0 ; qtype < MAXQUOTAS; qtype++) - if (*quota_sb_inump(fs->super, qtype) != 0) + if (*quota_sb_inump(fs->super, qtype)) break; if (qtype == MAXQUOTAS) { - fs->super->s_feature_ro_compat &= - ~EXT4_FEATURE_RO_COMPAT_QUOTA; - ext2fs_mark_super_dirty(fs); + ext2fs_clear_feature_quota(fs->super); + need_dirty = 1; } - } + } + if (need_dirty) + ext2fs_mark_super_dirty(fs); return; } -static int option_handle_function(char *token, void *data) +static int option_handle_function(char *token) { if (strncmp(token, "usr", 3) == 0) { quota_enable[USRQUOTA] = QOPT_ENABLE; @@ -1719,8 +1902,7 @@ static void parse_tune2fs_options(int argc, char **argv) break; case 'Q': Q_flag = 1; - ret = parse_quota_opts(optarg, option_handle_function, - NULL); + ret = parse_quota_opts(optarg, option_handle_function); if (ret) exit(1); open_flag = EXT2_FLAG_RW; @@ -1891,6 +2073,10 @@ static int parse_extended_opts(ext2_filsys fs, const char *opts) intv); fs->super->s_mmp_update_interval = intv; ext2fs_mark_super_dirty(fs); + } else if (!strcmp(token, "force_fsck")) { + fs->super->s_state |= EXT2_ERROR_FS; + printf(_("Setting filesystem error flag to force fsck.\n")); + ext2fs_mark_super_dirty(fs); } else if (!strcmp(token, "test_fs")) { fs->super->s_flags |= EXT2_FLAGS_TEST_FILESYS; printf("Setting test filesystem flag\n"); @@ -1970,8 +2156,10 @@ static int parse_extended_opts(ext2_filsys fs, const char *opts) "\tclear_mmp\n" "\thash_alg=\n" "\tmount_opts=\n" + "\tmmp_update_interval=\n" "\tstride=\n" "\tstripe_width=\n" + "\tforce_fsck\n" "\ttest_fs\n" "\t^test_fs\n")); free(buf); @@ -2621,6 +2809,11 @@ fs_update_journal_user(struct ext2_super_block *sb, __u8 old_uuid[UUID_SIZE]) jsb = (journal_superblock_t *) buf; /* Find the filesystem UUID */ nr_users = ntohl(jsb->s_nr_users); + if (nr_users > JFS_USERS_MAX) { + fprintf(stderr, _("Journal superblock is corrupted, nr_users\n" + "is too high (%d).\n"), nr_users); + return EXT2_ET_CORRUPT_JOURNAL_SB; + } j_uuid = journal_user(old_uuid, jsb->s_users, nr_users); if (j_uuid == NULL) { @@ -2753,6 +2946,8 @@ retry_open: rc = 1; goto closefs; } + check_fsck_needed(fs, + _("Resizing inodes could take some time.")); /* * If inode resize is requested use the * Undo I/O manager @@ -2793,6 +2988,37 @@ retry_open: rc = 1; goto closefs; } + +#ifdef NO_RECOVERY + /* Warn if file system needs recovery and it is opened for writing. */ + if ((open_flag & EXT2_FLAG_RW) && !(mount_flags & EXT2_MF_MOUNTED) && + (sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL) && + (sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER)) { + fprintf(stderr, +_("Warning: The journal is dirty. You may wish to replay the journal like:\n\n" + "\te2fsck -E journal_only %s\n\n" + "then rerun this command. Otherwise, any changes made may be overwritten\n" + "by journal recovery.\n"), device_name); + } +#else + /* Recover the journal if possible. */ + if ((open_flag & EXT2_FLAG_RW) && !(mount_flags & (EXT2_MF_BUSY | EXT2_MF_MOUNTED)) && + ext2fs_has_feature_journal_needs_recovery(fs->super)) { + errcode_t err; + + printf(_("Recovering journal.\n")); + err = ext2fs_run_ext3_journal(&fs); + if (err) { + com_err("tune2fs", err, "while recovering journal.\n"); + printf(_("Please run e2fsck -fy %s.\n"), argv[1]); + if (fs) + ext2fs_close_free(&fs); + exit(1); + } + sb = fs->super; + } +#endif + /* Normally we only need to write out the superblock */ fs->flags |= EXT2_FLAG_SUPER_ONLY; @@ -2948,19 +3174,35 @@ retry_open: char buf[SUPERBLOCK_SIZE] __attribute__ ((aligned(8))); __u8 old_uuid[UUID_SIZE]; + if (!ext2fs_has_feature_csum_seed(fs->super) && + (ext2fs_has_feature_metadata_csum(fs->super) || + ext2fs_has_feature_ea_inode(fs->super))) { + check_fsck_needed(fs, + _("Setting the UUID on this " + "filesystem could take some time.")); + rewrite_checksums = 1; + } + if (ext2fs_has_group_desc_csum(fs)) { /* - * Changing the UUID requires rewriting all metadata, - * which can race with a mounted fs. Don't allow that. + * Changing the UUID on a metadata_csum FS requires + * rewriting all metadata, which can race with a + * mounted fs. Don't allow that unless we're saving + * the checksum seed. */ - if ((mount_flags & EXT2_MF_MOUNTED) && !f_flag) { + if ((mount_flags & EXT2_MF_MOUNTED) && + !ext2fs_has_feature_csum_seed(fs->super) && + ext2fs_has_feature_metadata_csum(fs->super)) { fputs(_("The UUID may only be " "changed when the filesystem is " "unmounted.\n"), stderr); + fputs(_("If you only use kernels newer than " + "v4.4, run 'tune2fs -O " + "metadata_csum_seed' and re-run this " + "command.\n"), stderr); + try_confirm_csum_seed_support(); exit(1); } - if (check_fsck_needed(fs)) - exit(1); /* * Determine if the block group checksums are @@ -3018,8 +3260,6 @@ retry_open: } ext2fs_mark_super_dirty(fs); - if (ext2fs_has_feature_metadata_csum(fs->super)) - rewrite_checksums = 1; } if (I_flag) { @@ -3084,17 +3324,6 @@ retry_open: free(ext_mount_opts); } - /* Warn if file system needs recovery and it is opened for writing. */ - if ((open_flag & EXT2_FLAG_RW) && !(mount_flags & EXT2_MF_MOUNTED) && - (sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL) && - (sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER)) { - fprintf(stderr, -_("Warning: The journal is dirty. You may wish to replay the journal like:\n\n" - "\te2fsck -E journal_only %s\n\n" - "then rerun this command. Otherwise, any changes made may be overwritten\n" - "by journal recovery.\n"), device_name); - } - free(device_name); remove_error_table(&et_ext2_error_table); @@ -3106,6 +3335,7 @@ closefs: #endif } - convert_64bit(fs, feature_64bit); + if (feature_64bit) + convert_64bit(fs, feature_64bit); return (ext2fs_close_free(&fs) ? 1 : 0); }