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, 210 insertions, 43 deletions

diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 35b5954489ee..eb7aa3e4ef05 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -112,6 +112,48 @@ static struct file_system_type ext3_fs_type = {
 #define IS_EXT3_SB(sb) (0)
 #endif
 
+static int ext4_verify_csum_type(struct super_block *sb,
+                                 struct ext4_super_block *es)
+{
+        if (!EXT4_HAS_RO_COMPAT_FEATURE(sb,
+                                        EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
+                return 1;
+
+        return es->s_checksum_type == EXT4_CRC32C_CHKSUM;
+}
+
+static __le32 ext4_superblock_csum(struct super_block *sb,
+                                   struct ext4_super_block *es)
+{
+        struct ext4_sb_info *sbi = EXT4_SB(sb);
+        int offset = offsetof(struct ext4_super_block, s_checksum);
+        __u32 csum;
+
+        csum = ext4_chksum(sbi, ~0, (char *)es, offset);
+
+        return cpu_to_le32(csum);
+}
+
+int ext4_superblock_csum_verify(struct super_block *sb,
+                                struct ext4_super_block *es)
+{
+        if (!EXT4_HAS_RO_COMPAT_FEATURE(sb,
+                                       EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
+                return 1;
+
+        return es->s_checksum == ext4_superblock_csum(sb, es);
+}
+
+void ext4_superblock_csum_set(struct super_block *sb,
+                              struct ext4_super_block *es)
+{
+        if (!EXT4_HAS_RO_COMPAT_FEATURE(sb,
+                EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
+                return;
+
+        es->s_checksum = ext4_superblock_csum(sb, es);
+}
+
 void *ext4_kvmalloc(size_t size, gfp_t flags)
 {
         void *ret;
@@ -497,6 +539,7 @@ void __ext4_error(struct super_block *sb, const char *function,
         printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: comm %s: %pV\n",
                sb->s_id, function, line, current->comm, &vaf);
         va_end(args);
+        save_error_info(sb, function, line);
 
         ext4_handle_error(sb);
 }
@@ -905,6 +948,8 @@ static void ext4_put_super(struct super_block *sb)
         unlock_super(sb);
         kobject_put(&sbi->s_kobj);
         wait_for_completion(&sbi->s_kobj_unregister);
+        if (sbi->s_chksum_driver)
+                crypto_free_shash(sbi->s_chksum_driver);
         kfree(sbi->s_blockgroup_lock);
         kfree(sbi);
 }
@@ -1922,43 +1967,69 @@ failed:
         return 0;
 }
 
-__le16 ext4_group_desc_csum(struct ext4_sb_info *sbi, __u32 block_group,
-                            struct ext4_group_desc *gdp)
+static __le16 ext4_group_desc_csum(struct ext4_sb_info *sbi, __u32 block_group,
+                                   struct ext4_group_desc *gdp)
 {
+        int offset;
         __u16 crc = 0;
+        __le32 le_group = cpu_to_le32(block_group);
 
-        if (sbi->s_es->s_feature_ro_compat &
-            cpu_to_le32(EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) {
-                int offset = offsetof(struct ext4_group_desc, bg_checksum);
-                __le32 le_group = cpu_to_le32(block_group);
-
-                crc = crc16(~0, sbi->s_es->s_uuid, sizeof(sbi->s_es->s_uuid));
-                crc = crc16(crc, (__u8 *)&le_group, sizeof(le_group));
-                crc = crc16(crc, (__u8 *)gdp, offset);
-                offset += sizeof(gdp->bg_checksum); /* skip checksum */
-                /* for checksum of struct ext4_group_desc do the rest...*/
-                if ((sbi->s_es->s_feature_incompat &
-                     cpu_to_le32(EXT4_FEATURE_INCOMPAT_64BIT)) &&
-                    offset < le16_to_cpu(sbi->s_es->s_desc_size))
-                        crc = crc16(crc, (__u8 *)gdp + offset,
-                                    le16_to_cpu(sbi->s_es->s_desc_size) -
-                                        offset);
+        if ((sbi->s_es->s_feature_ro_compat &
+             cpu_to_le32(EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))) {
+                /* Use new metadata_csum algorithm */
+                __u16 old_csum;
+                __u32 csum32;
+
+                old_csum = gdp->bg_checksum;
+                gdp->bg_checksum = 0;
+                csum32 = ext4_chksum(sbi, sbi->s_csum_seed, (__u8 *)&le_group,
+                                     sizeof(le_group));
+                csum32 = ext4_chksum(sbi, csum32, (__u8 *)gdp,
+                                     sbi->s_desc_size);
+                gdp->bg_checksum = old_csum;
+
+                crc = csum32 & 0xFFFF;
+                goto out;
         }
 
+        /* old crc16 code */
+        offset = offsetof(struct ext4_group_desc, bg_checksum);
+
+        crc = crc16(~0, sbi->s_es->s_uuid, sizeof(sbi->s_es->s_uuid));
+        crc = crc16(crc, (__u8 *)&le_group, sizeof(le_group));
+        crc = crc16(crc, (__u8 *)gdp, offset);
+        offset += sizeof(gdp->bg_checksum); /* skip checksum */
+        /* for checksum of struct ext4_group_desc do the rest...*/
+        if ((sbi->s_es->s_feature_incompat &
+             cpu_to_le32(EXT4_FEATURE_INCOMPAT_64BIT)) &&
+            offset < le16_to_cpu(sbi->s_es->s_desc_size))
+                crc = crc16(crc, (__u8 *)gdp + offset,
+                            le16_to_cpu(sbi->s_es->s_desc_size) -
+                                offset);
+
+out:
         return cpu_to_le16(crc);
 }
 
-int ext4_group_desc_csum_verify(struct ext4_sb_info *sbi, __u32 block_group,
+int ext4_group_desc_csum_verify(struct super_block *sb, __u32 block_group,
                                 struct ext4_group_desc *gdp)
 {
-        if ((sbi->s_es->s_feature_ro_compat &
-             cpu_to_le32(EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) &&
-            (gdp->bg_checksum != ext4_group_desc_csum(sbi, block_group, gdp)))
+        if (ext4_has_group_desc_csum(sb) &&
+            (gdp->bg_checksum != ext4_group_desc_csum(EXT4_SB(sb),
+                                                      block_group, gdp)))
                 return 0;
 
         return 1;
 }
 
+void ext4_group_desc_csum_set(struct super_block *sb, __u32 block_group,
+                              struct ext4_group_desc *gdp)
+{
+        if (!ext4_has_group_desc_csum(sb))
+                return;
+        gdp->bg_checksum = ext4_group_desc_csum(EXT4_SB(sb), block_group, gdp);
+}
+
 /* Called at mount-time, super-block is locked */
 static int ext4_check_descriptors(struct super_block *sb,
                                   ext4_group_t *first_not_zeroed)
@@ -2013,7 +2084,7 @@ static int ext4_check_descriptors(struct super_block *sb,
                         return 0;
                 }
                 ext4_lock_group(sb, i);
-                if (!ext4_group_desc_csum_verify(sbi, i, gdp)) {
+                if (!ext4_group_desc_csum_verify(sb, i, gdp)) {
                         ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
                                  "Checksum for group %u failed (%u!=%u)",
                                  i, le16_to_cpu(ext4_group_desc_csum(sbi, i,
@@ -2417,6 +2488,23 @@ static ssize_t sbi_ui_store(struct ext4_attr *a,
         return count;
 }
 
+static ssize_t trigger_test_error(struct ext4_attr *a,
+                                  struct ext4_sb_info *sbi,
+                                  const char *buf, size_t count)
+{
+        int len = count;
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EPERM;
+
+        if (len && buf[len-1] == '\n')
+                len--;
+
+        if (len)
+                ext4_error(sbi->s_sb, "%.*s", len, buf);
+        return count;
+}
+
 #define EXT4_ATTR_OFFSET(_name,_mode,_show,_store,_elname) \
 static struct ext4_attr ext4_attr_##_name = {                   \
         .attr = {.name = __stringify(_name), .mode = _mode },   \
@@ -2447,6 +2535,7 @@ EXT4_RW_ATTR_SBI_UI(mb_order2_req, s_mb_order2_reqs);
 EXT4_RW_ATTR_SBI_UI(mb_stream_req, s_mb_stream_request);
 EXT4_RW_ATTR_SBI_UI(mb_group_prealloc, s_mb_group_prealloc);
 EXT4_RW_ATTR_SBI_UI(max_writeback_mb_bump, s_max_writeback_mb_bump);
+EXT4_ATTR(trigger_fs_error, 0200, NULL, trigger_test_error);
 
 static struct attribute *ext4_attrs[] = {
         ATTR_LIST(delayed_allocation_blocks),
@@ -2461,6 +2550,7 @@ static struct attribute *ext4_attrs[] = {
         ATTR_LIST(mb_stream_req),
         ATTR_LIST(mb_group_prealloc),
         ATTR_LIST(max_writeback_mb_bump),
+        ATTR_LIST(trigger_fs_error),
         NULL,
 };
 
@@ -2957,6 +3047,44 @@ static void ext4_destroy_lazyinit_thread(void)
         kthread_stop(ext4_lazyinit_task);
 }
 
+static int set_journal_csum_feature_set(struct super_block *sb)
+{
+        int ret = 1;
+        int compat, incompat;
+        struct ext4_sb_info *sbi = EXT4_SB(sb);
+
+        if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
+                                       EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) {
+                /* journal checksum v2 */
+                compat = 0;
+                incompat = JBD2_FEATURE_INCOMPAT_CSUM_V2;
+        } else {
+                /* journal checksum v1 */
+                compat = JBD2_FEATURE_COMPAT_CHECKSUM;
+                incompat = 0;
+        }
+
+        if (test_opt(sb, JOURNAL_ASYNC_COMMIT)) {
+                ret = jbd2_journal_set_features(sbi->s_journal,
+                                compat, 0,
+                                JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT |
+                                incompat);
+        } else if (test_opt(sb, JOURNAL_CHECKSUM)) {
+                ret = jbd2_journal_set_features(sbi->s_journal,
+                                compat, 0,
+                                incompat);
+                jbd2_journal_clear_features(sbi->s_journal, 0, 0,
+                                JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT);
+        } else {
+                jbd2_journal_clear_features(sbi->s_journal,
+                                JBD2_FEATURE_COMPAT_CHECKSUM, 0,
+                                JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT |
+                                JBD2_FEATURE_INCOMPAT_CSUM_V2);
+        }
+
+        return ret;
+}
+
 static int ext4_fill_super(struct super_block *sb, void *data, int silent)
 {
         char *orig_data = kstrdup(data, GFP_KERNEL);
@@ -2993,6 +3121,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
                 goto out_free_orig;
         }
         sb->s_fs_info = sbi;
+        sbi->s_sb = sb;
         sbi->s_mount_opt = 0;
         sbi->s_resuid = make_kuid(&init_user_ns, EXT4_DEF_RESUID);
         sbi->s_resgid = make_kgid(&init_user_ns, EXT4_DEF_RESGID);
@@ -3032,13 +3161,54 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
          * Note: s_es must be initialized as soon as possible because
          *       some ext4 macro-instructions depend on its value
          */
-        es = (struct ext4_super_block *) (((char *)bh->b_data) + offset);
+        es = (struct ext4_super_block *) (bh->b_data + offset);
         sbi->s_es = es;
         sb->s_magic = le16_to_cpu(es->s_magic);
         if (sb->s_magic != EXT4_SUPER_MAGIC)
                 goto cantfind_ext4;
         sbi->s_kbytes_written = le64_to_cpu(es->s_kbytes_written);
 
+        /* Warn if metadata_csum and gdt_csum are both set. */
+        if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
+                                       EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) &&
+            EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_GDT_CSUM))
+                ext4_warning(sb, KERN_INFO "metadata_csum and uninit_bg are "
+                             "redundant flags; please run fsck.");
+
+        /* Check for a known checksum algorithm */
+        if (!ext4_verify_csum_type(sb, es)) {
+                ext4_msg(sb, KERN_ERR, "VFS: Found ext4 filesystem with "
+                         "unknown checksum algorithm.");
+                silent = 1;
+                goto cantfind_ext4;
+        }
+
+        /* Load the checksum driver */
+        if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
+                                       EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) {
+                sbi->s_chksum_driver = crypto_alloc_shash("crc32c", 0, 0);
+                if (IS_ERR(sbi->s_chksum_driver)) {
+                        ext4_msg(sb, KERN_ERR, "Cannot load crc32c driver.");
+                        ret = PTR_ERR(sbi->s_chksum_driver);
+                        sbi->s_chksum_driver = NULL;
+                        goto failed_mount;
+                }
+        }
+
+        /* Check superblock checksum */
+        if (!ext4_superblock_csum_verify(sb, es)) {
+                ext4_msg(sb, KERN_ERR, "VFS: Found ext4 filesystem with "
+                         "invalid superblock checksum.  Run e2fsck?");
+                silent = 1;
+                goto cantfind_ext4;
+        }
+
+        /* Precompute checksum seed for all metadata */
+        if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
+                        EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
+                sbi->s_csum_seed = ext4_chksum(sbi, ~0, es->s_uuid,
+                                               sizeof(es->s_uuid));
+
         /* Set defaults before we parse the mount options */
         def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
         set_opt(sb, INIT_INODE_TABLE);
@@ -3200,7 +3370,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
                                "Can't read superblock on 2nd try");
                         goto failed_mount;
                 }
-                es = (struct ext4_super_block *)(((char *)bh->b_data) + offset);
+                es = (struct ext4_super_block *)(bh->b_data + offset);
                 sbi->s_es = es;
                 if (es->s_magic != cpu_to_le16(EXT4_SUPER_MAGIC)) {
                         ext4_msg(sb, KERN_ERR,
@@ -3392,6 +3562,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
                                           GFP_KERNEL);
         if (sbi->s_group_desc == NULL) {
                 ext4_msg(sb, KERN_ERR, "not enough memory");
+                ret = -ENOMEM;
                 goto failed_mount;
         }
 
@@ -3449,6 +3620,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
         }
         if (err) {
                 ext4_msg(sb, KERN_ERR, "insufficient memory");
+                ret = err;
                 goto failed_mount3;
         }
 
@@ -3506,26 +3678,17 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
                 goto no_journal;
         }
 
-        if (ext4_blocks_count(es) > 0xffffffffULL &&
+        if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_64BIT) &&
             !jbd2_journal_set_features(EXT4_SB(sb)->s_journal, 0, 0,
                                        JBD2_FEATURE_INCOMPAT_64BIT)) {
                 ext4_msg(sb, KERN_ERR, "Failed to set 64-bit journal feature");
                 goto failed_mount_wq;
         }
 
-        if (test_opt(sb, JOURNAL_ASYNC_COMMIT)) {
-                jbd2_journal_set_features(sbi->s_journal,
-                                JBD2_FEATURE_COMPAT_CHECKSUM, 0,
-                                JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT);
-        } else if (test_opt(sb, JOURNAL_CHECKSUM)) {
-                jbd2_journal_set_features(sbi->s_journal,
-                                JBD2_FEATURE_COMPAT_CHECKSUM, 0, 0);
-                jbd2_journal_clear_features(sbi->s_journal, 0, 0,
-                                JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT);
-        } else {
-                jbd2_journal_clear_features(sbi->s_journal,
-                                JBD2_FEATURE_COMPAT_CHECKSUM, 0,
-                                JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT);
+        if (!set_journal_csum_feature_set(sb)) {
+                ext4_msg(sb, KERN_ERR, "Failed to set journal checksum "
+                         "feature set");
+                goto failed_mount_wq;
         }
 
         /* We have now updated the journal if required, so we can
@@ -3606,7 +3769,8 @@ no_journal:
                 goto failed_mount4;
         }
 
-        ext4_setup_super(sb, es, sb->s_flags & MS_RDONLY);
+        if (ext4_setup_super(sb, es, sb->s_flags & MS_RDONLY))
+                sb->s_flags |= MS_RDONLY;
 
         /* determine the minimum size of new large inodes, if present */
         if (sbi->s_inode_size > EXT4_GOOD_OLD_INODE_SIZE) {
@@ -3641,7 +3805,7 @@ no_journal:
         }
 
         ext4_ext_init(sb);
-        err = ext4_mb_init(sb, needs_recovery);
+        err = ext4_mb_init(sb);
         if (err) {
                 ext4_msg(sb, KERN_ERR, "failed to initialize mballoc (%d)",
                          err);
@@ -3724,6 +3888,8 @@ failed_mount2:
                 brelse(sbi->s_group_desc[i]);
         ext4_kvfree(sbi->s_group_desc);
 failed_mount:
+        if (sbi->s_chksum_driver)
+                crypto_free_shash(sbi->s_chksum_driver);
         if (sbi->s_proc) {
                 remove_proc_entry("options", sbi->s_proc);
                 remove_proc_entry(sb->s_id, ext4_proc_root);
@@ -3847,7 +4013,7 @@ static journal_t *ext4_get_dev_journal(struct super_block *sb,
                 goto out_bdev;
         }
 
-        es = (struct ext4_super_block *) (((char *)bh->b_data) + offset);
+        es = (struct ext4_super_block *) (bh->b_data + offset);
         if ((le16_to_cpu(es->s_magic) != EXT4_SUPER_MAGIC) ||
             !(le32_to_cpu(es->s_feature_incompat) &
               EXT4_FEATURE_INCOMPAT_JOURNAL_DEV)) {
@@ -4039,6 +4205,7 @@ static int ext4_commit_super(struct super_block *sb, int sync)
                                 &EXT4_SB(sb)->s_freeinodes_counter));
         sb->s_dirt = 0;
         BUFFER_TRACE(sbh, "marking dirty");
+        ext4_superblock_csum_set(sb, es);
         mark_buffer_dirty(sbh);
         if (sync) {
                 error = sync_dirty_buffer(sbh);
@@ -4333,7 +4500,7 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data)
                                 struct ext4_group_desc *gdp =
                                         ext4_get_group_desc(sb, g, NULL);
 
-                                if (!ext4_group_desc_csum_verify(sbi, g, gdp)) {
+                                if (!ext4_group_desc_csum_verify(sb, g, gdp)) {
                                         ext4_msg(sb, KERN_ERR,
                "ext4_remount: Checksum for group %u failed (%u!=%u)",
                 g, le16_to_cpu(ext4_group_desc_csum(sbi, g, gdp)),