Merge tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4

Pull Ext4 updates from Theodore Ts'o:
 "The major new feature added in this update is Darrick J Wong's
  metadata checksum feature, which adds crc32 checksums to ext4's
  metadata fields.

  There is also the usual set of cleanups and bug fixes."

* tag 'ext4_for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4: (44 commits)
  ext4: hole-punch use truncate_pagecache_range
  jbd2: use kmem_cache_zalloc wrapper instead of flag
  ext4: remove mb_groups before tearing down the buddy_cache
  ext4: add ext4_mb_unload_buddy in the error path
  ext4: don't trash state flags in EXT4_IOC_SETFLAGS
  ext4: let getattr report the right blocks in delalloc+bigalloc
  ext4: add missing save_error_info() to ext4_error()
  ext4: add debugging trigger for ext4_error()
  ext4: protect group inode free counting with group lock
  ext4: use consistent ssize_t type in ext4_file_write()
  ext4: fix format flag in ext4_ext_binsearch_idx()
  ext4: cleanup in ext4_discard_allocated_blocks()
  ext4: return ENOMEM when mounts fail due to lack of memory
  ext4: remove redundundant "(char *) bh->b_data" casts
  ext4: disallow hard-linked directory in ext4_lookup
  ext4: fix potential integer overflow in alloc_flex_gd()
  ext4: remove needs_recovery in ext4_mb_init()
  ext4: force ro mount if ext4_setup_super() fails
  ext4: fix potential NULL dereference in ext4_free_inodes_counts()
  ext4/jbd2: add metadata checksumming to the list of supported features
  ...

1 files changed, 79 insertions, 12 deletions

diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
index abcdeab67f52..91341ec6e06a 100644
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -52,6 +52,46 @@
 #define EXT4_EXT_MARK_UNINIT1   0x2  /* mark first half uninitialized */
 #define EXT4_EXT_MARK_UNINIT2   0x4  /* mark second half uninitialized */
 
