1 files changed, 86 insertions, 15 deletions

diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 175b68c60968..75adbb64e028 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -29,12 +29,14 @@
 #include <linux/parser.h>
 #include <linux/smp_lock.h>
 #include <linux/buffer_head.h>
+#include <linux/exportfs.h>
 #include <linux/vfs.h>
 #include <linux/random.h>
 #include <linux/mount.h>
 #include <linux/namei.h>
 #include <linux/quotaops.h>
 #include <linux/seq_file.h>
+#include <linux/log2.h>
 
 #include <asm/uaccess.h>
 
@@ -510,6 +512,14 @@ static struct inode *ext4_alloc_inode(struct super_block *sb)
 
 static void ext4_destroy_inode(struct inode *inode)
 {
+        if (!list_empty(&(EXT4_I(inode)->i_orphan))) {
+                printk("EXT4 Inode %p: orphan list check failed!\n",
+                        EXT4_I(inode));
+                print_hex_dump(KERN_INFO, "", DUMP_PREFIX_ADDRESS, 16, 4,
+                                EXT4_I(inode), sizeof(struct ext4_inode_info),
+                                true);
+                dump_stack();
+        }
         kmem_cache_free(ext4_inode_cachep, EXT4_I(inode));
 }
 
@@ -531,7 +541,7 @@ static int init_inodecache(void)
                                              sizeof(struct ext4_inode_info),
                                              0, (SLAB_RECLAIM_ACCOUNT|
                                                 SLAB_MEM_SPREAD),
-                                             init_once, NULL);
+                                             init_once);
         if (ext4_inode_cachep == NULL)
                 return -ENOMEM;
         return 0;
@@ -725,7 +735,7 @@ enum {
         Opt_usrjquota, Opt_grpjquota, Opt_offusrjquota, Opt_offgrpjquota,
         Opt_jqfmt_vfsold, Opt_jqfmt_vfsv0, Opt_quota, Opt_noquota,
         Opt_ignore, Opt_barrier, Opt_err, Opt_resize, Opt_usrquota,
-        Opt_grpquota, Opt_extents,
+        Opt_grpquota, Opt_extents, Opt_noextents,
 };
 
 static match_table_t tokens = {
@@ -776,6 +786,7 @@ static match_table_t tokens = {
         {Opt_usrquota, "usrquota"},
         {Opt_barrier, "barrier=%u"},
         {Opt_extents, "extents"},
+        {Opt_noextents, "noextents"},
         {Opt_err, NULL},
         {Opt_resize, "resize"},
 };
@@ -1111,6 +1122,9 @@ clear_qf_name:
                 case Opt_extents:
                         set_opt (sbi->s_mount_opt, EXTENTS);
                         break;
+                case Opt_noextents:
+                        clear_opt (sbi->s_mount_opt, EXTENTS);
+                        break;
                 default:
                         printk (KERN_ERR
                                 "EXT4-fs: Unrecognized mount option \"%s\" "
@@ -1542,6 +1556,12 @@ static int ext4_fill_super (struct super_block *sb, void *data, int silent)
 
         set_opt(sbi->s_mount_opt, RESERVATION);
 
+        /*
+         * turn on extents feature by default in ext4 filesystem
+         * User -o noextents to turn it off
+         */
+        set_opt(sbi->s_mount_opt, EXTENTS);
+
         if (!parse_options ((char *) data, sb, &journal_inum, &journal_devnum,
                             NULL, 0))
                 goto failed_mount;
@@ -1625,13 +1645,15 @@ static int ext4_fill_super (struct super_block *sb, void *data, int silent)
                 sbi->s_inode_size = le16_to_cpu(es->s_inode_size);
                 sbi->s_first_ino = le32_to_cpu(es->s_first_ino);
                 if ((sbi->s_inode_size < EXT4_GOOD_OLD_INODE_SIZE) ||
-                    (sbi->s_inode_size & (sbi->s_inode_size - 1)) ||
+                    (!is_power_of_2(sbi->s_inode_size)) ||
                     (sbi->s_inode_size > blocksize)) {
                         printk (KERN_ERR
                                 "EXT4-fs: unsupported inode size: %d\n",
                                 sbi->s_inode_size);
                         goto failed_mount;
                 }
+                if (sbi->s_inode_size > EXT4_GOOD_OLD_INODE_SIZE)
+                        sb->s_time_gran = 1 << (EXT4_EPOCH_BITS - 2);
         }
         sbi->s_frag_size = EXT4_MIN_FRAG_SIZE <<
                                    le32_to_cpu(es->s_log_frag_size);
@@ -1794,6 +1816,13 @@ static int ext4_fill_super (struct super_block *sb, void *data, int silent)
                 goto failed_mount3;
         }
 
