From: "Dr. Tilmann Bubeck" Subject: Re: [PATCH -v3] ext4: implementation of a new ioctl called EXT4_IOC_SWAP_BOOT Date: Sun, 07 Apr 2013 20:43:33 +0200 Message-ID: <5161BE55.1060502@reinform.de> References: <51023FEA.7000802@reinform.de> <20130126184927.GB20005@thunk.org> <20130407024701.GC7816@thunk.org> Mime-Version: 1.0 Content-Type: text/plain; charset=ISO-8859-1; format=flowed Content-Transfer-Encoding: 7bit Cc: linux-ext4@vger.kernel.org To: Theodore Ts'o Return-path: Received: from gw1.reinform.de ([82.141.45.9]:36535 "EHLO gw1.reinform.de" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S934267Ab3DGSni (ORCPT ); Sun, 7 Apr 2013 14:43:38 -0400 In-Reply-To: <20130407024701.GC7816@thunk.org> Sender: linux-ext4-owner@vger.kernel.org List-ID: Hi Ted, thanks for improving my patch and thanks a lot for the lessons! I appreciate this really. Feel free to improve the patch, it is getting better with every release. Thanks! Tilmann Am 07.04.2013 04:47, schrieb Theodore Ts'o: > Hi Tilmann, > > I had to make a number of changes to your patches: > > #1) If the boot inode is uninitialized, i_flags was set to zero, but > the i_data field was initialized via ext4_ext_tree_init(). As a > result, if you ran e2fsck on a freshly created file system after > running ext4-swap-boot-inode, e2fsck would complain about a corrupted > file system. (Lesson to be learned: always run e2fsck afterwards > testing the code. The file system _must_ be consistent afterwards). > > #2) Unconditionally calling ext4_ext_tree_init() means the inode will > be initialized to use extents even if the file system does not support > extents (for example, if it is an ext2 or ext3 mapped file system). > This will also cause a file system that will fail an e2fsck for a file > system formatted as ext2 or ext3 but mounted using the ext4 file > system driver. > > #3) The original version of the code called truncate_inode_pages() > after releasing i_mutex. This violates a requirement which is very > clearly documented in the comments of that function. (Lesson to be > learned: always check the implementation of functions that you're not > familiar with. This is also why defensive programming such as > including mutex_is_locked() assertions in functions is useful, since > developers don't always read function documentation...) > > #4) filemap_flush() needs to be called before you swap the inode data. > That's because the page cache is indexed by inode number and page > number. So if there is dirty page data, it needs to be flushed to the > inode *before* the messing with the inode data. > > #5) I needed to port the patch to deal with the extent status tree. > I'm guessing you probably based your patch off of the 3.7 version of > the kernel, and not the 3.8-rcX development tree. > > Here's the modified patch; if someone else on the ext4 development > team could review the patch after my modifications, I'd appreciate it. > > - Ted > > From 3de49c9eeb1303b751b92b2f554c57c686e2997d Mon Sep 17 00:00:00 2001 > From: "Dr. Tilmann Bubeck" > Date: Sat, 6 Apr 2013 22:44:18 -0400 > Subject: [PATCH] ext4: implementation of a new ioctl called EXT4_IOC_SWAP_BOOT > > Add a new ioctl, EXT4_IOC_SWAP_BOOT which swaps i_blocks and > associated attributes (like i_blocks, i_size, i_flags, ...) from > the associated inode with inode EXT4_BOOT_LOADER_INO (#5). This is > typically used to store a boot loader in a secure part of the > filesystem, where it can't be changed by the user on accident. The > data blocks of the previous boot loader will be associated with the > given inode. > > This usercode program is a simple example of the usage: > > int main(int argc, char *argv[]) > { > int fd; > int err; > > if ( argc != 2 ) { > printf("usage: ext4-swap-boot-inode FILE-TO-SWAP\n"); > exit(1); > } > > fd = open(argv[1], O_WRONLY); > if ( fd < 0 ) { > perror("open"); > exit(1); > } > > err = ioctl(fd, EXT4_IOC_SWAP_BOOT); > if ( err < 0 ) { > perror("ioctl"); > exit(1); > } > > close(fd); > exit(0); > } > > [ Modified by Theodore Ts'o to fix a number of bugs in the original code.] > > Signed-off-by: Dr. Tilmann Bubeck > Signed-off-by: "Theodore Ts'o" > --- > Documentation/filesystems/ext4.txt | 10 ++ > fs/ext4/ext4.h | 8 ++ > fs/ext4/inode.c | 11 ++- > fs/ext4/ioctl.c | 197 +++++++++++++++++++++++++++++++++++++ > fs/ext4/move_extent.c | 48 ++++----- > 5 files changed, 248 insertions(+), 26 deletions(-) > > diff --git a/Documentation/filesystems/ext4.txt b/Documentation/filesystems/ext4.txt > index 34ea4f1..69e83a4 100644 > --- a/Documentation/filesystems/ext4.txt > +++ b/Documentation/filesystems/ext4.txt > @@ -587,6 +587,16 @@ Table of Ext4 specific ioctls > bitmaps and inode table, the userspace tool thus > just passes the new number of blocks. > > +EXT4_IOC_SWAP_BOOT Swap i_blocks and associated attributes > + (like i_blocks, i_size, i_flags, ...) from > + the associated inode with inode > + EXT4_BOOT_LOADER_INO (#5). This is typically > + used to store a boot loader in a secure part of > + the filesystem, where it can't be changed by the > + user on accident. > + The data blocks of the previous boot loader > + will be associated with the given inode. > + > .............................................................................. > > References > diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h > index a0637e5..d918715 100644 > --- a/fs/ext4/ext4.h > +++ b/fs/ext4/ext4.h > @@ -616,6 +616,7 @@ enum { > #define EXT4_IOC_ALLOC_DA_BLKS _IO('f', 12) > #define EXT4_IOC_MOVE_EXT _IOWR('f', 15, struct move_extent) > #define EXT4_IOC_RESIZE_FS _IOW('f', 16, __u64) > +#define EXT4_IOC_SWAP_BOOT _IO('f', 17) > > #if defined(__KERNEL__) && defined(CONFIG_COMPAT) > /* > @@ -1341,6 +1342,7 @@ static inline int ext4_valid_inum(struct super_block *sb, unsigned long ino) > return ino == EXT4_ROOT_INO || > ino == EXT4_USR_QUOTA_INO || > ino == EXT4_GRP_QUOTA_INO || > + ino == EXT4_BOOT_LOADER_INO || > ino == EXT4_JOURNAL_INO || > ino == EXT4_RESIZE_INO || > (ino >= EXT4_FIRST_INO(sb) && > @@ -2624,6 +2626,12 @@ extern int ext4_ind_migrate(struct inode *inode); > > > /* move_extent.c */ > +extern void ext4_double_down_write_data_sem(struct inode *first, > + struct inode *second); > +extern void ext4_double_up_write_data_sem(struct inode *orig_inode, > + struct inode *donor_inode); > +void ext4_inode_double_lock(struct inode *inode1, struct inode *inode2); > +void ext4_inode_double_unlock(struct inode *inode1, struct inode *inode2); > extern int ext4_move_extents(struct file *o_filp, struct file *d_filp, > __u64 start_orig, __u64 start_donor, > __u64 len, __u64 *moved_len); > diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c > index 769c656..a29bfc2 100644 > --- a/fs/ext4/inode.c > +++ b/fs/ext4/inode.c > @@ -4191,8 +4191,9 @@ struct inode *ext4_iget(struct super_block *sb, unsigned long ino) > * NeilBrown 1999oct15 > */ > if (inode->i_nlink == 0) { > - if (inode->i_mode == 0 || > - !(EXT4_SB(inode->i_sb)->s_mount_state & EXT4_ORPHAN_FS)) { > + if ((inode->i_mode == 0 || > + !(EXT4_SB(inode->i_sb)->s_mount_state & EXT4_ORPHAN_FS)) && > + ino != EXT4_BOOT_LOADER_INO) { > /* this inode is deleted */ > ret = -ESTALE; > goto bad_inode; > @@ -4200,7 +4201,9 @@ struct inode *ext4_iget(struct super_block *sb, unsigned long ino) > /* The only unlinked inodes we let through here have > * valid i_mode and are being read by the orphan > * recovery code: that's fine, we're about to complete > - * the process of deleting those. */ > + * the process of deleting those. > + * OR it is the EXT4_BOOT_LOADER_INO which is > + * not initialized on a new filesystem. */ > } > ei->i_flags = le32_to_cpu(raw_inode->i_flags); > inode->i_blocks = ext4_inode_blocks(raw_inode, ei); > @@ -4320,6 +4323,8 @@ struct inode *ext4_iget(struct super_block *sb, unsigned long ino) > else > init_special_inode(inode, inode->i_mode, > new_decode_dev(le32_to_cpu(raw_inode->i_block[1]))); > + } else if (ino == EXT4_BOOT_LOADER_INO) { > + make_bad_inode(inode); > } else { > ret = -EIO; > EXT4_ERROR_INODE(inode, "bogus i_mode (%o)", inode->i_mode); > diff --git a/fs/ext4/ioctl.c b/fs/ext4/ioctl.c > index a07b7bc..140a8d6 100644 > --- a/fs/ext4/ioctl.c > +++ b/fs/ext4/ioctl.c > @@ -17,9 +17,201 @@ > #include > #include "ext4_jbd2.h" > #include "ext4.h" > +#include "ext4_extents.h" > > #define MAX_32_NUM ((((unsigned long long) 1) << 32) - 1) > > +/** > + * Swap memory between @a and @b for @len bytes. > + * > + * @a: pointer to first memory area > + * @b: pointer to second memory area > + * @len: number of bytes to swap > + * > + */ > +static void memswap(void *a, void *b, size_t len) > +{ > + unsigned char *ap, *bp; > + unsigned char tmp; > + > + ap = (unsigned char *)a; > + bp = (unsigned char *)b; > + while (len-- > 0) { > + tmp = *ap; > + *ap = *bp; > + *bp = tmp; > + ap++; > + bp++; > + } > +} > + > +/** > + * Swap i_data and associated attributes between inode1 and inode2. > + * This function is used for the primary swap between inode1 and inode2 > + * and also to revert this primary swap in case of errors. > + * > + * Therefore you have to make sure, that calling this method twice > + * will revert all changes. > + * > + * @inode1: pointer to first inode > + * @inode2: pointer to second inode > + */ > +static void swap_inode_data(struct inode *inode1, struct inode *inode2) > +{ > + loff_t isize; > + struct ext4_inode_info *ei1; > + struct ext4_inode_info *ei2; > + > + ei1 = EXT4_I(inode1); > + ei2 = EXT4_I(inode2); > + > + memswap(&inode1->i_flags, &inode2->i_flags, sizeof(inode1->i_flags)); > + memswap(&inode1->i_version, &inode2->i_version, > + sizeof(inode1->i_version)); > + memswap(&inode1->i_blocks, &inode2->i_blocks, > + sizeof(inode1->i_blocks)); > + memswap(&inode1->i_bytes, &inode2->i_bytes, sizeof(inode1->i_bytes)); > + memswap(&inode1->i_atime, &inode2->i_atime, sizeof(inode1->i_atime)); > + memswap(&inode1->i_mtime, &inode2->i_mtime, sizeof(inode1->i_mtime)); > + > + memswap(ei1->i_data, ei2->i_data, sizeof(ei1->i_data)); > + memswap(&ei1->i_flags, &ei2->i_flags, sizeof(ei1->i_flags)); > + memswap(&ei1->i_disksize, &ei2->i_disksize, sizeof(ei1->i_disksize)); > + memswap(&ei1->i_es_tree, &ei2->i_es_tree, sizeof(ei1->i_es_tree)); > + memswap(&ei1->i_es_lru_nr, &ei2->i_es_lru_nr, sizeof(ei1->i_es_lru_nr)); > + > + isize = i_size_read(inode1); > + i_size_write(inode1, i_size_read(inode2)); > + i_size_write(inode2, isize); > +} > + > +/** > + * Swap the information from the given @inode and the inode > + * EXT4_BOOT_LOADER_INO. It will basically swap i_data and all other > + * important fields of the inodes. > + * > + * @sb: the super block of the filesystem > + * @inode: the inode to swap with EXT4_BOOT_LOADER_INO > + * > + */ > +static long swap_inode_boot_loader(struct super_block *sb, > + struct inode *inode) > +{ > + handle_t *handle; > + int err; > + struct inode *inode_bl; > + struct ext4_inode_info *ei; > + struct ext4_inode_info *ei_bl; > + struct ext4_sb_info *sbi; > + > + if (inode->i_nlink != 1 || !S_ISREG(inode->i_mode)) { > + err = -EINVAL; > + goto swap_boot_out; > + } > + > + if (!inode_owner_or_capable(inode) || !capable(CAP_SYS_ADMIN)) { > + err = -EPERM; > + goto swap_boot_out; > + } > + > + sbi = EXT4_SB(sb); > + ei = EXT4_I(inode); > + > + inode_bl = ext4_iget(sb, EXT4_BOOT_LOADER_INO); > + if (IS_ERR(inode_bl)) { > + err = PTR_ERR(inode_bl); > + goto swap_boot_out; > + } > + ei_bl = EXT4_I(inode_bl); > + > + filemap_flush(inode->i_mapping); > + filemap_flush(inode_bl->i_mapping); > + > + /* Protect orig inodes against a truncate and make sure, > + * that only 1 swap_inode_boot_loader is running. */ > + ext4_inode_double_lock(inode, inode_bl); > + > + truncate_inode_pages(&inode->i_data, 0); > + truncate_inode_pages(&inode_bl->i_data, 0); > + > + /* Wait for all existing dio workers */ > + ext4_inode_block_unlocked_dio(inode); > + ext4_inode_block_unlocked_dio(inode_bl); > + inode_dio_wait(inode); > + inode_dio_wait(inode_bl); > + > + handle = ext4_journal_start(inode_bl, EXT4_HT_MOVE_EXTENTS, 2); > + if (IS_ERR(handle)) { > + err = -EINVAL; > + goto swap_boot_out; > + } > + > + /* Protect extent tree against block allocations via delalloc */ > + ext4_double_down_write_data_sem(inode, inode_bl); > + > + if (inode_bl->i_nlink == 0) { > + /* this inode has never been used as a BOOT_LOADER */ > + set_nlink(inode_bl, 1); > + i_uid_write(inode_bl, 0); > + i_gid_write(inode_bl, 0); > + inode_bl->i_flags = 0; > + ei_bl->i_flags = 0; > + inode_bl->i_version = 1; > + i_size_write(inode_bl, 0); > + inode_bl->i_mode = S_IFREG; > + if (EXT4_HAS_INCOMPAT_FEATURE(sb, > + EXT4_FEATURE_INCOMPAT_EXTENTS)) { > + ext4_set_inode_flag(inode_bl, EXT4_INODE_EXTENTS); > + ext4_ext_tree_init(handle, inode_bl); > + } else > + memset(ei_bl->i_data, 0, sizeof(ei_bl->i_data)); > + } > + > + swap_inode_data(inode, inode_bl); > + > + inode->i_ctime = inode_bl->i_ctime = ext4_current_time(inode); > + > + spin_lock(&sbi->s_next_gen_lock); > + inode->i_generation = sbi->s_next_generation++; > + inode_bl->i_generation = sbi->s_next_generation++; > + spin_unlock(&sbi->s_next_gen_lock); > + > + ext4_discard_preallocations(inode); > + > + err = ext4_mark_inode_dirty(handle, inode); > + if (err < 0) { > + ext4_warning(inode->i_sb, > + "couldn't mark inode #%lu dirty (err %d)", > + inode->i_ino, err); > + /* Revert all changes: */ > + swap_inode_data(inode, inode_bl); > + } else { > + err = ext4_mark_inode_dirty(handle, inode_bl); > + if (err < 0) { > + ext4_warning(inode_bl->i_sb, > + "couldn't mark inode #%lu dirty (err %d)", > + inode_bl->i_ino, err); > + /* Revert all changes: */ > + swap_inode_data(inode, inode_bl); > + ext4_mark_inode_dirty(handle, inode); > + } > + } > + > + ext4_journal_stop(handle); > + > + ext4_double_up_write_data_sem(inode, inode_bl); > + > + ext4_inode_resume_unlocked_dio(inode); > + ext4_inode_resume_unlocked_dio(inode_bl); > + > + ext4_inode_double_unlock(inode, inode_bl); > + > + iput(inode_bl); > + > +swap_boot_out: > + return err; > +} > + > long ext4_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) > { > struct inode *inode = file_inode(filp); > @@ -353,6 +545,11 @@ group_add_out: > return err; > } > > + case EXT4_IOC_SWAP_BOOT: > + if (!(filp->f_mode & FMODE_WRITE)) > + return -EBADF; > + return swap_inode_boot_loader(sb, inode); > + > case EXT4_IOC_RESIZE_FS: { > ext4_fsblk_t n_blocks_count; > struct super_block *sb = inode->i_sb; > diff --git a/fs/ext4/move_extent.c b/fs/ext4/move_extent.c > index 33e1c08..a2e696e 100644 > --- a/fs/ext4/move_extent.c > +++ b/fs/ext4/move_extent.c > @@ -144,12 +144,13 @@ mext_next_extent(struct inode *inode, struct ext4_ext_path *path, > } > > /** > - * double_down_write_data_sem - Acquire two inodes' write lock of i_data_sem > + * ext4_double_down_write_data_sem - Acquire two inodes' write lock > + * of i_data_sem > * > * Acquire write lock of i_data_sem of the two inodes > */ > -static void > -double_down_write_data_sem(struct inode *first, struct inode *second) > +void > +ext4_double_down_write_data_sem(struct inode *first, struct inode *second) > { > if (first < second) { > down_write(&EXT4_I(first)->i_data_sem); > @@ -162,14 +163,15 @@ double_down_write_data_sem(struct inode *first, struct inode *second) > } > > /** > - * double_up_write_data_sem - Release two inodes' write lock of i_data_sem > + * ext4_double_up_write_data_sem - Release two inodes' write lock of i_data_sem > * > * @orig_inode: original inode structure to be released its lock first > * @donor_inode: donor inode structure to be released its lock second > * Release write lock of i_data_sem of two inodes (orig and donor). > */ > -static void > -double_up_write_data_sem(struct inode *orig_inode, struct inode *donor_inode) > +void > +ext4_double_up_write_data_sem(struct inode *orig_inode, > + struct inode *donor_inode) > { > up_write(&EXT4_I(orig_inode)->i_data_sem); > up_write(&EXT4_I(donor_inode)->i_data_sem); > @@ -976,7 +978,7 @@ again: > * necessary, just swap data blocks between orig and donor. > */ > if (uninit) { > - double_down_write_data_sem(orig_inode, donor_inode); > + ext4_double_down_write_data_sem(orig_inode, donor_inode); > /* If any of extents in range became initialized we have to > * fallback to data copying */ > uninit = mext_check_coverage(orig_inode, orig_blk_offset, > @@ -990,7 +992,7 @@ again: > goto drop_data_sem; > > if (!uninit) { > - double_up_write_data_sem(orig_inode, donor_inode); > + ext4_double_up_write_data_sem(orig_inode, donor_inode); > goto data_copy; > } > if ((page_has_private(pagep[0]) && > @@ -1004,7 +1006,7 @@ again: > donor_inode, orig_blk_offset, > block_len_in_page, err); > drop_data_sem: > - double_up_write_data_sem(orig_inode, donor_inode); > + ext4_double_up_write_data_sem(orig_inode, donor_inode); > goto unlock_pages; > } > data_copy: > @@ -1065,11 +1067,11 @@ repair_branches: > * Extents are swapped already, but we are not able to copy data. > * Try to swap extents to it's original places > */ > - double_down_write_data_sem(orig_inode, donor_inode); > + ext4_double_down_write_data_sem(orig_inode, donor_inode); > replaced_count = mext_replace_branches(handle, donor_inode, orig_inode, > orig_blk_offset, > block_len_in_page, &err2); > - double_up_write_data_sem(orig_inode, donor_inode); > + ext4_double_up_write_data_sem(orig_inode, donor_inode); > if (replaced_count != block_len_in_page) { > EXT4_ERROR_INODE_BLOCK(orig_inode, (sector_t)(orig_blk_offset), > "Unable to copy data block," > @@ -1209,15 +1211,15 @@ mext_check_arguments(struct inode *orig_inode, > } > > /** > - * mext_inode_double_lock - Lock i_mutex on both @inode1 and @inode2 > + * ext4_inode_double_lock - Lock i_mutex on both @inode1 and @inode2 > * > * @inode1: the inode structure > * @inode2: the inode structure > * > * Lock two inodes' i_mutex > */ > -static void > -mext_inode_double_lock(struct inode *inode1, struct inode *inode2) > +void > +ext4_inode_double_lock(struct inode *inode1, struct inode *inode2) > { > BUG_ON(inode1 == inode2); > if (inode1 < inode2) { > @@ -1230,15 +1232,15 @@ mext_inode_double_lock(struct inode *inode1, struct inode *inode2) > } > > /** > - * mext_inode_double_unlock - Release i_mutex on both @inode1 and @inode2 > + * ext4_inode_double_unlock - Release i_mutex on both @inode1 and @inode2 > * > * @inode1: the inode that is released first > * @inode2: the inode that is released second > * > */ > > -static void > -mext_inode_double_unlock(struct inode *inode1, struct inode *inode2) > +void > +ext4_inode_double_unlock(struct inode *inode1, struct inode *inode2) > { > mutex_unlock(&inode1->i_mutex); > mutex_unlock(&inode2->i_mutex); > @@ -1333,7 +1335,7 @@ ext4_move_extents(struct file *o_filp, struct file *d_filp, > return -EINVAL; > } > /* Protect orig and donor inodes against a truncate */ > - mext_inode_double_lock(orig_inode, donor_inode); > + ext4_inode_double_lock(orig_inode, donor_inode); > > /* Wait for all existing dio workers */ > ext4_inode_block_unlocked_dio(orig_inode); > @@ -1342,7 +1344,7 @@ ext4_move_extents(struct file *o_filp, struct file *d_filp, > inode_dio_wait(donor_inode); > > /* Protect extent tree against block allocations via delalloc */ > - double_down_write_data_sem(orig_inode, donor_inode); > + ext4_double_down_write_data_sem(orig_inode, donor_inode); > /* Check the filesystem environment whether move_extent can be done */ > ret = mext_check_arguments(orig_inode, donor_inode, orig_start, > donor_start, &len); > @@ -1466,7 +1468,7 @@ ext4_move_extents(struct file *o_filp, struct file *d_filp, > * b. racing with ->readpage, ->write_begin, and ext4_get_block > * in move_extent_per_page > */ > - double_up_write_data_sem(orig_inode, donor_inode); > + ext4_double_up_write_data_sem(orig_inode, donor_inode); > > while (orig_page_offset <= seq_end_page) { > > @@ -1500,7 +1502,7 @@ ext4_move_extents(struct file *o_filp, struct file *d_filp, > block_len_in_page = rest_blocks; > } > > - double_down_write_data_sem(orig_inode, donor_inode); > + ext4_double_down_write_data_sem(orig_inode, donor_inode); > if (ret < 0) > break; > > @@ -1538,10 +1540,10 @@ out: > ext4_ext_drop_refs(holecheck_path); > kfree(holecheck_path); > } > - double_up_write_data_sem(orig_inode, donor_inode); > + ext4_double_up_write_data_sem(orig_inode, donor_inode); > ext4_inode_resume_unlocked_dio(orig_inode); > ext4_inode_resume_unlocked_dio(donor_inode); > - mext_inode_double_unlock(orig_inode, donor_inode); > + ext4_inode_double_unlock(orig_inode, donor_inode); > > return ret; > } > -- +-------+-------------------------------------------------------------+ | | dr. tilmann bubeck reinform medien- und | | | informationstechnologie AG | | rein | fon : +49 (711) 7 82 76-52 loeffelstr. 40 | | form | fax : +49 (711) 7 82 76-46 70597 stuttgart / germany | | AG | cell.: +49 (172) 8 84 29 72 fon: +49 (711) 75 86 56-10 | | | email: t.bubeck@reinform.de http://www.reinform.de | | +-------------------------------------------------------------+ | | pflichtangaben nach paragraph 80, AktG: | | | reinform medien- und informationstechnologie AG, stuttgart | | | handelsregister stuttgart, HRB 23001 | | | vorstand: dr. tilmann bubeck (vorsitz) | | | aufsichtsrat: frank stege (vorsitz) | +-------+-------------------------------------------------------------+