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
specified 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 a normal user by 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 <t.bubeck@reinform.de>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>

1 files changed, 25 insertions, 23 deletions

diff --git a/fs/ext4/move_extent.c b/fs/ext4/move_extent.c
index 33e1c086858b..a2e696e16331 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;
 }