X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=misc%2Ftune2fs.c;h=b11b2e3f30c8ec3b0470a0f61e75f16061594876;hb=1dc5c3928d2766bb700ac11ad09ffb796bfe3ff6;hp=9ba32a1c1a381677798af098bac5352dc3816c79;hpb=1c358e6e127b605d29e535e575994d3583a19c72;p=tools%2Fe2fsprogs.git diff --git a/misc/tune2fs.c b/misc/tune2fs.c index 9ba32a1..b11b2e3 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 @@ -54,16 +55,17 @@ extern int optind; #include "ext2fs/ext2_fs.h" #include "ext2fs/ext2fs.h" +#include "ext2fs/kernel-jbd.h" #include "et/com_err.h" +#include "support/plausible.h" +#include "support/quotaio.h" #include "uuid/uuid.h" #include "e2p/e2p.h" -#include "jfs_user.h" #include "util.h" #include "blkid/blkid.h" -#include "quota/quotaio.h" #include "../version.h" -#include "nls-enable.h" +#include "support/nls-enable.h" #define QOPT_ENABLE (1) #define QOPT_DISABLE (-1) @@ -94,7 +96,11 @@ static int stride_set, stripe_width_set; static char *extended_cmd; static unsigned long new_inode_size; static char *ext_mount_opts; -static int usrquota, grpquota; +static int quota_enable[MAXQUOTAS]; +static int rewrite_checksums; +static int feature_64bit; +static int fsck_requested; +static char *undo_file; int journal_size, journal_flags; char *journal_device; @@ -108,29 +114,35 @@ 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 -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[,...]] [-p mmp_update_interval]\n" - "\t[-r reserved_blocks_count] [-u user] [-C mount_count] " - "[-L volume_label]\n" - "\t[-M last_mounted_dir] [-O [^]feature[,...]]\n" -#ifdef CONFIG_QUOTA - "\t[-Q quota_options]\n" -#endif + "\t[-m reserved_blocks_percent] [-o [^]mount_options[,...]]\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 ] device\n"), program_name); + "[-U UUID]\n\t[-I new_inode_size] [-z undo_file] device\n"), + program_name); exit(1); } @@ -142,17 +154,21 @@ static __u32 ok_features[3] = { EXT2_FEATURE_INCOMPAT_FILETYPE | EXT3_FEATURE_INCOMPAT_EXTENTS | EXT4_FEATURE_INCOMPAT_FLEX_BG | - EXT4_FEATURE_INCOMPAT_MMP, + EXT4_FEATURE_INCOMPAT_MMP | + EXT4_FEATURE_INCOMPAT_64BIT | + EXT4_FEATURE_INCOMPAT_ENCRYPT | + EXT4_FEATURE_INCOMPAT_CSUM_SEED, /* R/O compat */ EXT2_FEATURE_RO_COMPAT_LARGE_FILE | EXT4_FEATURE_RO_COMPAT_HUGE_FILE| EXT4_FEATURE_RO_COMPAT_DIR_NLINK| EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE| EXT4_FEATURE_RO_COMPAT_GDT_CSUM | -#ifdef CONFIG_QUOTA + EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER | EXT4_FEATURE_RO_COMPAT_QUOTA | -#endif - EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER + EXT4_FEATURE_RO_COMPAT_METADATA_CSUM | + EXT4_FEATURE_RO_COMPAT_READONLY | + EXT4_FEATURE_RO_COMPAT_PROJECT }; static __u32 clear_ok_features[3] = { @@ -163,18 +179,63 @@ static __u32 clear_ok_features[3] = { /* Incompat */ EXT2_FEATURE_INCOMPAT_FILETYPE | EXT4_FEATURE_INCOMPAT_FLEX_BG | - EXT4_FEATURE_INCOMPAT_MMP, + EXT4_FEATURE_INCOMPAT_MMP | + EXT4_FEATURE_INCOMPAT_64BIT | + EXT4_FEATURE_INCOMPAT_CSUM_SEED, /* R/O compat */ EXT2_FEATURE_RO_COMPAT_LARGE_FILE | EXT4_FEATURE_RO_COMPAT_HUGE_FILE| EXT4_FEATURE_RO_COMPAT_DIR_NLINK| EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE| -#ifdef CONFIG_QUOTA + EXT4_FEATURE_RO_COMPAT_GDT_CSUM | EXT4_FEATURE_RO_COMPAT_QUOTA | -#endif - EXT4_FEATURE_RO_COMPAT_GDT_CSUM + EXT4_FEATURE_RO_COMPAT_PROJECT | + EXT4_FEATURE_RO_COMPAT_METADATA_CSUM | + EXT4_FEATURE_RO_COMPAT_READONLY }; +/** + * Try to get journal super block if any + */ +static int get_journal_sb(ext2_filsys jfs, char buf[SUPERBLOCK_SIZE]) +{ + int retval; + journal_superblock_t *jsb; + + if (!ext2fs_has_feature_journal_dev(jfs->super)) { + return EXT2_ET_UNSUPP_FEATURE; + } + + /* Get the journal superblock */ + if ((retval = io_channel_read_blk64(jfs->io, + ext2fs_journal_sb_start(jfs->blocksize), -SUPERBLOCK_SIZE, buf))) { + com_err(program_name, retval, "%s", + _("while reading journal superblock")); + return retval; + } + + jsb = (journal_superblock_t *) buf; + if ((jsb->s_header.h_magic != (unsigned)ntohl(JFS_MAGIC_NUMBER)) || + (jsb->s_header.h_blocktype != (unsigned)ntohl(JFS_SUPERBLOCK_V2))) { + fputs(_("Journal superblock not found!\n"), stderr); + return EXT2_ET_BAD_MAGIC; + } + + return 0; +} + +static __u8 *journal_user(__u8 uuid[UUID_SIZE], __u8 s_users[JFS_USERS_SIZE], + int nr_users) +{ + int i; + for (i = 0; i < nr_users; i++) { + if (memcmp(uuid, &s_users[i * UUID_SIZE], UUID_SIZE) == 0) + return &s_users[i * UUID_SIZE]; + } + + return NULL; +} + /* * Remove an external journal from the filesystem */ @@ -182,7 +243,7 @@ static int remove_journal_device(ext2_filsys fs) { char *journal_path; ext2_filsys jfs; - char buf[1024]; + char buf[SUPERBLOCK_SIZE] __attribute__ ((aligned(8))); journal_superblock_t *jsb; int i, nr_users; errcode_t retval; @@ -217,34 +278,19 @@ static int remove_journal_device(ext2_filsys fs) _("while trying to open external journal")); goto no_valid_journal; } - if (!(jfs->super->s_feature_incompat & - EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)) { - fprintf(stderr, _("%s is not a journal device.\n"), - journal_path); - goto no_valid_journal; - } - /* Get the journal superblock */ - if ((retval = io_channel_read_blk64(jfs->io, 1, -1024, buf))) { - com_err(program_name, retval, "%s", - _("while reading journal superblock")); + if ((retval = get_journal_sb(jfs, buf))) { + if (retval == EXT2_ET_UNSUPP_FEATURE) + fprintf(stderr, _("%s is not a journal device.\n"), + journal_path); goto no_valid_journal; } jsb = (journal_superblock_t *) buf; - if ((jsb->s_header.h_magic != (unsigned)ntohl(JFS_MAGIC_NUMBER)) || - (jsb->s_header.h_blocktype != (unsigned)ntohl(JFS_SUPERBLOCK_V2))) { - fputs(_("Journal superblock not found!\n"), stderr); - goto no_valid_journal; - } - /* Find the filesystem UUID */ nr_users = ntohl(jsb->s_nr_users); - for (i = 0; i < nr_users; i++) { - if (memcmp(fs->super->s_uuid, &jsb->s_users[i * 16], 16) == 0) - break; - } - if (i >= nr_users) { + + if (!journal_user(fs->super->s_uuid, jsb->s_users, nr_users)) { fputs(_("Filesystem's UUID not found on journal device.\n"), stderr); commit_remove_journal = 1; @@ -256,7 +302,10 @@ static int remove_journal_device(ext2_filsys fs) jsb->s_nr_users = htonl(nr_users); /* Write back the journal superblock */ - if ((retval = io_channel_write_blk64(jfs->io, 1, -1024, buf))) { + retval = io_channel_write_blk64(jfs->io, + ext2fs_journal_sb_start(fs->blocksize), + -SUPERBLOCK_SIZE, buf); + if (retval) { com_err(program_name, retval, "while writing journal superblock."); goto no_valid_journal; @@ -272,6 +321,7 @@ no_valid_journal: return 1; } fs->super->s_journal_dev = 0; + memset(fs->super->s_jnl_blocks, 0, sizeof(fs->super->s_jnl_blocks)); uuid_clear(fs->super->s_journal_uuid); ext2fs_mark_super_dirty(fs); fputs(_("Journal removed\n"), stdout); @@ -341,6 +391,7 @@ static errcode_t remove_journal_inode(ext2_filsys fs) return retval; } fs->super->s_journal_inum = 0; + memset(fs->super->s_jnl_blocks, 0, sizeof(fs->super->s_jnl_blocks)); ext2fs_mark_super_dirty(fs); return 0; @@ -363,14 +414,39 @@ 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)); + /* 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) +{ + static int requested; + + if (requested++) + return; + fsck_requested++; + fs->super->s_state &= ~EXT2_VALID_FS; + puts(_(fsck_explain)); + puts(_(please_dir_fsck)); if (mount_flags & EXT2_MF_READONLY) printf("%s", _("(and reboot afterwards!)\n")); - return 1; } static void request_fsck_afterwards(ext2_filsys fs) @@ -379,23 +455,539 @@ static void request_fsck_afterwards(ext2_filsys fs) if (requested++) return; + fsck_requested++; fs->super->s_state &= ~EXT2_VALID_FS; printf("\n%s\n", _(please_fsck)); if (mount_flags & EXT2_MF_READONLY) printf("%s", _("(and reboot afterwards!)\n")); } +static void convert_64bit(ext2_filsys fs, int direction) +{ + /* + * Is resize2fs going to demand a fsck run? Might as well tell the + * user now. + */ + if (!fsck_requested && + ((fs->super->s_state & EXT2_ERROR_FS) || + !(fs->super->s_state & EXT2_VALID_FS) || + fs->super->s_lastcheck < fs->super->s_mtime)) + request_fsck_afterwards(fs); + if (fsck_requested) + fprintf(stderr, _("After running e2fsck, please run `resize2fs %s %s"), + direction > 0 ? "-b" : "-s", fs->device_name); + else + fprintf(stderr, _("Please run `resize2fs %s %s"), + direction > 0 ? "-b" : "-s", fs->device_name); + + if (undo_file) + fprintf(stderr, _(" -z \"%s\""), undo_file); + if (direction > 0) + fprintf(stderr, _("' to enable 64-bit mode.\n")); + else + 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 + */ +struct rewrite_dir_context { + char *buf; + errcode_t errcode; + ext2_ino_t dir; + int is_htree; +}; + +static int rewrite_dir_block(ext2_filsys fs, + blk64_t *blocknr, + e2_blkcnt_t blockcnt EXT2FS_ATTR((unused)), + blk64_t ref_block EXT2FS_ATTR((unused)), + int ref_offset EXT2FS_ATTR((unused)), + void *priv_data) +{ + struct ext2_dx_countlimit *dcl = NULL; + struct rewrite_dir_context *ctx = priv_data; + int dcl_offset, changed = 0; + + ctx->errcode = ext2fs_read_dir_block4(fs, *blocknr, ctx->buf, 0, + ctx->dir); + if (ctx->errcode) + return BLOCK_ABORT; + + /* if htree node... */ + if (ctx->is_htree) + ext2fs_get_dx_countlimit(fs, (struct ext2_dir_entry *)ctx->buf, + &dcl, &dcl_offset); + if (dcl) { + if (!ext2fs_has_feature_metadata_csum(fs->super)) { + /* Ensure limit is the max size */ + int max_entries = (fs->blocksize - dcl_offset) / + sizeof(struct ext2_dx_entry); + if (ext2fs_le16_to_cpu(dcl->limit) != max_entries) { + changed = 1; + dcl->limit = ext2fs_cpu_to_le16(max_entries); + } + } else { + /* If htree block is full then rebuild the dir */ + if (ext2fs_le16_to_cpu(dcl->count) == + ext2fs_le16_to_cpu(dcl->limit)) { + request_dir_fsck_afterwards(fs); + return 0; + } + /* + * Ensure dcl->limit is small enough to leave room for + * the checksum tail. + */ + int max_entries = (fs->blocksize - (dcl_offset + + sizeof(struct ext2_dx_tail))) / + sizeof(struct ext2_dx_entry); + if (ext2fs_le16_to_cpu(dcl->limit) != max_entries) + dcl->limit = ext2fs_cpu_to_le16(max_entries); + /* Always rewrite checksum */ + changed = 1; + } + } else { + unsigned int rec_len, name_size; + char *top = ctx->buf + fs->blocksize; + struct ext2_dir_entry *de = (struct ext2_dir_entry *)ctx->buf; + struct ext2_dir_entry *last_de = NULL, *penultimate_de = NULL; + + /* Find last and penultimate dirent */ + while ((char *)de < top) { + penultimate_de = last_de; + last_de = de; + ctx->errcode = ext2fs_get_rec_len(fs, de, &rec_len); + if (!ctx->errcode && !rec_len) + ctx->errcode = EXT2_ET_DIR_CORRUPTED; + if (ctx->errcode) + return BLOCK_ABORT; + de = (struct ext2_dir_entry *)(((char *)de) + rec_len); + } + ctx->errcode = ext2fs_get_rec_len(fs, last_de, &rec_len); + if (ctx->errcode) + return BLOCK_ABORT; + name_size = ext2fs_dirent_name_len(last_de); + + if (!ext2fs_has_feature_metadata_csum(fs->super)) { + if (!penultimate_de) + return 0; + if (last_de->inode || + name_size || + rec_len != sizeof(struct ext2_dir_entry_tail)) + return 0; + /* + * The last dirent is unused and the right length to + * have stored a checksum. Erase it. + */ + ctx->errcode = ext2fs_get_rec_len(fs, penultimate_de, + &rec_len); + if (!rec_len) + ctx->errcode = EXT2_ET_DIR_CORRUPTED; + if (ctx->errcode) + return BLOCK_ABORT; + ext2fs_set_rec_len(fs, rec_len + + sizeof(struct ext2_dir_entry_tail), + penultimate_de); + changed = 1; + } else { + unsigned csum_size = sizeof(struct ext2_dir_entry_tail); + struct ext2_dir_entry_tail *t; + + /* + * If the last dirent looks like the tail, just update + * the checksum. + */ + if (!last_de->inode && + rec_len == csum_size) { + t = (struct ext2_dir_entry_tail *)last_de; + t->det_reserved_name_len = + EXT2_DIR_NAME_LEN_CSUM; + changed = 1; + goto out; + } + if (name_size & 3) + name_size = (name_size & ~3) + 4; + /* If there's not enough space for the tail, e2fsck */ + if (rec_len <= (8 + name_size + csum_size)) { + request_dir_fsck_afterwards(fs); + return 0; + } + /* Shorten that last de and insert the tail */ + ext2fs_set_rec_len(fs, rec_len - csum_size, last_de); + t = EXT2_DIRENT_TAIL(ctx->buf, fs->blocksize); + ext2fs_initialize_dirent_tail(fs, t); + + /* Always update checksum */ + changed = 1; + } + } + +out: + if (!changed) + return 0; + + ctx->errcode = ext2fs_write_dir_block4(fs, *blocknr, ctx->buf, + 0, ctx->dir); + if (ctx->errcode) + return BLOCK_ABORT; + + return 0; +} + +static errcode_t rewrite_directory(ext2_filsys fs, ext2_ino_t dir, + struct ext2_inode *inode) +{ + errcode_t retval; + struct rewrite_dir_context ctx; + + retval = ext2fs_get_mem(fs->blocksize, &ctx.buf); + if (retval) + return retval; + + ctx.is_htree = (inode->i_flags & EXT2_INDEX_FL); + ctx.dir = dir; + ctx.errcode = 0; + retval = ext2fs_block_iterate3(fs, dir, BLOCK_FLAG_READ_ONLY | + BLOCK_FLAG_DATA_ONLY, + 0, rewrite_dir_block, &ctx); + + ext2fs_free_mem(&ctx.buf); + if (retval) + return retval; + + return ctx.errcode; +} + +/* + * Forcibly set checksums in all inodes. + */ +static void rewrite_inodes(ext2_filsys fs) +{ + 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; + + if (fs->super->s_creator_os == EXT2_OS_HURD) + return; + + retval = ext2fs_open_inode_scan(fs, 0, &scan); + if (retval) { + com_err("set_csum", retval, "while opening inode scan"); + exit(1); + } + + retval = ext2fs_get_mem(length, &inode); + if (retval) { + com_err("set_csum", retval, "while allocating memory"); + exit(1); + } + + retval = ext2fs_get_memzero(length, &zero); + if (retval) { + com_err("set_csum", retval, "while allocating memory"); + exit(1); + } + + retval = ext2fs_get_mem(fs->blocksize, &ea_buf); + if (retval) { + com_err("set_csum", retval, "while allocating memory"); + exit(1); + } + + 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; + } + } + + 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 = rewrite_extents(fs, ino, inode); + if (retval) { + com_err("rewrite_extents", retval, + "while rewriting extents"); + exit(1); + } + + 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); + } + } + + 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); + + ext2fs_free_mem(&zero); + ext2fs_free_mem(&inode); + ext2fs_free_mem(&ea_buf); + ext2fs_close_inode_scan(scan); +} + +static void rewrite_metadata_checksums(ext2_filsys fs) +{ + errcode_t retval; + dgrp_t i; + + fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS; + ext2fs_init_csum_seed(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); + } + rewrite_inodes(fs); + ext2fs_mark_ib_dirty(fs); + ext2fs_mark_bb_dirty(fs); + ext2fs_mmp_update2(fs, 1); + fs->flags &= ~EXT2_FLAG_SUPER_ONLY; + fs->flags &= ~EXT2_FLAG_IGNORE_CSUM_ERRORS; + if (ext2fs_has_feature_metadata_csum(fs->super)) + fs->super->s_checksum_type = EXT2_CRC32C_CHKSUM; + else + fs->super->s_checksum_type = 0; + ext2fs_mark_super_dirty(fs); +} + +static void enable_uninit_bg(ext2_filsys fs) +{ + struct ext2_group_desc *gd; + dgrp_t i; + + for (i = 0; i < fs->group_desc_count; i++) { + gd = ext2fs_group_desc(fs, fs->group_desc, i); + gd->bg_itable_unused = 0; + gd->bg_flags = EXT2_BG_INODE_ZEROED; + ext2fs_group_desc_csum_set(fs, i); + } + fs->flags &= ~EXT2_FLAG_SUPER_ONLY; +} + +static errcode_t zero_empty_inodes(ext2_filsys fs) +{ + int length = EXT2_INODE_SIZE(fs->super); + struct ext2_inode *inode = NULL; + ext2_inode_scan scan; + errcode_t retval; + ext2_ino_t ino; + + retval = ext2fs_open_inode_scan(fs, 0, &scan); + if (retval) + goto out; + + retval = ext2fs_get_mem(length, &inode); + if (retval) + goto out; + + do { + retval = ext2fs_get_next_inode_full(scan, &ino, inode, length); + if (retval) + goto out; + if (!ino) + break; + if (!ext2fs_test_inode_bitmap2(fs->inode_map, ino)) { + memset(inode, 0, length); + retval = ext2fs_write_inode_full(fs, ino, inode, + length); + if (retval) + goto out; + } + } while (1); + +out: + ext2fs_free_mem(&inode); + ext2fs_close_inode_scan(scan); + return retval; +} + +static errcode_t disable_uninit_bg(ext2_filsys fs, __u32 csum_feature_flag) +{ + struct ext2_group_desc *gd; + dgrp_t i; + errcode_t retval; + blk64_t b, c, d; + + /* Load bitmaps to ensure that the uninit ones get written out */ + fs->super->s_feature_ro_compat |= csum_feature_flag; + retval = ext2fs_read_bitmaps(fs); + fs->super->s_feature_ro_compat &= ~csum_feature_flag; + if (retval) { + com_err("disable_uninit_bg", retval, + "while reading bitmaps"); + request_fsck_afterwards(fs); + return retval; + } + ext2fs_mark_ib_dirty(fs); + ext2fs_mark_bb_dirty(fs); + + /* If we're only turning off uninit_bg, zero the inodes */ + if (csum_feature_flag == EXT4_FEATURE_RO_COMPAT_GDT_CSUM) { + retval = zero_empty_inodes(fs); + if (retval) { + com_err("disable_uninit_bg", retval, + "while zeroing unused inodes"); + request_fsck_afterwards(fs); + return retval; + } + } + + /* The bbitmap is zeroed; we must mark group metadata blocks in use */ + for (i = 0; i < fs->group_desc_count; i++) { + b = ext2fs_block_bitmap_loc(fs, i); + ext2fs_mark_block_bitmap2(fs->block_map, b); + b = ext2fs_inode_bitmap_loc(fs, i); + ext2fs_mark_block_bitmap2(fs->block_map, b); + + retval = ext2fs_super_and_bgd_loc2(fs, i, &b, &c, &d, NULL); + if (retval == 0 && b) + ext2fs_mark_block_bitmap2(fs->block_map, b); + if (retval == 0 && c) + ext2fs_mark_block_bitmap2(fs->block_map, c); + if (retval == 0 && d) + ext2fs_mark_block_bitmap2(fs->block_map, d); + if (retval) { + com_err("disable_uninit_bg", retval, + "while initializing block bitmaps"); + request_fsck_afterwards(fs); + } + + gd = ext2fs_group_desc(fs, fs->group_desc, i); + gd->bg_itable_unused = 0; + gd->bg_flags = 0; + ext2fs_group_desc_csum_set(fs, i); + } + fs->flags &= ~EXT2_FLAG_SUPER_ONLY; + ext2fs_mark_super_dirty(fs); + + 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. */ static int update_feature_set(ext2_filsys fs, char *features) { struct ext2_super_block *sb = fs->super; - struct ext2_group_desc *gd; __u32 old_features[3]; - dgrp_t i; int type_err; unsigned int mask_err; + errcode_t err; + enum quota_type qtype; #define FEATURE_ON(type, mask) (!(old_features[(type)] & (mask)) && \ ((&sb->s_feature_compat)[(type)] & (mask))) @@ -437,8 +1029,7 @@ static int update_feature_set(ext2_filsys fs, char *features) "read-only.\n"), stderr); return 1; } - if ((sb->s_feature_incompat & - EXT3_FEATURE_INCOMPAT_RECOVER) && + if (ext2fs_has_feature_journal_needs_recovery(sb) && f_flag < 2) { fputs(_("The needs_recovery flag is set. " "Please run e2fsck before clearing\n" @@ -457,8 +1048,7 @@ static int update_feature_set(ext2_filsys fs, char *features) if (FEATURE_ON(E2P_FEATURE_RO_INCOMPAT, EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER)) { - if (sb->s_feature_incompat & - EXT2_FEATURE_INCOMPAT_META_BG) { + if (ext2fs_has_feature_meta_bg(sb)) { fputs(_("Setting filesystem feature 'sparse_super' " "not supported\nfor filesystems with " "the meta_bg feature enabled.\n"), @@ -541,7 +1131,7 @@ mmp_error: */ if (!journal_size) journal_size = -1; - sb->s_feature_compat &= ~EXT3_FEATURE_COMPAT_HAS_JOURNAL; + ext2fs_clear_feature_journal(sb); } if (FEATURE_ON(E2P_FEATURE_COMPAT, EXT2_FEATURE_COMPAT_DIR_INDEX)) { @@ -573,33 +1163,130 @@ mmp_error: } if (FEATURE_ON(E2P_FEATURE_RO_INCOMPAT, - EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) { - for (i = 0; i < fs->group_desc_count; i++) { - gd = ext2fs_group_desc(fs, fs->group_desc, i); - gd->bg_itable_unused = 0; - gd->bg_flags = EXT2_BG_INODE_ZEROED; - ext2fs_group_desc_csum_set(fs, i); + EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) { + 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); + exit(1); } - fs->flags &= ~EXT2_FLAG_SUPER_ONLY; + if (!ext2fs_has_feature_extents(fs->super)) + printf("%s", + _("Extents are not enabled. The file extent " + "tree can be checksummed, whereas block maps " + "cannot. Not enabling extents reduces the " + "coverage of metadata checksumming. " + "Re-run with -O extent to rectify.\n")); + if (!ext2fs_has_feature_64bit(fs->super)) + printf("%s", + _("64-bit filesystem support is not enabled. " + "The larger fields afforded by this feature " + "enable full-strength checksumming. " + "Run resize2fs -b to rectify.\n")); + rewrite_checksums = 1; + /* metadata_csum supersedes uninit_bg */ + ext2fs_clear_feature_gdt_csum(fs->super); + + /* if uninit_bg was previously off, rewrite group desc */ + if (!(old_features[E2P_FEATURE_RO_INCOMPAT] & + EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) + enable_uninit_bg(fs); + + /* + * Since metadata_csum supersedes uninit_bg, pretend like + * uninit_bg has been off all along. + */ + old_features[E2P_FEATURE_RO_INCOMPAT] &= + ~EXT4_FEATURE_RO_COMPAT_GDT_CSUM; + } + + if (FEATURE_OFF(E2P_FEATURE_RO_INCOMPAT, + EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) { + __u32 test_features[3]; + + 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); + exit(1); + } + rewrite_checksums = 1; + + /* Enable uninit_bg unless the user expressly turned it off */ + memcpy(test_features, old_features, sizeof(test_features)); + test_features[E2P_FEATURE_RO_INCOMPAT] |= + EXT4_FEATURE_RO_COMPAT_GDT_CSUM; + e2p_edit_feature2(features, test_features, ok_features, + clear_ok_features, NULL, NULL); + if (test_features[E2P_FEATURE_RO_INCOMPAT] & + EXT4_FEATURE_RO_COMPAT_GDT_CSUM) + ext2fs_set_feature_gdt_csum(fs->super); + + /* + * If we're turning off metadata_csum and not turning on + * uninit_bg, rewrite group desc. + */ + if (!ext2fs_has_feature_gdt_csum(fs->super)) { + err = disable_uninit_bg(fs, + EXT4_FEATURE_RO_COMPAT_METADATA_CSUM); + if (err) + return 1; + } else + /* + * metadata_csum previously provided uninit_bg, so if + * we're also setting the uninit_bg feature bit, + * pretend like it was previously enabled. Checksums + * will be rewritten with crc16 later. + */ + 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, + EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) { + /* Do not enable uninit_bg when metadata_csum enabled */ + if (ext2fs_has_feature_metadata_csum(fs->super)) + ext2fs_clear_feature_gdt_csum(fs->super); + else + enable_uninit_bg(fs); } if (FEATURE_OFF(E2P_FEATURE_RO_INCOMPAT, EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) { - for (i = 0; i < fs->group_desc_count; i++) { - gd = ext2fs_group_desc(fs, fs->group_desc, i); - if ((gd->bg_flags & EXT2_BG_INODE_ZEROED) == 0) { - /* - * XXX what we really should do is zap - * uninitialized inode tables instead. - */ - request_fsck_afterwards(fs); - break; - } - gd->bg_itable_unused = 0; - gd->bg_flags = 0; - gd->bg_checksum = 0; + err = disable_uninit_bg(fs, + EXT4_FEATURE_RO_COMPAT_GDT_CSUM); + if (err) + return 1; + } + + /* + * We don't actually toggle 64bit; resize2fs does that. But this + * must come after the metadata_csum feature_on so that it won't + * complain about the lack of 64bit. + */ + if (FEATURE_ON(E2P_FEATURE_INCOMPAT, + EXT4_FEATURE_INCOMPAT_64BIT)) { + if (mount_flags & EXT2_MF_MOUNTED) { + fprintf(stderr, _("Cannot enable 64-bit mode " + "while mounted!\n")); + exit(1); } - fs->flags &= ~EXT2_FLAG_SUPER_ONLY; + ext2fs_clear_feature_64bit(sb); + feature_64bit = 1; + } + if (FEATURE_OFF(E2P_FEATURE_INCOMPAT, + EXT4_FEATURE_INCOMPAT_64BIT)) { + if (mount_flags & EXT2_MF_MOUNTED) { + fprintf(stderr, _("Cannot disable 64-bit mode " + "while mounted!\n")); + exit(1); + } + ext2fs_set_feature_64bit(sb); + feature_64bit = -1; } if (FEATURE_ON(E2P_FEATURE_RO_INCOMPAT, @@ -610,11 +1297,32 @@ mmp_error: */ if (!Q_flag) { Q_flag = 1; - /* Enable both user quota and group quota by default */ - usrquota = QOPT_ENABLE; - grpquota = QOPT_ENABLE; + /* Enable usr/grp quota by default */ + for (qtype = 0; qtype < MAXQUOTAS; qtype++) { + if (qtype != PRJQUOTA) + quota_enable[qtype] = QOPT_ENABLE; + else + quota_enable[qtype] = QOPT_DISABLE; + } } - sb->s_feature_ro_compat &= ~EXT4_FEATURE_RO_COMPAT_QUOTA; + ext2fs_clear_feature_quota(sb); + } + + if (FEATURE_ON(E2P_FEATURE_RO_INCOMPAT, + 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, @@ -627,9 +1335,49 @@ mmp_error: fputs(_("\nWarning: '^quota' option overrides '-Q'" "arguments.\n"), stderr); Q_flag = 1; - /* Disable both user quota and group quota by default */ - usrquota = QOPT_DISABLE; - grpquota = QOPT_DISABLE; + /* Disable all quota by default */ + for (qtype = 0; qtype < MAXQUOTAS; qtype++) + quota_enable[qtype] = QOPT_DISABLE; + } + + if (FEATURE_ON(E2P_FEATURE_INCOMPAT, EXT4_FEATURE_INCOMPAT_ENCRYPT)) { + 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 && @@ -667,8 +1415,7 @@ static int add_journal(ext2_filsys fs) ext2_filsys jfs; io_manager io_ptr; - if (fs->super->s_feature_compat & - EXT3_FEATURE_COMPAT_HAS_JOURNAL) { + if (ext2fs_has_feature_journal(fs->super)) { fputs(_("The filesystem already has a journal.\n"), stderr); goto err; } @@ -698,7 +1445,7 @@ static int add_journal(ext2_filsys fs) fflush(stdout); retval = ext2fs_add_journal_device(fs, jfs); - ext2fs_close(jfs); + ext2fs_close_free(&jfs); if (retval) { com_err(program_name, retval, _("while adding filesystem to journal on %s"), @@ -743,94 +1490,130 @@ 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; + unsigned int qtype_bits = 0; + int need_dirty = 0; - if (!usrquota && !grpquota) + for (qtype = 0 ; qtype < MAXQUOTAS; qtype++) + if (quota_enable[qtype] != 0) + break; + if (qtype == MAXQUOTAS) /* Nothing to do. */ return; - quota_init_context(&qctx, fs, -1); + 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 (usrquota == QOPT_ENABLE || grpquota == QOPT_ENABLE) - quota_compute_usage(qctx); + for (qtype = 0; qtype < MAXQUOTAS; qtype++) { + if (quota_enable[qtype] == QOPT_ENABLE) + qtype_bits |= 1 << qtype; + } - if (usrquota == QOPT_ENABLE && !fs->super->s_usr_quota_inum) { - if ((qf_ino = quota_file_exists(fs, USRQUOTA, - QFMT_VFS_V1)) > 0) - quota_update_limits(qctx, qf_ino, USRQUOTA); - quota_write_inode(qctx, USRQUOTA); - } else if (usrquota == QOPT_DISABLE) { - quota_remove_inode(fs, USRQUOTA); + 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 (grpquota == QOPT_ENABLE && !fs->super->s_grp_quota_inum) { - if ((qf_ino = quota_file_exists(fs, GRPQUOTA, - QFMT_VFS_V1)) > 0) - quota_update_limits(qctx, qf_ino, GRPQUOTA); - quota_write_inode(qctx, GRPQUOTA); - } else if (grpquota == QOPT_DISABLE) { - quota_remove_inode(fs, GRPQUOTA); + 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) { + 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) { + 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); + /* Clear Quota feature if all quota types disabled. */ + if (!qtype_bits) { + for (qtype = 0 ; qtype < MAXQUOTAS; qtype++) + if (*quota_sb_inump(fs->super, qtype)) + break; + if (qtype == MAXQUOTAS) { + ext2fs_clear_feature_quota(fs->super); + need_dirty = 1; + } - if ((usrquota == QOPT_ENABLE) || (grpquota == QOPT_ENABLE)) { - fs->super->s_feature_ro_compat |= EXT4_FEATURE_RO_COMPAT_QUOTA; - ext2fs_mark_super_dirty(fs); - } else if (!fs->super->s_usr_quota_inum && - !fs->super->s_grp_quota_inum) { - fs->super->s_feature_ro_compat &= ~EXT4_FEATURE_RO_COMPAT_QUOTA; - ext2fs_mark_super_dirty(fs); } - + if (need_dirty) + ext2fs_mark_super_dirty(fs); return; } -#ifdef CONFIG_QUOTA -static void parse_quota_opts(const char *opts) +static int option_handle_function(char *token) { - char *buf, *token, *next, *p; - int len; - - len = strlen(opts); - buf = malloc(len+1); - if (!buf) { - fputs(_("Couldn't allocate memory to parse quota " - "options!\n"), stderr); - exit(1); - } - strcpy(buf, opts); - for (token = buf; token && *token; token = next) { - p = strchr(token, ','); - next = 0; - if (p) { - *p = 0; - next = p+1; - } - - if (strcmp(token, "usrquota") == 0) { - usrquota = QOPT_ENABLE; - } else if (strcmp(token, "^usrquota") == 0) { - usrquota = QOPT_DISABLE; - } else if (strcmp(token, "grpquota") == 0) { - grpquota = QOPT_ENABLE; - } else if (strcmp(token, "^grpquota") == 0) { - grpquota = QOPT_DISABLE; - } else { - fputs(_("\nBad quota options specified.\n\n" - "Following valid quota options are available " - "(pass by separating with comma):\n" - "\t[^]usrquota\n" - "\t[^]grpquota\n" - "\n\n"), stderr); - free(buf); - exit(1); - } + if (strncmp(token, "usr", 3) == 0) { + quota_enable[USRQUOTA] = QOPT_ENABLE; + } else if (strncmp(token, "^usr", 4) == 0) { + quota_enable[USRQUOTA] = QOPT_DISABLE; + } else if (strncmp(token, "grp", 3) == 0) { + quota_enable[GRPQUOTA] = QOPT_ENABLE; + } else if (strncmp(token, "^grp", 4) == 0) { + quota_enable[GRPQUOTA] = QOPT_DISABLE; + } else if (strncmp(token, "prj", 3) == 0) { + quota_enable[PRJQUOTA] = QOPT_ENABLE; + } else if (strncmp(token, "^prj", 4) == 0) { + quota_enable[PRJQUOTA] = QOPT_DISABLE; + } else { + fputs(_("\nBad quota options specified.\n\n" + "Following valid quota options are available " + "(pass by separating with comma):\n" + "\t[^]usr[quota]\n" + "\t[^]grp[quota]\n" + "\t[^]prj[quota]\n" + "\n\n"), stderr); + return 1; } - free(buf); + return 0; } -#endif static void parse_e2label_options(int argc, char ** argv) { @@ -892,13 +1675,10 @@ static void parse_tune2fs_options(int argc, char **argv) char *tmp; struct group *gr; struct passwd *pw; - char optstring[100] = "c:e:fg:i:jlm:o:r:s:u:C:E:I:J:L:M:O:T:U:"; + int ret; + char optstring[100] = "c:e:fg:i:jlm:o:r:s:u:C:E:I:J:L:M:O:T:U:z:Q:"; -#ifdef CONFIG_QUOTA - strcat(optstring, "Q:"); -#endif open_flag = 0; - printf("tune2fs %s (%s)\n", E2FSPROGS_VERSION, E2FSPROGS_DATE); while ((c = getopt(argc, argv, optstring)) != EOF) switch (c) { @@ -1054,13 +1834,13 @@ static void parse_tune2fs_options(int argc, char **argv) features_cmd = optarg; open_flag = EXT2_FLAG_RW; break; -#ifdef CONFIG_QUOTA case 'Q': Q_flag = 1; - parse_quota_opts(optarg); + ret = parse_quota_opts(optarg, option_handle_function); + if (ret) + exit(1); open_flag = EXT2_FLAG_RW; break; -#endif case 'r': reserved_blocks = strtoul(optarg, &tmp, 0); if (*tmp) { @@ -1126,6 +1906,9 @@ static void parse_tune2fs_options(int argc, char **argv) open_flag = EXT2_FLAG_RW; I_flag = 1; break; + case 'z': + undo_file = optarg; + break; default: usage(); } @@ -1303,6 +2086,7 @@ 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" "\ttest_fs\n" @@ -1383,7 +2167,7 @@ static int ext2fs_is_block_in_group(ext2_filsys fs, dgrp_t group, blk64_t blk) { blk64_t start_blk, end_blk; start_blk = fs->super->s_first_data_block + - EXT2_BLOCKS_PER_GROUP(fs->super) * group; + EXT2_GROUPS_TO_BLOCKS(fs->super, group); /* * We cannot get new block beyond end_blk for for the last block group * so we can check with EXT2_BLOCKS_PER_GROUP even for last block group @@ -1570,6 +2354,7 @@ static int inode_scan_and_fix(ext2_filsys fs, ext2fs_block_bitmap bmap) err_out: ext2fs_free_mem(&block_buf); + ext2fs_close_inode_scan(scan); return retval; } @@ -1666,6 +2451,8 @@ static int expand_inode_table(ext2_filsys fs, unsigned long new_ino_size) /* Update the meta data */ fs->inode_blocks_per_group = new_ino_blks_per_grp; + ext2fs_free_inode_cache(fs->icache); + fs->icache = 0; fs->super->s_inode_size = new_ino_size; err_out: @@ -1840,27 +2627,29 @@ static int tune2fs_setup_tdb(const char *name, io_manager *io_ptr) { errcode_t retval = 0; const char *tdb_dir; - char *tdb_file; + char *tdb_file = NULL; char *dev_name, *tmp_name; -#if 0 /* FIXME!! */ + /* (re)open a specific undo file */ + if (undo_file && undo_file[0] != 0) { + retval = set_undo_io_backing_manager(*io_ptr); + if (retval) + goto err; + *io_ptr = undo_io_manager; + retval = set_undo_io_backup_file(undo_file); + if (retval) + goto err; + printf(_("Overwriting existing filesystem; this can be undone " + "using the command:\n" + " e2undo %s %s\n\n"), + undo_file, name); + return retval; + } + /* * Configuration via a conf file would be * nice */ - profile_get_string(profile, "scratch_files", - "directory", 0, 0, - &tdb_dir); -#endif - tmp_name = strdup(name); - if (!tmp_name) { - alloc_fn_fail: - com_err(program_name, ENOMEM, "%s", - _("Couldn't allocate memory for tdb filename\n")); - return ENOMEM; - } - dev_name = basename(tmp_name); - tdb_dir = getenv("E2FSPROGS_UNDO_DIR"); if (!tdb_dir) tdb_dir = "/var/lib/e2fsprogs"; @@ -1869,37 +2658,122 @@ static int tune2fs_setup_tdb(const char *name, io_manager *io_ptr) access(tdb_dir, W_OK)) return 0; + tmp_name = strdup(name); + if (!tmp_name) + goto errout; + dev_name = basename(tmp_name); tdb_file = malloc(strlen(tdb_dir) + 9 + strlen(dev_name) + 7 + 1); - if (!tdb_file) - goto alloc_fn_fail; + if (!tdb_file) { + free(tmp_name); + goto errout; + } sprintf(tdb_file, "%s/tune2fs-%s.e2undo", tdb_dir, dev_name); + free(tmp_name); if ((unlink(tdb_file) < 0) && (errno != ENOENT)) { retval = errno; com_err(program_name, retval, _("while trying to delete %s"), tdb_file); - free(tdb_file); - return retval; + goto errout; } - set_undo_io_backing_manager(*io_ptr); + retval = set_undo_io_backing_manager(*io_ptr); + if (retval) + goto errout; *io_ptr = undo_io_manager; - set_undo_io_backup_file(tdb_file); - printf(_("To undo the tune2fs operation please run " - "the command\n e2undo %s %s\n\n"), + retval = set_undo_io_backup_file(tdb_file); + if (retval) + goto errout; + printf(_("Overwriting existing filesystem; this can be undone " + "using the command:\n" + " e2undo %s %s\n\n"), tdb_file, name); + free(tdb_file); - free(tmp_name); + return 0; +errout: + free(tdb_file); +err: + com_err("tune2fs", retval, "while trying to setup undo file\n"); return retval; } +static int +fs_update_journal_user(struct ext2_super_block *sb, __u8 old_uuid[UUID_SIZE]) +{ + int retval, nr_users, start; + journal_superblock_t *jsb; + ext2_filsys jfs; + __u8 *j_uuid; + char *journal_path; + char uuid[UUID_STR_SIZE]; + char buf[SUPERBLOCK_SIZE] __attribute__ ((aligned(8))); + + if (!ext2fs_has_feature_journal(sb) || uuid_is_null(sb->s_journal_uuid)) + return 0; + + uuid_unparse(sb->s_journal_uuid, uuid); + journal_path = blkid_get_devname(NULL, "UUID", uuid); + if (!journal_path) + return 0; + + retval = ext2fs_open2(journal_path, io_options, + EXT2_FLAG_JOURNAL_DEV_OK | EXT2_FLAG_RW, + 0, 0, unix_io_manager, &jfs); + if (retval) { + com_err(program_name, retval, + _("while trying to open %s"), + journal_path); + return retval; + } + + retval = get_journal_sb(jfs, buf); + if (retval != 0) { + if (retval == EXT2_ET_UNSUPP_FEATURE) + fprintf(stderr, _("%s is not a journal device.\n"), + journal_path); + return retval; + } + + jsb = (journal_superblock_t *) buf; + /* Find the filesystem UUID */ + nr_users = ntohl(jsb->s_nr_users); + + j_uuid = journal_user(old_uuid, jsb->s_users, nr_users); + if (j_uuid == NULL) { + fputs(_("Filesystem's UUID not found on journal device.\n"), + stderr); + return EXT2_ET_LOAD_EXT_JOURNAL; + } + + memcpy(j_uuid, sb->s_uuid, UUID_SIZE); + + start = ext2fs_journal_sb_start(jfs->blocksize); + /* Write back the journal superblock */ + retval = io_channel_write_blk64(jfs->io, start, -SUPERBLOCK_SIZE, buf); + if (retval != 0) { + com_err(program_name, retval, + "while writing journal superblock."); + return retval; + } + + ext2fs_close(jfs); + + return 0; +} + +#ifndef BUILD_AS_LIB int main(int argc, char **argv) +#else +int tune2fs_main(int argc, char **argv) +#endif /* BUILD_AS_LIB */ { errcode_t retval; ext2_filsys fs; struct ext2_super_block *sb; io_manager io_ptr, io_ptr_orig = NULL; int rc = 0; + char default_undo_file[1] = { 0 }; #ifdef ENABLE_NLS setlocale(LC_MESSAGES, ""); @@ -1933,7 +2807,7 @@ retry_open: if ((open_flag & EXT2_FLAG_RW) == 0 || f_flag) open_flag |= EXT2_FLAG_SKIP_MMP; - open_flag |= EXT2_FLAG_64BITS; + open_flag |= EXT2_FLAG_64BITS | EXT2_FLAG_JOURNAL_DEV_OK; /* keep the filesystem struct around to dump MMP data */ open_flag |= EXT2_FLAG_NOFREE_ON_ERROR; @@ -1956,6 +2830,8 @@ retry_open: fprintf(stderr, _("MMP block magic is bad. Try to fix it by " "running:\n'e2fsck -f %s'\n"), device_name); + else if (retval == EXT2_ET_BAD_MAGIC) + check_plausibility(device_name, CHECK_FS_EXIST, NULL); else if (retval != EXT2_ET_MMP_FAILED) fprintf(stderr, "%s", _("Couldn't find valid filesystem superblock.\n")); @@ -1963,9 +2839,14 @@ retry_open: ext2fs_free(fs); exit(1); } + if (ext2fs_has_feature_journal_dev(fs->super)) { + fprintf(stderr, "%s", _("Cannot modify a journal device.\n")); + ext2fs_free(fs); + exit(1); + } fs->default_bitmap_type = EXT2FS_BMAP64_RBTREE; - if (I_flag && !io_ptr_orig) { + if (I_flag) { /* * Check the inode size is right so we can issue an * error message and bail before setting up the tdb @@ -1989,11 +2870,17 @@ 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 */ + undo_file = default_undo_file; + } + + /* Set up an undo file */ + if (undo_file && io_ptr_orig == NULL) { io_ptr_orig = io_ptr; retval = tune2fs_setup_tdb(device_name, &io_ptr); if (retval) { @@ -2001,7 +2888,7 @@ retry_open: goto closefs; } if (io_ptr != io_ptr_orig) { - ext2fs_close(fs); + ext2fs_close_free(&fs); goto retry_open; } } @@ -2025,6 +2912,36 @@ 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); + } + } +#endif + /* Normally we only need to write out the superblock */ fs->flags |= EXT2_FLAG_SUPER_ONLY; @@ -2083,12 +3000,10 @@ retry_open: reserved_blocks); } if (s_flag == 1) { - if (sb->s_feature_ro_compat & - EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER) { + if (ext2fs_has_feature_sparse_super(sb)) { fputs(_("\nThe filesystem already has sparse " "superblocks.\n"), stderr); - } else if (sb->s_feature_incompat & - EXT2_FEATURE_INCOMPAT_META_BG) { + } else if (ext2fs_has_feature_meta_bg(sb)) { fputs(_("\nSetting the sparse superblock flag not " "supported\nfor filesystems with " "the meta_bg feature enabled.\n"), @@ -2096,8 +3011,7 @@ retry_open: rc = 1; goto closefs; } else { - sb->s_feature_ro_compat |= - EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER; + ext2fs_set_feature_sparse_super(sb); sb->s_state &= ~EXT2_VALID_FS; ext2fs_mark_super_dirty(fs); printf(_("\nSparse superblock flag set. %s"), @@ -2180,21 +3094,33 @@ retry_open: if (U_flag) { int set_csum = 0; dgrp_t i; + char buf[SUPERBLOCK_SIZE] __attribute__ ((aligned(8))); + __u8 old_uuid[UUID_SIZE]; - if (sb->s_feature_ro_compat & - EXT4_FEATURE_RO_COMPAT_GDT_CSUM) { + 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) { + 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); + if (!ext2fs_has_feature_csum_seed(fs->super)) + check_fsck_needed(fs, + _("Setting UUID on a checksummed " + "filesystem could take some time.")); /* * Determine if the block group checksums are @@ -2207,6 +3133,8 @@ retry_open: if (i >= fs->group_desc_count) set_csum = 1; } + + memcpy(old_uuid, sb->s_uuid, UUID_SIZE); if ((strcasecmp(new_UUID, "null") == 0) || (strcasecmp(new_UUID, "clear") == 0)) { uuid_clear(sb->s_uuid); @@ -2220,13 +3148,41 @@ retry_open: rc = 1; goto closefs; } + ext2fs_init_csum_seed(fs); if (set_csum) { for (i = 0; i < fs->group_desc_count; i++) ext2fs_group_desc_csum_set(fs, i); fs->flags &= ~EXT2_FLAG_SUPER_ONLY; } + + /* If this is a journal dev, we need to copy UUID into jsb */ + if (!(rc = get_journal_sb(fs, buf))) { + journal_superblock_t *jsb; + + jsb = (journal_superblock_t *) buf; + fputs(_("Need to update journal superblock.\n"), stdout); + memcpy(jsb->s_uuid, sb->s_uuid, sizeof(sb->s_uuid)); + + /* Writeback the journal superblock */ + if ((rc = io_channel_write_blk64(fs->io, + ext2fs_journal_sb_start(fs->blocksize), + -SUPERBLOCK_SIZE, buf))) + goto closefs; + } else if (rc != EXT2_ET_UNSUPP_FEATURE) + goto closefs; + else { + rc = 0; /** Reset rc to avoid ext2fs_mmp_stop() */ + + if ((rc = fs_update_journal_user(sb, old_uuid))) + goto closefs; + } + ext2fs_mark_super_dirty(fs); + if (ext2fs_has_feature_metadata_csum(fs->super) && + !ext2fs_has_feature_csum_seed(fs->super)) + rewrite_checksums = 1; } + if (I_flag) { if (mount_flags & EXT2_MF_MOUNTED) { fputs(_("The inode size may only be " @@ -2235,8 +3191,7 @@ retry_open: rc = 1; goto closefs; } - if (fs->super->s_feature_incompat & - EXT4_FEATURE_INCOMPAT_FLEX_BG) { + if (ext2fs_has_feature_flex_bg(fs->super)) { fputs(_("Changing the inode size not supported for " "filesystems with the flex_bg\n" "feature enabled.\n"), @@ -2248,10 +3203,16 @@ retry_open: * We want to update group descriptor also * with the new free inode count */ + if (rewrite_checksums) + fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS; fs->flags &= ~EXT2_FLAG_SUPER_ONLY; - if (resize_inode(fs, new_inode_size) == 0) { + retval = resize_inode(fs, new_inode_size); + if (rewrite_checksums) + fs->flags &= ~EXT2_FLAG_IGNORE_CSUM_ERRORS; + if (retval == 0) { printf(_("Setting inode size %lu\n"), new_inode_size); + rewrite_checksums = 1; } else { printf("%s", _("Failed to change inode size\n")); rc = 1; @@ -2259,6 +3220,9 @@ retry_open: } } + if (rewrite_checksums) + rewrite_metadata_checksums(fs); + if (l_flag) list_super(sb); if (stride_set) { @@ -2280,14 +3244,19 @@ retry_open: ext_mount_opts); free(ext_mount_opts); } + free(device_name); remove_error_table(&et_ext2_error_table); closefs: if (rc) { ext2fs_mmp_stop(fs); +#ifndef BUILD_AS_LIB exit(1); +#endif } - return (ext2fs_close(fs) ? 1 : 0); + if (feature_64bit) + convert_64bit(fs, feature_64bit); + return (ext2fs_close_free(&fs) ? 1 : 0); }