+        if (ext4_blocks_count(es) > 0xffffffffULL &&
+            !jbd2_journal_set_features(EXT4_SB(sb)->s_journal, 0, 0,
+                                       JBD2_FEATURE_INCOMPAT_64BIT)) {
+                printk(KERN_ERR "ext4: Failed to set 64-bit journal feature\n");
+                goto failed_mount4;
+        }
+
         /* We have now updated the journal if required, so we can
          * validate the data journaling mode. */
         switch (test_opt(sb, DATA_FLAGS)) {
@@ -1848,6 +1877,32 @@ static int ext4_fill_super (struct super_block *sb, void *data, int silent)
         }
 
         ext4_setup_super (sb, es, 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) {
+                sbi->s_want_extra_isize = sizeof(struct ext4_inode) -
+                                                     EXT4_GOOD_OLD_INODE_SIZE;
+                if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
+                                       EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE)) {
+                        if (sbi->s_want_extra_isize <
+                            le16_to_cpu(es->s_want_extra_isize))
+                                sbi->s_want_extra_isize =
+                                        le16_to_cpu(es->s_want_extra_isize);
+                        if (sbi->s_want_extra_isize <
+                            le16_to_cpu(es->s_min_extra_isize))
+                                sbi->s_want_extra_isize =
+                                        le16_to_cpu(es->s_min_extra_isize);
+                }
+        }
+        /* Check if enough inode space is available */
+        if (EXT4_GOOD_OLD_INODE_SIZE + sbi->s_want_extra_isize >
+                                                        sbi->s_inode_size) {
+                sbi->s_want_extra_isize = sizeof(struct ext4_inode) -
+                                                       EXT4_GOOD_OLD_INODE_SIZE;
+                printk(KERN_INFO "EXT4-fs: required extra inode space not"
+                        "available.\n");
+        }
+
         /*
          * akpm: core read_super() calls in here with the superblock locked.
          * That deadlocks, because orphan cleanup needs to lock the superblock
@@ -2150,6 +2205,7 @@ static int ext4_create_journal(struct super_block * sb,
                                unsigned int journal_inum)
 {
         journal_t *journal;
+        int err;
 
         if (sb->s_flags & MS_RDONLY) {
                 printk(KERN_ERR "EXT4-fs: readonly filesystem when trying to "
@@ -2157,13 +2213,15 @@ static int ext4_create_journal(struct super_block * sb,
                 return -EROFS;
         }
 
-        if (!(journal = ext4_get_journal(sb, journal_inum)))
+        journal = ext4_get_journal(sb, journal_inum);
+        if (!journal)
                 return -EINVAL;
 
         printk(KERN_INFO "EXT4-fs: creating new journal on inode %u\n",
                journal_inum);
 
-        if (jbd2_journal_create(journal)) {
+        err = jbd2_journal_create(journal);
+        if (err) {
                 printk(KERN_ERR "EXT4-fs: error creating journal.\n");
                 jbd2_journal_destroy(journal);
                 return -EIO;
@@ -2214,12 +2272,14 @@ static void ext4_mark_recovery_complete(struct super_block * sb,
 
         jbd2_journal_lock_updates(journal);
         jbd2_journal_flush(journal);
+        lock_super(sb);
         if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER) &&
             sb->s_flags & MS_RDONLY) {
                 EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
                 sb->s_dirt = 0;
                 ext4_commit_super(sb, es, 1);
         }
+        unlock_super(sb);
         jbd2_journal_unlock_updates(journal);
 }
 
@@ -2408,7 +2468,13 @@ static int ext4_remount (struct super_block * sb, int * flags, char * data)
                             (sbi->s_mount_state & EXT4_VALID_FS))
                                 es->s_state = cpu_to_le16(sbi->s_mount_state);
 
+                        /*
+                         * We have to unlock super so that we can wait for
+                         * transactions.
+                         */
+                        unlock_super(sb);
                         ext4_mark_recovery_complete(sb, es);