+static __le32 ext4_extent_block_csum(struct inode *inode,
+                                     struct ext4_extent_header *eh)
+{
+        struct ext4_inode_info *ei = EXT4_I(inode);
+        struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
+        __u32 csum;
+
+        csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)eh,
+                           EXT4_EXTENT_TAIL_OFFSET(eh));
+        return cpu_to_le32(csum);
+}
+
+static int ext4_extent_block_csum_verify(struct inode *inode,
+                                         struct ext4_extent_header *eh)
+{
+        struct ext4_extent_tail *et;
+
+        if (!EXT4_HAS_RO_COMPAT_FEATURE(inode->i_sb,
+                EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
+                return 1;
+
+        et = find_ext4_extent_tail(eh);
+        if (et->et_checksum != ext4_extent_block_csum(inode, eh))
+                return 0;
+        return 1;
+}
+
+static void ext4_extent_block_csum_set(struct inode *inode,
+                                       struct ext4_extent_header *eh)
+{
+        struct ext4_extent_tail *et;
+
+        if (!EXT4_HAS_RO_COMPAT_FEATURE(inode->i_sb,
+                EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
+                return;
+
+        et = find_ext4_extent_tail(eh);
+        et->et_checksum = ext4_extent_block_csum(inode, eh);
+}
+
 static int ext4_split_extent(handle_t *handle,
                                 struct inode *inode,
                                 struct ext4_ext_path *path,
@@ -117,6 +157,7 @@ static int __ext4_ext_dirty(const char *where, unsigned int line,
 {
         int err;
         if (path->p_bh) {
+                ext4_extent_block_csum_set(inode, ext_block_hdr(path->p_bh));
                 /* path points to block */
                 err = __ext4_handle_dirty_metadata(where, line, handle,
                                                    inode, path->p_bh);
@@ -391,6 +432,12 @@ static int __ext4_ext_check(const char *function, unsigned int line,
                 error_msg = "invalid extent entries";
                 goto corrupted;
         }
+        /* Verify checksum on non-root extent tree nodes */
+        if (ext_depth(inode) != depth &&
+            !ext4_extent_block_csum_verify(inode, eh)) {
+                error_msg = "extent tree corrupted";
+                goto corrupted;
+        }
         return 0;
 
 corrupted:
@@ -412,6 +459,26 @@ int ext4_ext_check_inode(struct inode *inode)
         return ext4_ext_check(inode, ext_inode_hdr(inode), ext_depth(inode));
 }
 
+static int __ext4_ext_check_block(const char *function, unsigned int line,
+                                  struct inode *inode,
+                                  struct ext4_extent_header *eh,
+                                  int depth,
+                                  struct buffer_head *bh)
+{
+        int ret;
+
+        if (buffer_verified(bh))
+                return 0;
+        ret = ext4_ext_check(inode, eh, depth);
+        if (ret)
+                return ret;
+        set_buffer_verified(bh);
+        return ret;
+}
+
+#define ext4_ext_check_block(inode, eh, depth, bh)      \
+        __ext4_ext_check_block(__func__, __LINE__, inode, eh, depth, bh)
+
 #ifdef EXT_DEBUG
 static void ext4_ext_show_path(struct inode *inode, struct ext4_ext_path *path)
 {
@@ -536,7 +603,7 @@ ext4_ext_binsearch_idx(struct inode *inode,
         }
 
         path->p_idx = l - 1;
-        ext_debug("  -> %d->%lld ", le32_to_cpu(path->p_idx->ei_block),
+        ext_debug("  -> %u->%lld ", le32_to_cpu(path->p_idx->ei_block),
                   ext4_idx_pblock(path->p_idx));
 
 #ifdef CHECK_BINSEARCH
@@ -668,8 +735,6 @@ ext4_ext_find_extent(struct inode *inode, ext4_lblk_t block,
         i = depth;
         /* walk through the tree */
         while (i) {
-                int need_to_validate = 0;
-
                 ext_debug("depth %d: num %d, max %d\n",
                           ppos, le16_to_cpu(eh->eh_entries), le16_to_cpu(eh->eh_max));
 
@@ -688,8 +753,6 @@ ext4_ext_find_extent(struct inode *inode, ext4_lblk_t block,
                                 put_bh(bh);
                                 goto err;
                         }
-                        /* validate the extent entries */
-                        need_to_validate = 1;
                 }
                 eh = ext_block_hdr(bh);
                 ppos++;
@@ -703,7 +766,7 @@ ext4_ext_find_extent(struct inode *inode, ext4_lblk_t block,
                 path[ppos].p_hdr = eh;
                 i--;
 
-                if (need_to_validate && ext4_ext_check(inode, eh, i))
+                if (ext4_ext_check_block(inode, eh, i, bh))
                         goto err;
         }
 
@@ -914,6 +977,7 @@ static int ext4_ext_split(handle_t *handle, struct inode *inode,
                 le16_add_cpu(&neh->eh_entries, m);
         }
 
+        ext4_extent_block_csum_set(inode, neh);
         set_buffer_uptodate(bh);
         unlock_buffer(bh);
 
@@ -992,6 +1056,7 @@ static int ext4_ext_split(handle_t *handle, struct inode *inode,
                                 sizeof(struct ext4_extent_idx) * m);
                         le16_add_cpu(&neh->eh_entries, m);
                 }
+                ext4_extent_block_csum_set(inode, neh);
                 set_buffer_uptodate(bh);
                 unlock_buffer(bh);
 
@@ -1089,6 +1154,7 @@ static int ext4_ext_grow_indepth(handle_t *handle, struct inode *inode,
         else
                 neh->eh_max = cpu_to_le16(ext4_ext_space_block(inode, 0));
         neh->eh_magic = EXT4_EXT_MAGIC;
+        ext4_extent_block_csum_set(inode, neh);
         set_buffer_uptodate(bh);
         unlock_buffer(bh);
 
@@ -1344,7 +1410,8 @@ got_index:
                         return -EIO;
                 eh = ext_block_hdr(bh);
                 /* subtract from p_depth to get proper eh_depth */
-                if (ext4_ext_check(inode, eh, path->p_depth - depth)) {
+                if (ext4_ext_check_block(inode, eh,
+                                         path->p_depth - depth, bh)) {
                         put_bh(bh);
                         return -EIO;
                 }
@@ -1357,7 +1424,7 @@ got_index:
         if (bh == NULL)
                 return -EIO;
         eh = ext_block_hdr(bh);
-        if (ext4_ext_check(inode, eh, path->p_depth - depth)) {
+        if (ext4_ext_check_block(inode, eh, path->p_depth - depth, bh)) {
                 put_bh(bh);
                 return -EIO;
         }
@@ -2644,8 +2711,8 @@ cont:
                                 err = -EIO;
                                 break;
                         }
-                        if (ext4_ext_check(inode, ext_block_hdr(bh),
-                                                        depth - i - 1)) {
+                        if (ext4_ext_check_block(inode, ext_block_hdr(bh),
+                                                        depth - i - 1, bh)) {
                                 err = -EIO;
                                 break;
                         }
@@ -4722,8 +4789,8 @@ int ext4_ext_punch_hole(struct file *file, loff_t offset, loff_t length)
 
         /* Now release the pages */
         if (last_page_offset > first_page_offset) {
-                truncate_inode_pages_range(mapping, first_page_offset,
-                                           last_page_offset-1);
+                truncate_pagecache_range(inode, first_page_offset,
+                                         last_page_offset - 1);
         }
 
         /* finish any pending end_io work */