X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=misc%2Ftune2fs.c;h=9f0d4379180b214197c9a91a8775cf239f7840fb;hb=c2b975f843505f5b98eda17ede4e188bd9bdc835;hp=10ce58f50f5acdaf50118db52426d8a22aa542cc;hpb=9c05bb9fbae9d31d4a0c0d52b5ecec8ebd1b9011;p=tools%2Fe2fsprogs.git diff --git a/misc/tune2fs.c b/misc/tune2fs.c index 10ce58f..9f0d437 100644 --- a/misc/tune2fs.c +++ b/misc/tune2fs.c @@ -52,6 +52,9 @@ extern int optind; #include #include #include +#ifdef HAVE_SYS_IOCTL_H +#include +#endif #include "ext2fs/ext2_fs.h" #include "ext2fs/ext2fs.h" @@ -59,6 +62,7 @@ extern int optind; #include "et/com_err.h" #include "support/plausible.h" #include "support/quotaio.h" +#include "support/devname.h" #include "uuid/uuid.h" #include "e2p/e2p.h" #include "util.h" @@ -70,11 +74,34 @@ extern int optind; #define QOPT_ENABLE (1) #define QOPT_DISABLE (-1) +#ifndef FS_IOC_SETFSLABEL +#define FSLABEL_MAX 256 +#define FS_IOC_SETFSLABEL _IOW(0x94, 50, char[FSLABEL_MAX]) +#endif + +#ifndef FS_IOC_GETFSLABEL +#define FS_IOC_GETFSLABEL _IOR(0x94, 49, char[FSLABEL_MAX]) +#endif + +struct fsuuid { + __u32 fsu_len; + __u32 fsu_flags; + __u8 fsu_uuid[]; +}; + +#ifndef EXT4_IOC_GETFSUUID +#define EXT4_IOC_GETFSUUID _IOR('f', 44, struct fsuuid) +#endif + +#ifndef EXT4_IOC_SETFSUUID +#define EXT4_IOC_SETFSUUID _IOW('f', 44, struct fsuuid) +#endif + extern int ask_yn(const char *string, int def); const char *program_name = "tune2fs"; char *device_name; -char *new_label, *new_last_mounted, *new_UUID; +char *new_label, *new_last_mounted, *requested_uuid; char *io_options; static int c_flag, C_flag, e_flag, f_flag, g_flag, i_flag, l_flag, L_flag; static int m_flag, M_flag, Q_flag, r_flag, s_flag = -1, u_flag, U_flag, T_flag; @@ -101,10 +128,12 @@ static int rewrite_checksums; static int feature_64bit; static int fsck_requested; static char *undo_file; +int enabling_casefold; -int journal_size, journal_flags; +int journal_size, journal_fc_size, journal_flags; char *journal_device; static blk64_t journal_location = ~0LL; +static e2_blkcnt_t orphan_file_blocks; static struct list_head blk_move_list; @@ -116,24 +145,29 @@ struct blk_move { 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"), @@ -144,15 +178,21 @@ static void usage(void) static __u32 ok_features[3] = { /* Compat */ EXT3_FEATURE_COMPAT_HAS_JOURNAL | - EXT2_FEATURE_COMPAT_DIR_INDEX, + EXT2_FEATURE_COMPAT_DIR_INDEX | + EXT4_FEATURE_COMPAT_FAST_COMMIT | + EXT4_FEATURE_COMPAT_STABLE_INODES | + EXT4_FEATURE_COMPAT_ORPHAN_FILE, /* Incompat */ 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_CSUM_SEED, + EXT4_FEATURE_INCOMPAT_CSUM_SEED | + EXT4_FEATURE_INCOMPAT_LARGEDIR | + EXT4_FEATURE_INCOMPAT_CASEFOLD, /* R/O compat */ EXT2_FEATURE_RO_COMPAT_LARGE_FILE | EXT4_FEATURE_RO_COMPAT_HUGE_FILE| @@ -163,20 +203,24 @@ 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] = { /* Compat */ EXT3_FEATURE_COMPAT_HAS_JOURNAL | EXT2_FEATURE_COMPAT_RESIZE_INODE | - EXT2_FEATURE_COMPAT_DIR_INDEX, + EXT2_FEATURE_COMPAT_DIR_INDEX | + EXT4_FEATURE_COMPAT_FAST_COMMIT | + EXT4_FEATURE_COMPAT_ORPHAN_FILE, /* Incompat */ EXT2_FEATURE_INCOMPAT_FILETYPE | EXT4_FEATURE_INCOMPAT_FLEX_BG | EXT4_FEATURE_INCOMPAT_MMP | EXT4_FEATURE_INCOMPAT_64BIT | - EXT4_FEATURE_INCOMPAT_CSUM_SEED, + EXT4_FEATURE_INCOMPAT_CSUM_SEED | + EXT4_FEATURE_INCOMPAT_CASEFOLD, /* R/O compat */ EXT2_FEATURE_RO_COMPAT_LARGE_FILE | EXT4_FEATURE_RO_COMPAT_HUGE_FILE| @@ -184,6 +228,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 }; @@ -209,8 +254,8 @@ static int get_journal_sb(ext2_filsys jfs, char buf[SUPERBLOCK_SIZE]) } 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))) { + if ((jsb->s_header.h_magic != (unsigned)ntohl(JBD2_MAGIC_NUMBER)) || + (jsb->s_header.h_blocktype != (unsigned)ntohl(JBD2_SUPERBLOCK_V2))) { fputs(_("Journal superblock not found!\n"), stderr); return EXT2_ET_BAD_MAGIC; } @@ -218,7 +263,7 @@ static int get_journal_sb(ext2_filsys jfs, char buf[SUPERBLOCK_SIZE]) return 0; } -static __u8 *journal_user(__u8 uuid[UUID_SIZE], __u8 s_users[JFS_USERS_SIZE], +static __u8 *journal_user(__u8 uuid[UUID_SIZE], __u8 s_users[JBD2_USERS_SIZE], int nr_users) { int i; @@ -283,6 +328,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 > JBD2_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"), @@ -350,7 +401,7 @@ static errcode_t remove_journal_inode(ext2_filsys fs) { struct ext2_inode inode; errcode_t retval; - ino_t ino = fs->super->s_journal_inum; + ext2_ino_t ino = fs->super->s_journal_inum; retval = ext2fs_read_inode(fs, ino, &inode); if (retval) { @@ -373,6 +424,8 @@ static errcode_t remove_journal_inode(ext2_filsys fs) _("while clearing journal inode")); return retval; } + fs->super->s_overhead_clusters -= + EXT2FS_NUM_B2C(fs, EXT2_I_SIZE(&inode) / fs->blocksize); memset(&inode, 0, sizeof(inode)); ext2fs_mark_bb_dirty(fs); fs->flags &= ~EXT2_FLAG_SUPER_ONLY; @@ -408,24 +461,27 @@ static int update_mntopts(ext2_filsys fs, char *mntopts) return 0; } -static void check_fsck_needed(ext2_filsys fs, const char *prompt) +static int check_fsck_needed(ext2_filsys fs, const char *prompt) { /* 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)) { - printf("\n%s\n", _(please_fsck)); + puts(_(fsck_explain)); + puts(_(please_fsck)); if (mount_flags & EXT2_MF_READONLY) printf("%s", _("(and reboot afterwards!)\n")); - exit(1); + return 1; } /* Give the admin a few seconds to bail out of a dangerous op. */ if (!getenv("TUNE2FS_FORCE_PROMPT") && (!isatty(0) || !isatty(1))) - return; + return 0; puts(prompt); proceed_question(5); + + return 0; } static void request_dir_fsck_afterwards(ext2_filsys fs) @@ -436,7 +492,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")); } @@ -456,9 +513,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. @@ -483,64 +537,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 */ @@ -548,7 +544,8 @@ struct rewrite_dir_context { char *buf; errcode_t errcode; ext2_ino_t dir; - int is_htree; + int is_htree:1; + int clear_htree:1; }; static int rewrite_dir_block(ext2_filsys fs, @@ -567,8 +564,13 @@ static int rewrite_dir_block(ext2_filsys fs, if (ctx->errcode) return BLOCK_ABORT; - /* if htree node... */ - if (ctx->is_htree) + /* + * if htree node... Note that if we are clearing htree structures from + * the directory, we treat the htree internal block as an ordinary leaf. + * The code below will do the right thing and make space for checksum + * there. + */ + if (ctx->is_htree && !ctx->clear_htree) ext2fs_get_dx_countlimit(fs, (struct ext2_dir_entry *)ctx->buf, &dcl, &dcl_offset); if (dcl) { @@ -697,7 +699,8 @@ static errcode_t rewrite_directory(ext2_filsys fs, ext2_ino_t dir, if (retval) return retval; - ctx.is_htree = (inode->i_flags & EXT2_INDEX_FL); + ctx.is_htree = !!(inode->i_flags & EXT2_INDEX_FL); + ctx.clear_htree = !ext2fs_has_feature_dir_index(fs->super); ctx.dir = dir; ctx.errcode = 0; retval = ext2fs_block_iterate3(fs, dir, BLOCK_FLAG_READ_ONLY | @@ -708,121 +711,256 @@ static errcode_t rewrite_directory(ext2_filsys fs, ext2_ino_t dir, if (retval) return retval; + if (ctx.is_htree && ctx.clear_htree) { + inode->i_flags &= ~EXT2_INDEX_FL; + retval = ext2fs_write_inode(fs, dir, inode); + if (retval) + return retval; + } + return ctx.errcode; } /* - * 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"); } + file_acl_block = ext2fs_file_acl_block(ctx->fs, inode); + if (!file_acl_block) + return; + + retval = ext2fs_read_ext_attr3(ctx->fs, file_acl_block, ctx->ea_buf, + ino); + if (retval) + fatal_err(retval, "while rewriting extended attribute"); + + 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"); +} + +#define REWRITE_EA_FL 0x01 /* Rewrite EA inodes */ +#define REWRITE_DIR_FL 0x02 /* Rewrite directories */ +#define REWRITE_NONDIR_FL 0x04 /* Rewrite other inodes */ +#define REWRITE_ALL (REWRITE_EA_FL | REWRITE_DIR_FL | REWRITE_NONDIR_FL) + +static void rewrite_inodes_pass(struct rewrite_context *ctx, unsigned int flags) +{ + ext2_inode_scan scan; + errcode_t retval; + ext2_ino_t ino; + struct ext2_inode *inode; + int rewrite; + + retval = ext2fs_get_mem(ctx->inode_size, &inode); + if (retval) + fatal_err(retval, "while allocating memory"); + + retval = ext2fs_open_inode_scan(ctx->fs, 0, &scan); + if (retval) + fatal_err(retval, "while opening inode scan"); + do { - retval = ext2fs_get_next_inode_full(scan, &ino, inode, length); - if (retval) { - com_err("set_csum", retval, "while getting next inode"); - exit(1); - } + 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 (ext2fs_test_inode_bitmap2(fs->inode_map, ino)) { - inode_dirty = 1; + + rewrite = 0; + if (inode->i_flags & EXT4_EA_INODE_FL) { + if (flags & REWRITE_EA_FL) + rewrite = 1; + } else if (LINUX_S_ISDIR(inode->i_mode)) { + if (flags & REWRITE_DIR_FL) + rewrite = 1; } else { - if (memcmp(inode, zero, length) != 0) { - memset(inode, 0, length); - inode_dirty = 1; - } else { - inode_dirty = 0; - } + if (flags & REWRITE_NONDIR_FL) + rewrite = 1; } + if (rewrite) + rewrite_one_inode(ctx, ino, inode); + } while (ino); + ext2fs_close_inode_scan(scan); + ext2fs_free_mem(&inode); +} - if (inode_dirty) { - retval = ext2fs_write_inode_full(fs, ino, inode, - length); - if (retval) { - com_err("set_csum", retval, "while writing " - "inode"); - exit(1); - } - } +/* + * Forcibly rewrite checksums in inodes specified by 'flags' + */ +static void rewrite_inodes(ext2_filsys fs, unsigned int flags) +{ + struct rewrite_context ctx = { + .fs = fs, + .inode_size = EXT2_INODE_SIZE(fs->super), + }; + errcode_t retval; - retval = rewrite_extents(fs, ino, inode); - if (retval) { - com_err("rewrite_extents", retval, - "while rewriting extents"); - exit(1); - } + if (fs->super->s_creator_os == EXT2_OS_HURD) + return; - 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); - } - } + retval = ext2fs_get_memzero(ctx.inode_size, &ctx.zero_inode); + if (retval) + fatal_err(retval, "while allocating memory"); - 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(64 * 1024, &ctx.ea_buf); + if (retval) + fatal_err(retval, "while allocating memory"); - ext2fs_free_mem(&zero); - ext2fs_free_mem(&inode); - ext2fs_free_mem(&ea_buf); - ext2fs_close_inode_scan(scan); + /* + * 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) && (flags & REWRITE_EA_FL)) + rewrite_inodes_pass(&ctx, REWRITE_EA_FL); + flags &= ~REWRITE_EA_FL; + rewrite_inodes_pass(&ctx, flags); + + ext2fs_free_mem(&ctx.zero_inode); + ext2fs_free_mem(&ctx.ea_buf); } -static void rewrite_metadata_checksums(ext2_filsys fs) +static void rewrite_metadata_checksums(ext2_filsys fs, unsigned int flags) { errcode_t retval; dgrp_t i; @@ -832,12 +970,9 @@ 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); - } - rewrite_inodes(fs); + if (retval) + fatal_err(retval, "while reading bitmaps"); + rewrite_inodes(fs, flags); ext2fs_mark_ib_dirty(fs); ext2fs_mark_bb_dirty(fs); ext2fs_mmp_update2(fs, 1); @@ -901,6 +1036,41 @@ out: return retval; } +static int has_casefold_inode(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; + int found_casefold = 0; + + retval = ext2fs_get_mem(length, &inode); + if (retval) + fatal_err(retval, "while allocating memory"); + + 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, length); + if (retval) + fatal_err(retval, "while getting next inode"); + if (!ino) + break; + + if(inode->i_flags & EXT4_CASEFOLD_FL) { + found_casefold = 1; + break; + } + } while(1); + + ext2fs_free_mem(&inode); + ext2fs_close_inode_scan(scan); + return found_casefold; +} + static errcode_t disable_uninit_bg(ext2_filsys fs, __u32 csum_feature_flag) { struct ext2_group_desc *gd; @@ -1041,6 +1211,56 @@ static int update_feature_set(ext2_filsys fs, char *features) } } + if (FEATURE_OFF(E2P_FEATURE_COMPAT, EXT4_FEATURE_COMPAT_ORPHAN_FILE)) { + ext2_ino_t ino; + + if (mount_flags & EXT2_MF_MOUNTED) { + fputs(_("The orphan_file feature may only be cleared " + "when the filesystem is unmounted.\n"), stderr); + return 1; + } + if (ext2fs_has_feature_orphan_present(sb) && f_flag < 2) { + fputs(_("The orphan_present feature is set. Please " + "run e2fsck before clearing orphan_file " + "feature.\n"), + stderr); + return 1; + } + err = ext2fs_read_bitmaps(fs); + if (err) { + com_err(program_name, err, "%s", + _("while loading bitmaps")); + return 1; + } + err = ext2fs_truncate_orphan_file(fs); + if (err) { + com_err(program_name, err, + _("\n\twhile trying to delete orphan file\n")); + return 1; + } + ino = sb->s_orphan_file_inum; + sb->s_orphan_file_inum = 0; + ext2fs_inode_alloc_stats2(fs, ino, -1, 0); + ext2fs_clear_feature_orphan_file(sb); + ext2fs_clear_feature_orphan_present(sb); + ext2fs_mark_super_dirty(fs); + } + + if (FEATURE_ON(E2P_FEATURE_COMPAT, EXT4_FEATURE_COMPAT_ORPHAN_FILE)) { + if (!ext2fs_has_feature_journal(sb)) { + fputs(_("orphan_file feature can be set only for " + "filesystems with journal.\n"), stderr); + return 1; + } + /* + * If adding an orphan file, let the create orphan file + * code below handle setting the flag and creating it. + * We supply a default size if necessary. + */ + orphan_file_blocks = ext2fs_default_orphan_file_blocks(fs); + ext2fs_set_feature_orphan_file(sb); + } + if (FEATURE_ON(E2P_FEATURE_RO_INCOMPAT, EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER)) { if (ext2fs_has_feature_meta_bg(sb)) { @@ -1136,6 +1356,24 @@ mmp_error: uuid_generate((unsigned char *) sb->s_hash_seed); } + if (FEATURE_OFF(E2P_FEATURE_COMPAT, EXT2_FEATURE_COMPAT_DIR_INDEX) && + ext2fs_has_feature_metadata_csum(sb)) { + if (check_fsck_needed(fs, + _("Disabling directory index on filesystem with " + "checksums could take some time."))) + return 1; + if (mount_flags & EXT2_MF_MOUNTED) { + fputs(_("Cannot disable dir_index on a mounted " + "filesystem!\n"), stderr); + exit(1); + } + /* + * Clearing dir_index on checksummed filesystem requires + * rewriting all directories to update checksums. + */ + rewrite_checksums |= REWRITE_DIR_FL; + } + if (FEATURE_OFF(E2P_FEATURE_INCOMPAT, EXT4_FEATURE_INCOMPAT_FLEX_BG)) { if (ext2fs_check_desc(fs)) { fputs(_("Clearing the flex_bg flag would " @@ -1159,12 +1397,13 @@ mmp_error: if (FEATURE_ON(E2P_FEATURE_RO_INCOMPAT, EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) { - check_fsck_needed(fs, - _("Enabling checksums could take some time.")); + if (check_fsck_needed(fs, + _("Enabling checksums could take some time."))) + return 1; if (mount_flags & EXT2_MF_MOUNTED) { fputs(_("Cannot enable metadata_csum on a mounted " "filesystem!\n"), stderr); - exit(1); + return 1; } if (!ext2fs_has_feature_extents(fs->super)) printf("%s", @@ -1179,7 +1418,7 @@ mmp_error: "The larger fields afforded by this feature " "enable full-strength checksumming. " "Run resize2fs -b to rectify.\n")); - rewrite_checksums = 1; + rewrite_checksums = REWRITE_ALL; /* metadata_csum supersedes uninit_bg */ ext2fs_clear_feature_gdt_csum(fs->super); @@ -1200,14 +1439,15 @@ mmp_error: EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) { __u32 test_features[3]; - check_fsck_needed(fs, - _("Disabling checksums could take some time.")); + if (check_fsck_needed(fs, + _("Disabling checksums could take some time."))) + return 1; if (mount_flags & EXT2_MF_MOUNTED) { fputs(_("Cannot disable metadata_csum on a mounted " "filesystem!\n"), stderr); - exit(1); + return 1; } - rewrite_checksums = 1; + rewrite_checksums = REWRITE_ALL; /* Enable uninit_bg unless the user expressly turned it off */ memcpy(test_features, old_features, sizeof(test_features)); @@ -1243,6 +1483,12 @@ mmp_error: if (FEATURE_ON(E2P_FEATURE_RO_INCOMPAT, EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) { + if (mount_flags & EXT2_MF_MOUNTED) { + fputs(_("Cannot enable uninit_bg on a mounted " + "filesystem!\n"), stderr); + return 1; + } + /* Do not enable uninit_bg when metadata_csum enabled */ if (ext2fs_has_feature_metadata_csum(fs->super)) ext2fs_clear_feature_gdt_csum(fs->super); @@ -1252,6 +1498,12 @@ mmp_error: if (FEATURE_OFF(E2P_FEATURE_RO_INCOMPAT, EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) { + if (mount_flags & EXT2_MF_MOUNTED) { + fputs(_("Cannot disable uninit_bg on a mounted " + "filesystem!\n"), stderr); + return 1; + } + err = disable_uninit_bg(fs, EXT4_FEATURE_RO_COMPAT_GDT_CSUM); if (err) @@ -1268,7 +1520,7 @@ mmp_error: if (mount_flags & EXT2_MF_MOUNTED) { fprintf(stderr, _("Cannot enable 64-bit mode " "while mounted!\n")); - exit(1); + return 1; } ext2fs_clear_feature_64bit(sb); feature_64bit = 1; @@ -1278,7 +1530,7 @@ mmp_error: if (mount_flags & EXT2_MF_MOUNTED) { fprintf(stderr, _("Cannot disable 64-bit mode " "while mounted!\n")); - exit(1); + return 1; } ext2fs_set_feature_64bit(sb); feature_64bit = -1; @@ -1304,15 +1556,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")); + return 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 @@ -1334,6 +1594,33 @@ mmp_error: EXT4_ENCRYPTION_MODE_AES_256_CTS; } + if (FEATURE_ON(E2P_FEATURE_INCOMPAT, EXT4_FEATURE_INCOMPAT_CASEFOLD)) { + if (mount_flags & EXT2_MF_MOUNTED) { + fputs(_("The casefold feature may only be enabled when " + "the filesystem is unmounted.\n"), stderr); + return 1; + } + fs->super->s_encoding = EXT4_ENC_UTF8_12_1; + fs->super->s_encoding_flags = e2p_get_encoding_flags(EXT4_ENC_UTF8_12_1); + enabling_casefold = 1; + } + + if (FEATURE_OFF(E2P_FEATURE_INCOMPAT, EXT4_FEATURE_INCOMPAT_CASEFOLD)) { + if (mount_flags & EXT2_MF_MOUNTED) { + fputs(_("The casefold feature may only be disabled when " + "the filesystem is unmounted.\n"), stderr); + return 1; + } + if (has_casefold_inode(fs)) { + fputs(_("The casefold feature can't be cleared when " + "there are inodes with +F flag.\n"), stderr); + return 1; + } + fs->super->s_encoding = 0; + fs->super->s_encoding_flags = 0; + enabling_casefold = 0; + } + if (FEATURE_ON(E2P_FEATURE_INCOMPAT, EXT4_FEATURE_INCOMPAT_CSUM_SEED)) { if (!ext2fs_has_feature_metadata_csum(sb)) { @@ -1353,16 +1640,19 @@ mmp_error: uuid_seed = ext2fs_crc32c_le(~0, fs->super->s_uuid, sizeof(fs->super->s_uuid)); - if (fs->super->s_checksum_seed != uuid_seed && - (mount_flags & 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; + 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; + } + if (check_fsck_needed(fs, _("Recalculating checksums " + "could take some time."))) + return 1; + rewrite_checksums = REWRITE_ALL; } - - rewrite_checksums = 1; } if (sb->s_rev_level == EXT2_GOOD_OLD_REV && @@ -1395,7 +1685,7 @@ mmp_error: */ static int add_journal(ext2_filsys fs) { - unsigned long journal_blocks; + struct ext2fs_journal_params jparams; errcode_t retval; ext2_filsys jfs; io_manager io_ptr; @@ -1441,13 +1731,13 @@ static int add_journal(ext2_filsys fs) } else if (journal_size) { fputs(_("Creating journal inode: "), stdout); fflush(stdout); - journal_blocks = figure_journal_size(journal_size, fs); + figure_journal_size(&jparams, journal_size, journal_fc_size, fs); if (journal_location_string) journal_location = parse_num_blocks2(journal_location_string, fs->super->s_log_block_size); - retval = ext2fs_add_journal_inode2(fs, journal_blocks, + retval = ext2fs_add_journal_inode3(fs, &jparams, journal_location, journal_flags); if (retval) { @@ -1455,8 +1745,12 @@ static int add_journal(ext2_filsys fs) com_err(program_name, retval, "%s", _("\n\twhile trying to create journal file")); return retval; - } else - fputs(_("done\n"), stdout); + } + fs->super->s_overhead_clusters += EXT2FS_NUM_B2C(fs, + jparams.num_journal_blocks + jparams.num_fc_blocks); + ext2fs_mark_super_dirty(fs); + fputs(_("done\n"), stdout); + /* * If the filesystem wasn't mounted, we need to force * the block group descriptors out. @@ -1473,61 +1767,110 @@ err: return 1; } -static void handle_quota_options(ext2_filsys fs) +static int 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) break; if (qtype == MAXQUOTAS) /* Nothing to do. */ - return; + return 0; - 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")); + return 1; + } + + for (qtype = 0; qtype < MAXQUOTAS; qtype++) { + if (quota_enable[qtype] == QOPT_ENABLE) + qtype_bits |= 1 << qtype; } - if (enable) + + retval = quota_init_context(&qctx, fs, qtype_bits); + if (retval) { + com_err(program_name, retval, + _("while initializing quota context in support library")); + return 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_read_all_dquots(qctx, qf_ino, + qtype, + QREAD_LIMITS); + if (retval) { + com_err(program_name, retval, + _("while updating quota limits (%d)"), + qtype); + quota_errout: + quota_release_context(&qctx); + return 1; + } + } + retval = quota_write_inode(qctx, 1 << qtype); + if (retval) { + com_err(program_name, retval, + _("while writing quota file (%d)"), + qtype); + goto quota_errout; + } + /* 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); + goto quota_errout; + } + 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; } - } - return; + } + if (need_dirty) + ext2fs_mark_super_dirty(fs); + return 0; } -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; @@ -1563,13 +1906,13 @@ static void parse_e2label_options(int argc, char ** argv) io_options = strchr(argv[1], '?'); if (io_options) *io_options++ = 0; - device_name = blkid_get_devname(NULL, argv[1], NULL); + device_name = get_devname(NULL, argv[1], NULL); if (!device_name) { com_err("e2label", 0, _("Unable to resolve '%s'"), argv[1]); exit(1); } - open_flag = EXT2_FLAG_JOURNAL_DEV_OK; + open_flag = EXT2_FLAG_JOURNAL_DEV_OK | EXT2_FLAG_SUPER_ONLY; if (argc == 3) { open_flag |= EXT2_FLAG_RW; L_flag = 1; @@ -1622,8 +1965,15 @@ static void parse_tune2fs_options(int argc, char **argv) while ((c = getopt(argc, argv, optstring)) != EOF) switch (c) { case 'c': + open_flag = EXT2_FLAG_RW; + c_flag = 1; + if (strcmp(optarg, "random") == 0) { + max_mount_count = 65536; + break; + } max_mount_count = strtol(optarg, &tmp, 0); - if (*tmp || max_mount_count > 16000) { + if (*tmp || max_mount_count > 16000 || + max_mount_count < -16000) { com_err(program_name, 0, _("bad mounts count - %s"), optarg); @@ -1631,8 +1981,6 @@ static void parse_tune2fs_options(int argc, char **argv) } if (max_mount_count == 0) max_mount_count = -1; - c_flag = 1; - open_flag = EXT2_FLAG_RW; break; case 'C': mount_count = strtoul(optarg, &tmp, 0); @@ -1775,8 +2123,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; @@ -1822,7 +2169,7 @@ static void parse_tune2fs_options(int argc, char **argv) open_flag = EXT2_FLAG_RW; break; case 'U': - new_UUID = optarg; + requested_uuid = optarg; U_flag = 1; open_flag = EXT2_FLAG_RW | EXT2_FLAG_JOURNAL_DEV_OK; @@ -1859,7 +2206,7 @@ static void parse_tune2fs_options(int argc, char **argv) io_options = strchr(argv[optind], '?'); if (io_options) *io_options++ = 0; - device_name = blkid_get_devname(NULL, argv[optind], NULL); + device_name = get_devname(NULL, argv[optind], NULL); if (!device_name) { com_err(program_name, 0, _("Unable to resolve '%s'"), argv[optind]); @@ -1890,9 +2237,12 @@ void do_findfs(int argc, char **argv) static int parse_extended_opts(ext2_filsys fs, const char *opts) { + struct ext2_super_block *sb = fs->super; char *buf, *token, *next, *p, *arg; int len, hash_alg; int r_usage = 0; + int encoding = 0; + char *encoding_flags = NULL; len = strlen(opts); buf = malloc(len+1); @@ -1945,14 +2295,18 @@ static int parse_extended_opts(ext2_filsys fs, const char *opts) "Setting multiple mount protection update " "interval to %lu seconds\n", intv), intv); - fs->super->s_mmp_update_interval = intv; + sb->s_mmp_update_interval = intv; + ext2fs_mark_super_dirty(fs); + } else if (!strcmp(token, "force_fsck")) { + sb->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; + sb->s_flags |= EXT2_FLAGS_TEST_FILESYS; printf("Setting test filesystem flag\n"); ext2fs_mark_super_dirty(fs); } else if (!strcmp(token, "^test_fs")) { - fs->super->s_flags &= ~EXT2_FLAGS_TEST_FILESYS; + sb->s_flags &= ~EXT2_FLAGS_TEST_FILESYS; printf("Clearing test filesystem flag\n"); ext2fs_mark_super_dirty(fs); } else if (strcmp(token, "stride") == 0) { @@ -1998,7 +2352,7 @@ static int parse_extended_opts(ext2_filsys fs, const char *opts) r_usage++; continue; } - fs->super->s_def_hash_version = hash_alg; + sb->s_def_hash_version = hash_alg; printf(_("Setting default hash algorithm " "to %s (%d)\n"), arg, hash_alg); @@ -2014,9 +2368,78 @@ static int parse_extended_opts(ext2_filsys fs, const char *opts) continue; } ext_mount_opts = strdup(arg); + } else if (!strcmp(token, "encoding")) { + if (!arg) { + r_usage++; + continue; + } + if (mount_flags & EXT2_MF_MOUNTED) { + fputs(_("The casefold feature may only be enabled when " + "the filesystem is unmounted.\n"), stderr); + r_usage++; + continue; + } + if (ext2fs_has_feature_casefold(sb) && !enabling_casefold) { + fprintf(stderr, _("Cannot alter existing encoding\n")); + r_usage++; + continue; + } + encoding = e2p_str2encoding(arg); + if (encoding < 0) { + fprintf(stderr, _("Invalid encoding: %s\n"), arg); + r_usage++; + continue; + } + enabling_casefold = 1; + sb->s_encoding = encoding; + printf(_("Setting encoding to '%s'\n"), arg); + sb->s_encoding_flags = + e2p_get_encoding_flags(sb->s_encoding); + } else if (!strcmp(token, "encoding_flags")) { + if (!arg) { + r_usage++; + continue; + } + encoding_flags = arg; + } else if (!strcmp(token, "orphan_file_size")) { + if (!arg) { + r_usage++; + continue; + } + orphan_file_blocks = parse_num_blocks2(arg, + fs->super->s_log_block_size); + + if (orphan_file_blocks < 1) { + fprintf(stderr, + _("Invalid size of orphan file %s\n"), + arg); + r_usage++; + continue; + } } else r_usage++; } + + if (encoding > 0 && !r_usage) { + sb->s_encoding_flags = + e2p_get_encoding_flags(sb->s_encoding); + + if (encoding_flags && + e2p_str2encoding_flags(sb->s_encoding, encoding_flags, + &sb->s_encoding_flags)) { + fprintf(stderr, _("error: Invalid encoding flag: %s\n"), + encoding_flags); + r_usage++; + } else if (encoding_flags) + printf(_("Setting encoding_flags to '%s'\n"), + encoding_flags); + ext2fs_set_feature_casefold(sb); + ext2fs_mark_super_dirty(fs); + } else if (encoding_flags && !r_usage) { + fprintf(stderr, _("error: An encoding must be explicitly " + "specified when passing encoding-flags\n")); + r_usage++; + } if (r_usage) { fprintf(stderr, "%s", _("\nBad options specified.\n\n" "Extended options are separated by commas, " @@ -2026,10 +2449,14 @@ 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")); + "\t^test_fs\n" + "\tencoding=\n" + "\tencoding_flags=\n")); free(buf); return 1; } @@ -2404,63 +2831,6 @@ err_out: return retval; } -static errcode_t ext2fs_calculate_summary_stats(ext2_filsys fs) -{ - blk64_t blk; - ext2_ino_t ino; - unsigned int group = 0; - unsigned int count = 0; - int total_free = 0; - int group_free = 0; - - /* - * First calculate the block statistics - */ - for (blk = fs->super->s_first_data_block; - blk < ext2fs_blocks_count(fs->super); blk++) { - if (!ext2fs_fast_test_block_bitmap2(fs->block_map, blk)) { - group_free++; - total_free++; - } - count++; - if ((count == fs->super->s_blocks_per_group) || - (blk == ext2fs_blocks_count(fs->super)-1)) { - ext2fs_bg_free_blocks_count_set(fs, group++, - group_free); - count = 0; - group_free = 0; - } - } - total_free = EXT2FS_C2B(fs, total_free); - ext2fs_free_blocks_count_set(fs->super, total_free); - - /* - * Next, calculate the inode statistics - */ - group_free = 0; - total_free = 0; - count = 0; - group = 0; - - /* Protect loop from wrap-around if s_inodes_count maxed */ - for (ino = 1; ino <= fs->super->s_inodes_count && ino > 0; ino++) { - if (!ext2fs_fast_test_inode_bitmap2(fs->inode_map, ino)) { - group_free++; - total_free++; - } - count++; - if ((count == fs->super->s_inodes_per_group) || - (ino == fs->super->s_inodes_count)) { - ext2fs_bg_free_inodes_count_set(fs, group++, - group_free); - count = 0; - group_free = 0; - } - } - fs->super->s_free_inodes_count = total_free; - ext2fs_mark_super_dirty(fs); - return 0; -} #define list_for_each_safe(pos, pnext, head) \ for (pos = (head)->next, pnext = pos->next; pos != (head); \ @@ -2539,7 +2909,7 @@ static int resize_inode(ext2_filsys fs, unsigned long new_size) if (retval) goto err_out_undo; - ext2fs_calculate_summary_stats(fs); + ext2fs_calculate_summary_stats(fs, 1 /* super only */); fs->super->s_state |= EXT2_VALID_FS; /* mark super block and block bitmap as dirty */ @@ -2677,6 +3047,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 > JBD2_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) { @@ -2701,6 +3076,79 @@ fs_update_journal_user(struct ext2_super_block *sb, __u8 old_uuid[UUID_SIZE]) return 0; } +/* + * Use FS_IOC_SETFSLABEL or FS_IOC_GETFSLABEL to set/get file system label + * Return: 0 on success + * 1 on error + * -1 when the old method should be used + */ +int handle_fslabel(int setlabel) { + errcode_t ret; + int mnt_flags, fd; + char label[FSLABEL_MAX]; + int maxlen = FSLABEL_MAX - 1; + char mntpt[PATH_MAX + 1]; + +#ifdef __linux__ + ret = ext2fs_check_mount_point(device_name, &mnt_flags, + mntpt, sizeof(mntpt)); + if (ret) { + com_err(device_name, ret, _("while checking mount status")); + return 1; + } + if (!(mnt_flags & EXT2_MF_MOUNTED) || + (setlabel && (mnt_flags & EXT2_MF_READONLY))) + return -1; + + if (!mntpt[0]) { + fprintf(stderr,_("Unknown mount point for %s\n"), device_name); + return 1; + } + + fd = open(mntpt, O_RDONLY); + if (fd < 0) { + com_err(mntpt, errno, _("while opening mount point")); + return 1; + } + + /* Get fs label */ + if (!setlabel) { + if (ioctl(fd, FS_IOC_GETFSLABEL, &label)) { + close(fd); + if (errno == ENOTTY) + return -1; + com_err(mntpt, errno, _("while trying to get fs label")); + return 1; + } + close(fd); + printf("%.*s\n", EXT2_LEN_STR(label)); + return 0; + } + + /* If it's extN file system, truncate the label to appropriate size */ + if (mnt_flags & EXT2_MF_EXTFS) + maxlen = EXT2_LABEL_LEN; + if (strlen(new_label) > maxlen) { + fputs(_("Warning: label too long, truncating.\n"), + stderr); + new_label[maxlen] = '\0'; + } + + /* Set fs label */ + if (ioctl(fd, FS_IOC_SETFSLABEL, new_label)) { + close(fd); + if (errno == ENOTTY) + return -1; + com_err(mntpt, errno, _("while trying to set fs label")); + return 1; + } + close(fd); + return 0; +#else + return -1; +#endif +} + #ifndef BUILD_AS_LIB int main(int argc, char **argv) #else @@ -2713,6 +3161,9 @@ int tune2fs_main(int argc, char **argv) io_manager io_ptr, io_ptr_orig = NULL; int rc = 0; char default_undo_file[1] = { 0 }; + char mntpt[PATH_MAX + 1] = { 0 }; + int fd = -1; + struct fsuuid *fsuuid = NULL; #ifdef ENABLE_NLS setlocale(LC_MESSAGES, ""); @@ -2723,6 +3174,8 @@ int tune2fs_main(int argc, char **argv) #endif if (argc && *argv) program_name = *argv; + else + usage(); add_error_table(&et_ext2_error_table); #ifdef CONFIG_BUILD_FINDFS @@ -2742,11 +3195,27 @@ int tune2fs_main(int argc, char **argv) #endif io_ptr = unix_io_manager; + /* + * Try the get/set fs label using ioctls before we even attempt + * to open the file system. + */ + if (L_flag || print_label) { + rc = handle_fslabel(L_flag); + if (rc != -1) { +#ifndef BUILD_AS_LIB + exit(rc); +#endif + return rc; + } + rc = 0; + } + retry_open: if ((open_flag & EXT2_FLAG_RW) == 0 || f_flag) open_flag |= EXT2_FLAG_SKIP_MMP; - open_flag |= EXT2_FLAG_64BITS | EXT2_FLAG_JOURNAL_DEV_OK; + open_flag |= EXT2_FLAG_64BITS | EXT2_FLAG_THREADS | + EXT2_FLAG_JOURNAL_DEV_OK; /* keep the filesystem struct around to dump MMP data */ open_flag |= EXT2_FLAG_NOFREE_ON_ERROR; @@ -2809,8 +3278,10 @@ retry_open: rc = 1; goto closefs; } - check_fsck_needed(fs, + rc = check_fsck_needed(fs, _("Resizing inodes could take some time.")); + if (rc) + goto closefs; /* * If inode resize is requested use the * Undo I/O manager @@ -2837,24 +3308,58 @@ retry_open: if (print_label) { /* For e2label emulation */ - printf("%.*s\n", (int) sizeof(sb->s_volume_name), - sb->s_volume_name); + printf("%.*s\n", EXT2_LEN_STR(sb->s_volume_name)); remove_error_table(&et_ext2_error_table); goto closefs; } - retval = ext2fs_check_if_mounted(device_name, &mount_flags); + retval = ext2fs_check_mount_point(device_name, &mount_flags, + mntpt, sizeof(mntpt)); if (retval) { - com_err("ext2fs_check_if_mount", retval, + com_err("ext2fs_check_mount_point", retval, _("while determining whether %s is mounted."), device_name); 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)) { + printf(_("Recovering journal.\n")); + retval = ext2fs_run_ext3_journal(&fs); + if (retval) { + com_err("tune2fs", retval, + "while recovering journal.\n"); + printf(_("Please run e2fsck -fy %s.\n"), argv[1]); + if (fs) + ext2fs_close_free(&fs); + rc = 1; + goto closefs; + } + sb = fs->super; + } +#endif + /* Normally we only need to write out the superblock */ fs->flags |= EXT2_FLAG_SUPER_ONLY; if (c_flag) { + if (max_mount_count == 65536) + max_mount_count = EXT2_DFL_MAX_MNT_COUNT + + (random() % EXT2_DFL_MAX_MNT_COUNT); sb->s_max_mnt_count = max_mount_count; ext2fs_mark_super_dirty(fs); printf(_("Setting maximal mount count to %d\n"), @@ -2893,20 +3398,21 @@ retry_open: ext2fs_blocks_count(sb) / 100.0); ext2fs_mark_super_dirty(fs); printf (_("Setting reserved blocks percentage to %g%% (%llu blocks)\n"), - reserved_ratio, ext2fs_r_blocks_count(sb)); + reserved_ratio, + (unsigned long long) ext2fs_r_blocks_count(sb)); } if (r_flag) { if (reserved_blocks > ext2fs_blocks_count(sb)/2) { com_err(program_name, 0, _("reserved blocks count is too big (%llu)"), - reserved_blocks); + (unsigned long long) reserved_blocks); rc = 1; goto closefs; } ext2fs_r_blocks_count_set(sb, reserved_blocks); ext2fs_mark_super_dirty(fs); printf(_("Setting reserved blocks count to %llu\n"), - reserved_blocks); + (unsigned long long) reserved_blocks); } if (s_flag == 1) { if (ext2fs_has_feature_sparse_super(sb)) { @@ -2949,13 +3455,13 @@ retry_open: fputs(_("Warning: label too long, truncating.\n"), stderr); memset(sb->s_volume_name, 0, sizeof(sb->s_volume_name)); - strncpy(sb->s_volume_name, new_label, + strncpy((char *)sb->s_volume_name, new_label, sizeof(sb->s_volume_name)); ext2fs_mark_super_dirty(fs); } if (M_flag) { memset(sb->s_last_mounted, 0, sizeof(sb->s_last_mounted)); - strncpy(sb->s_last_mounted, new_last_mounted, + strncpy((char *)sb->s_last_mounted, new_last_mounted, sizeof(sb->s_last_mounted)); ext2fs_mark_super_dirty(fs); } @@ -2989,6 +3495,24 @@ retry_open: if (rc) goto closefs; } + if (orphan_file_blocks) { + errcode_t err; + + err = ext2fs_read_bitmaps(fs); + if (err) { + com_err(program_name, err, "%s", + _("while loading bitmaps")); + rc = 1; + goto closefs; + } + err = ext2fs_create_orphan_file(fs, orphan_file_blocks); + if (err) { + com_err(program_name, err, "%s", + _("while creating orphan file")); + rc = 1; + goto closefs; + } + } if (Q_flag) { if (mount_flags & EXT2_MF_MOUNTED) { @@ -2997,7 +3521,9 @@ retry_open: rc = 1; goto closefs; } - handle_quota_options(fs); + rc = handle_quota_options(fs); + if (rc) + goto closefs; } if (U_flag) { @@ -3005,6 +3531,26 @@ retry_open: dgrp_t i; char buf[SUPERBLOCK_SIZE] __attribute__ ((aligned(8))); __u8 old_uuid[UUID_SIZE]; + uuid_t new_uuid; + errcode_t ret = -1; + + if (ext2fs_has_feature_stable_inodes(fs->super)) { + fputs(_("Cannot change the UUID of this filesystem " + "because it has the stable_inodes feature " + "flag.\n"), stderr); + exit(1); + } + + if (!ext2fs_has_feature_csum_seed(fs->super) && + (ext2fs_has_feature_metadata_csum(fs->super) || + ext2fs_has_feature_ea_inode(fs->super))) { + rc = check_fsck_needed(fs, + _("Setting the UUID on this " + "filesystem could take some time.")); + if (rc) + goto closefs; + rewrite_checksums = REWRITE_ALL; + } if (ext2fs_has_group_desc_csum(fs)) { /* @@ -3024,12 +3570,9 @@ retry_open: "metadata_csum_seed' and re-run this " "command.\n"), stderr); try_confirm_csum_seed_support(); - exit(1); + rc = 1; + goto closefs; } - 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 @@ -3043,25 +3586,62 @@ retry_open: 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); - } else if (strcasecmp(new_UUID, "time") == 0) { - uuid_generate_time(sb->s_uuid); - } else if (strcasecmp(new_UUID, "random") == 0) { - uuid_generate(sb->s_uuid); - } else if (uuid_parse(new_UUID, sb->s_uuid)) { +#ifdef __linux__ + if ((mount_flags & EXT2_MF_MOUNTED) && + !(mount_flags & EXT2_MF_READONLY) && mntpt[0]) { + fd = open(mntpt, O_RDONLY); + if (fd >= 0) + fsuuid = malloc(sizeof(*fsuuid) + UUID_SIZE); + if (fsuuid) { + fsuuid->fsu_len = UUID_SIZE; + fsuuid->fsu_flags = 0; + ret = ioctl(fd, EXT4_IOC_GETFSUUID, fsuuid); + if (ret || fsuuid->fsu_len != UUID_SIZE) { + free(fsuuid); + fsuuid = NULL; + } + } + } +#endif + + memcpy(old_uuid, fsuuid ? fsuuid->fsu_uuid : sb->s_uuid, + UUID_SIZE); + if ((strcasecmp(requested_uuid, "null") == 0) || + (strcasecmp(requested_uuid, "clear") == 0)) { + uuid_clear(new_uuid); + } else if (strcasecmp(requested_uuid, "time") == 0) { + uuid_generate_time(new_uuid); + } else if (strcasecmp(requested_uuid, "random") == 0) { + uuid_generate(new_uuid); + } else if (uuid_parse(requested_uuid, new_uuid)) { com_err(program_name, 0, "%s", _("Invalid UUID format\n")); 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; + + ret = -1; +#ifdef __linux__ + if (fsuuid) { + fsuuid->fsu_len - UUID_SIZE; + fsuuid->fsu_flags = 0; + memcpy(&fsuuid->fsu_uuid, new_uuid, UUID_SIZE); + ret = ioctl(fd, EXT4_IOC_SETFSUUID, fsuuid); + } +#endif + /* + * If we can't set the UUID via the ioctl, fall + * back to directly modifying the superblock + .*/ + if (ret) { + memcpy(sb->s_uuid, new_uuid, UUID_SIZE); + 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; + } + ext2fs_mark_super_dirty(fs); } /* If this is a journal dev, we need to copy UUID into jsb */ @@ -3085,11 +3665,6 @@ retry_open: 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) { @@ -3121,7 +3696,7 @@ retry_open: if (retval == 0) { printf(_("Setting inode size %lu\n"), new_inode_size); - rewrite_checksums = 1; + rewrite_checksums = REWRITE_ALL; } else { printf("%s", _("Failed to change inode size\n")); rc = 1; @@ -3130,7 +3705,7 @@ retry_open: } if (rewrite_checksums) - rewrite_metadata_checksums(fs); + rewrite_metadata_checksums(fs, rewrite_checksums); if (l_flag) list_super(sb); @@ -3154,39 +3729,14 @@ retry_open: free(ext_mount_opts); } -#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_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]); - goto closefs; - } - ext2fs_clear_feature_journal_needs_recovery(fs->super); - ext2fs_mark_super_dirty(fs); - } -#endif - free(device_name); remove_error_table(&et_ext2_error_table); closefs: + if (fd >= 0) + close(fd); + if (fsuuid) + free(fsuuid); if (rc) { ext2fs_mmp_stop(fs); #ifndef BUILD_AS_LIB @@ -3194,6 +3744,7 @@ closefs: #endif } - convert_64bit(fs, feature_64bit); + if (feature_64bit) + convert_64bit(fs, feature_64bit); return (ext2fs_close_free(&fs) ? 1 : 0); }