+                        lock_super(sb);
                 } else {
                         __le32 ret;
                         if ((ret = EXT4_HAS_RO_COMPAT_FEATURE(sb,
@@ -2481,19 +2547,19 @@ static int ext4_statfs (struct dentry * dentry, struct kstatfs * buf)
         struct super_block *sb = dentry->d_sb;
         struct ext4_sb_info *sbi = EXT4_SB(sb);
         struct ext4_super_block *es = sbi->s_es;
-        ext4_fsblk_t overhead;
-        int i;
         u64 fsid;
 
-        if (test_opt (sb, MINIX_DF))
-                overhead = 0;
-        else {
-                unsigned long ngroups;
-                ngroups = EXT4_SB(sb)->s_groups_count;
+        if (test_opt(sb, MINIX_DF)) {
+                sbi->s_overhead_last = 0;
+        } else if (sbi->s_blocks_last != le32_to_cpu(es->s_blocks_count)) {
+                unsigned long ngroups = sbi->s_groups_count, i;
+                ext4_fsblk_t overhead = 0;
                 smp_rmb();
 
                 /*
-                 * Compute the overhead (FS structures)
+                 * Compute the overhead (FS structures).  This is constant
+                 * for a given filesystem unless the number of block groups
+                 * changes so we cache the previous value until it does.
                  */
 
                 /*
@@ -2517,18 +2583,23 @@ static int ext4_statfs (struct dentry * dentry, struct kstatfs * buf)
                  * Every block group has an inode bitmap, a block
                  * bitmap, and an inode table.
                  */
-                overhead += (ngroups * (2 + EXT4_SB(sb)->s_itb_per_group));
+                overhead += ngroups * (2 + sbi->s_itb_per_group);
+                sbi->s_overhead_last = overhead;
+                smp_wmb();
+                sbi->s_blocks_last = le32_to_cpu(es->s_blocks_count);
         }
 
         buf->f_type = EXT4_SUPER_MAGIC;
         buf->f_bsize = sb->s_blocksize;
-        buf->f_blocks = ext4_blocks_count(es) - overhead;
+        buf->f_blocks = ext4_blocks_count(es) - sbi->s_overhead_last;
         buf->f_bfree = percpu_counter_sum(&sbi->s_freeblocks_counter);
+        es->s_free_blocks_count = cpu_to_le32(buf->f_bfree);
         buf->f_bavail = buf->f_bfree - ext4_r_blocks_count(es);
         if (buf->f_bfree < ext4_r_blocks_count(es))
                 buf->f_bavail = 0;
         buf->f_files = le32_to_cpu(es->s_inodes_count);
         buf->f_ffree = percpu_counter_sum(&sbi->s_freeinodes_counter);
+        es->s_free_inodes_count = cpu_to_le32(buf->f_ffree);
         buf->f_namelen = EXT4_NAME_LEN;
         fsid = le64_to_cpup((void *)es->s_uuid) ^
                le64_to_cpup((void *)es->s_uuid + sizeof(u64));