1 files changed, 39 insertions, 13 deletions

diff --git a/fs/ext3/super.c b/fs/ext3/super.c
index 6e3062913a92..4f84dc86628a 100644
--- a/fs/ext3/super.c
+++ b/fs/ext3/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>
 
@@ -459,6 +461,14 @@ static struct inode *ext3_alloc_inode(struct super_block *sb)
 
 static void ext3_destroy_inode(struct inode *inode)
 {
+        if (!list_empty(&(EXT3_I(inode)->i_orphan))) {
+                printk("EXT3 Inode %p: orphan list check failed!\n",
+                        EXT3_I(inode));
+                print_hex_dump(KERN_INFO, "", DUMP_PREFIX_ADDRESS, 16, 4,
+                                EXT3_I(inode), sizeof(struct ext3_inode_info),
+                                false);
+                dump_stack();
+        }
         kmem_cache_free(ext3_inode_cachep, EXT3_I(inode));
 }
 
@@ -1566,7 +1576,7 @@ static int ext3_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 < EXT3_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
                                 "EXT3-fs: unsupported inode size: %d\n",
@@ -2075,6 +2085,7 @@ static int ext3_create_journal(struct super_block * sb,
                                unsigned int journal_inum)
 {
         journal_t *journal;
+        int err;
 
         if (sb->s_flags & MS_RDONLY) {
                 printk(KERN_ERR "EXT3-fs: readonly filesystem when trying to "
@@ -2082,13 +2093,15 @@ static int ext3_create_journal(struct super_block * sb,
                 return -EROFS;
         }
 
-        if (!(journal = ext3_get_journal(sb, journal_inum)))
+        journal = ext3_get_journal(sb, journal_inum);
+        if (!journal)
                 return -EINVAL;
 
         printk(KERN_INFO "EXT3-fs: creating new journal on inode %u\n",
                journal_inum);
 
-        if (journal_create(journal)) {
+        err = journal_create(journal);
+        if (err) {
                 printk(KERN_ERR "EXT3-fs: error creating journal.\n");
                 journal_destroy(journal);
                 return -EIO;
@@ -2139,12 +2152,14 @@ static void ext3_mark_recovery_complete(struct super_block * sb,
 
         journal_lock_updates(journal);
         journal_flush(journal);
+        lock_super(sb);
         if (EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER) &&
             sb->s_flags & MS_RDONLY) {
                 EXT3_CLEAR_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
                 sb->s_dirt = 0;
                 ext3_commit_super(sb, es, 1);
         }
+        unlock_super(sb);
         journal_unlock_updates(journal);
 }
 
@@ -2333,7 +2348,13 @@ static int ext3_remount (struct super_block * sb, int * flags, char * data)
                             (sbi->s_mount_state & EXT3_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);
                         ext3_mark_recovery_complete(sb, es);
+                        lock_super(sb);
                 } else {
                         __le32 ret;
                         if ((ret = EXT3_HAS_RO_COMPAT_FEATURE(sb,
@@ -2406,19 +2427,19 @@ static int ext3_statfs (struct dentry * dentry, struct kstatfs * buf)
         struct super_block *sb = dentry->d_sb;
         struct ext3_sb_info *sbi = EXT3_SB(sb);
         struct ext3_super_block *es = sbi->s_es;
-        ext3_fsblk_t overhead;
-        int i;
         u64 fsid;
 
-        if (test_opt (sb, MINIX_DF))
-                overhead = 0;
-        else {
-                unsigned long ngroups;
-                ngroups = EXT3_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;
+                ext3_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.
                  */
 
                 /*
@@ -2442,18 +2463,23 @@ static int ext3_statfs (struct dentry * dentry, struct kstatfs * buf)
                  * Every block group has an inode bitmap, a block
                  * bitmap, and an inode table.
                  */
-                overhead += (ngroups * (2 + EXT3_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 = EXT3_SUPER_MAGIC;
         buf->f_bsize = sb->s_blocksize;
-        buf->f_blocks = le32_to_cpu(es->s_blocks_count) - overhead;
+        buf->f_blocks = le32_to_cpu(es->s_blocks_count) - 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 - le32_to_cpu(es->s_r_blocks_count);
         if (buf->f_bfree < le32_to_cpu(es->s_r_blocks_count))
                 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 = EXT3_NAME_LEN;
         fsid = le64_to_cpup((void *)es->s_uuid) ^
                le64_to_cpup((void *)es->s_uuid + sizeof(u64));