14 files changed, 563 insertions, 196 deletions

diff --git a/fs/ext4/balloc.c b/fs/ext4/balloc.c
index cee7812cc3cf..d23b31ca9d7a 100644
--- a/fs/ext4/balloc.c
+++ b/fs/ext4/balloc.c
@@ -609,7 +609,8 @@ ext4_fsblk_t ext4_count_free_clusters(struct super_block *sb)
                 if (bitmap_bh == NULL)
                         continue;
 
-                x = ext4_count_free(bitmap_bh, sb->s_blocksize);
+                x = ext4_count_free(bitmap_bh->b_data,
+                                    EXT4_BLOCKS_PER_GROUP(sb) / 8);
                 printk(KERN_DEBUG "group %u: stored = %d, counted = %u\n",
                         i, ext4_free_group_clusters(sb, gdp), x);
                 bitmap_count += x;
diff --git a/fs/ext4/bitmap.c b/fs/ext4/bitmap.c
index b319721da26a..a94b9c63ee5c 100644
--- a/fs/ext4/bitmap.c
+++ b/fs/ext4/bitmap.c
@@ -11,24 +11,18 @@
 #include <linux/jbd2.h>
 #include "ext4.h"
 
-#ifdef EXT4FS_DEBUG
-
 static const int nibblemap[] = {4, 3, 3, 2, 3, 2, 2, 1, 3, 2, 2, 1, 2, 1, 1, 0};
 
-unsigned int ext4_count_free(struct buffer_head *map, unsigned int numchars)
+unsigned int ext4_count_free(char *bitmap, unsigned int numchars)
 {
         unsigned int i, sum = 0;
 
-        if (!map)
-                return 0;
         for (i = 0; i < numchars; i++)
-                sum += nibblemap[map->b_data[i] & 0xf] +
-                        nibblemap[(map->b_data[i] >> 4) & 0xf];
+                sum += nibblemap[bitmap[i] & 0xf] +
+                        nibblemap[(bitmap[i] >> 4) & 0xf];
         return sum;
 }
 
-#endif  /*  EXT4FS_DEBUG  */
-
 int ext4_inode_bitmap_csum_verify(struct super_block *sb, ext4_group_t group,
                                   struct ext4_group_desc *gdp,
                                   struct buffer_head *bh, int sz)
diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index cfc4e01b3c83..c3411d4ce2da 100644
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -571,6 +571,8 @@ enum {
 #define EXT4_GET_BLOCKS_NO_NORMALIZE            0x0040
         /* Request will not result in inode size update (user for fallocate) */
 #define EXT4_GET_BLOCKS_KEEP_SIZE               0x0080
+        /* Do not take i_data_sem locking in ext4_map_blocks */
+#define EXT4_GET_BLOCKS_NO_LOCK                 0x0100
 
 /*
  * Flags used by ext4_free_blocks
@@ -1161,8 +1163,7 @@ struct ext4_sb_info {
         unsigned long s_desc_per_block; /* Number of group descriptors per block */
         ext4_group_t s_groups_count;    /* Number of groups in the fs */
         ext4_group_t s_blockfile_groups;/* Groups acceptable for non-extent files */
-        unsigned long s_overhead_last;  /* Last calculated overhead */
-        unsigned long s_blocks_last;    /* Last seen block count */
+        unsigned long s_overhead;  /* # of fs overhead clusters */
         unsigned int s_cluster_ratio;   /* Number of blocks per cluster */
         unsigned int s_cluster_bits;    /* log2 of s_cluster_ratio */
         loff_t s_bitmap_maxbytes;       /* max bytes for bitmap files */
@@ -1314,6 +1315,8 @@ static inline struct timespec ext4_current_time(struct inode *inode)
 static inline int ext4_valid_inum(struct super_block *sb, unsigned long ino)
 {
         return ino == EXT4_ROOT_INO ||
+                ino == EXT4_USR_QUOTA_INO ||
+                ino == EXT4_GRP_QUOTA_INO ||
                 ino == EXT4_JOURNAL_INO ||
                 ino == EXT4_RESIZE_INO ||
                 (ino >= EXT4_FIRST_INO(sb) &&
@@ -1496,7 +1499,8 @@ static inline void ext4_clear_state_flags(struct ext4_inode_info *ei)
                                          EXT4_FEATURE_RO_COMPAT_BTREE_DIR |\
                                          EXT4_FEATURE_RO_COMPAT_HUGE_FILE |\
                                          EXT4_FEATURE_RO_COMPAT_BIGALLOC |\
-                                         EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)
+                                         EXT4_FEATURE_RO_COMPAT_METADATA_CSUM|\
+                                         EXT4_FEATURE_RO_COMPAT_QUOTA)
 
 /*
  * Default values for user and/or group using reserved blocks
@@ -1663,10 +1667,12 @@ static inline u32 ext4_chksum(struct ext4_sb_info *sbi, u32 crc,
 {
         struct {
                 struct shash_desc shash;
-                char ctx[crypto_shash_descsize(sbi->s_chksum_driver)];
+                char ctx[4];
         } desc;
         int err;
 
+        BUG_ON(crypto_shash_descsize(sbi->s_chksum_driver)!=sizeof(desc.ctx));
+
         desc.shash.tfm = sbi->s_chksum_driver;
         desc.shash.flags = 0;
         *(u32 *)desc.ctx = crc;
@@ -1852,7 +1858,7 @@ struct mmpd_data {
 # define NORET_AND      noreturn,
 
 /* bitmap.c */
-extern unsigned int ext4_count_free(struct buffer_head *, unsigned);
+extern unsigned int ext4_count_free(char *bitmap, unsigned numchars);
 void ext4_inode_bitmap_csum_set(struct super_block *sb, ext4_group_t group,
                                 struct ext4_group_desc *gdp,
                                 struct buffer_head *bh, int sz);
@@ -2037,6 +2043,7 @@ extern int ext4_group_extend(struct super_block *sb,
 extern int ext4_resize_fs(struct super_block *sb, ext4_fsblk_t n_blocks_count);
 
 /* super.c */
+extern int ext4_calculate_overhead(struct super_block *sb);
 extern int ext4_superblock_csum_verify(struct super_block *sb,
                                        struct ext4_super_block *es);
 extern void ext4_superblock_csum_set(struct super_block *sb,
@@ -2321,15 +2328,6 @@ static inline void ext4_unlock_group(struct super_block *sb,
         spin_unlock(ext4_group_lock_ptr(sb, group));
 }
 
-static inline void ext4_mark_super_dirty(struct super_block *sb)
-{
-        struct ext4_super_block *es = EXT4_SB(sb)->s_es;
-
-        ext4_superblock_csum_set(sb, es);
-        if (EXT4_SB(sb)->s_journal == NULL)
-                sb->s_dirt =1;
-}
-
 /*
  * Block validity checking
  */
diff --git a/fs/ext4/ext4_jbd2.c b/fs/ext4/ext4_jbd2.c
index 90f7c2e84db1..bfa65b49d424 100644
--- a/fs/ext4/ext4_jbd2.c
+++ b/fs/ext4/ext4_jbd2.c
@@ -138,8 +138,7 @@ int __ext4_handle_dirty_metadata(const char *where, unsigned int line,
 }
 
 int __ext4_handle_dirty_super(const char *where, unsigned int line,
-                              handle_t *handle, struct super_block *sb,
-                              int now)
+                              handle_t *handle, struct super_block *sb)
 {
         struct buffer_head *bh = EXT4_SB(sb)->s_sbh;
         int err = 0;
@@ -151,11 +150,10 @@ int __ext4_handle_dirty_super(const char *where, unsigned int line,
                 if (err)
                         ext4_journal_abort_handle(where, line, __func__,
                                                   bh, handle, err);
-        } else if (now) {
+        } else {
                 ext4_superblock_csum_set(sb,
                                 (struct ext4_super_block *)bh->b_data);
                 mark_buffer_dirty(bh);
-        } else
-                sb->s_dirt = 1;
+        }
         return err;
 }
diff --git a/fs/ext4/ext4_jbd2.h b/fs/ext4/ext4_jbd2.h
index f440e8f1841f..56d258c18303 100644
--- a/fs/ext4/ext4_jbd2.h
+++ b/fs/ext4/ext4_jbd2.h
@@ -87,14 +87,20 @@
 #ifdef CONFIG_QUOTA
 /* Amount of blocks needed for quota update - we know that the structure was
  * allocated so we need to update only data block */
-#define EXT4_QUOTA_TRANS_BLOCKS(sb) (test_opt(sb, QUOTA) ? 1 : 0)
+#define EXT4_QUOTA_TRANS_BLOCKS(sb) ((test_opt(sb, QUOTA) ||\
+                EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_QUOTA)) ?\
+                1 : 0)
 /* Amount of blocks needed for quota insert/delete - we do some block writes
  * but inode, sb and group updates are done only once */
-#define EXT4_QUOTA_INIT_BLOCKS(sb) (test_opt(sb, QUOTA) ? (DQUOT_INIT_ALLOC*\
-                (EXT4_SINGLEDATA_TRANS_BLOCKS(sb)-3)+3+DQUOT_INIT_REWRITE) : 0)
-
-#define EXT4_QUOTA_DEL_BLOCKS(sb) (test_opt(sb, QUOTA) ? (DQUOT_DEL_ALLOC*\
-                (EXT4_SINGLEDATA_TRANS_BLOCKS(sb)-3)+3+DQUOT_DEL_REWRITE) : 0)
+#define EXT4_QUOTA_INIT_BLOCKS(sb) ((test_opt(sb, QUOTA) ||\
+                EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_QUOTA)) ?\
+                (DQUOT_INIT_ALLOC*(EXT4_SINGLEDATA_TRANS_BLOCKS(sb)-3)\
+                 +3+DQUOT_INIT_REWRITE) : 0)
+
+#define EXT4_QUOTA_DEL_BLOCKS(sb) ((test_opt(sb, QUOTA) ||\
+                EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_QUOTA)) ?\
+                (DQUOT_DEL_ALLOC*(EXT4_SINGLEDATA_TRANS_BLOCKS(sb)-3)\
+                 +3+DQUOT_DEL_REWRITE) : 0)
 #else
 #define EXT4_QUOTA_TRANS_BLOCKS(sb) 0
 #define EXT4_QUOTA_INIT_BLOCKS(sb) 0
@@ -213,8 +219,7 @@ int __ext4_handle_dirty_metadata(const char *where, unsigned int line,
                                  struct buffer_head *bh);
 
 int __ext4_handle_dirty_super(const char *where, unsigned int line,
-                              handle_t *handle, struct super_block *sb,
-                              int now);
+                              handle_t *handle, struct super_block *sb);
 
 #define ext4_journal_get_write_access(handle, bh) \
         __ext4_journal_get_write_access(__func__, __LINE__, (handle), (bh))
@@ -226,10 +231,8 @@ int __ext4_handle_dirty_super(const char *where, unsigned int line,
 #define ext4_handle_dirty_metadata(handle, inode, bh) \
         __ext4_handle_dirty_metadata(__func__, __LINE__, (handle), (inode), \
                                      (bh))
-#define ext4_handle_dirty_super_now(handle, sb) \
-        __ext4_handle_dirty_super(__func__, __LINE__, (handle), (sb), 1)
 #define ext4_handle_dirty_super(handle, sb) \
-        __ext4_handle_dirty_super(__func__, __LINE__, (handle), (sb), 0)
+        __ext4_handle_dirty_super(__func__, __LINE__, (handle), (sb))
 
 handle_t *ext4_journal_start_sb(struct super_block *sb, int nblocks);
 int __ext4_journal_stop(const char *where, unsigned int line, handle_t *handle);
diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
index 91341ec6e06a..cd0c7ed06772 100644
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -1891,11 +1891,10 @@ has_space:
         nearex->ee_len = newext->ee_len;
 
 merge:
-        /* try to merge extents to the right */
+        /* try to merge extents */
         if (!(flag & EXT4_GET_BLOCKS_PRE_IO))
                 ext4_ext_try_to_merge(inode, path, nearex);
 
-        /* try to merge extents to the left */
 
         /* time to correct all indexes above */
         err = ext4_ext_correct_indexes(handle, inode, path);
@@ -2570,10 +2569,10 @@ static int ext4_ext_remove_space(struct inode *inode, ext4_lblk_t start,
 {
         struct super_block *sb = inode->i_sb;
         int depth = ext_depth(inode);
-        struct ext4_ext_path *path;
+        struct ext4_ext_path *path = NULL;
         ext4_fsblk_t partial_cluster = 0;
         handle_t *handle;
-        int i, err;
+        int i = 0, err;
 
         ext_debug("truncate since %u to %u\n", start, end);
 
@@ -2606,8 +2605,12 @@ again:
                 }
                 depth = ext_depth(inode);
                 ex = path[depth].p_ext;
-                if (!ex)
+                if (!ex) {
+                        ext4_ext_drop_refs(path);
+                        kfree(path);
+                        path = NULL;
                         goto cont;
+                }
 
                 ee_block = le32_to_cpu(ex->ee_block);
 
@@ -2637,8 +2640,6 @@ again:
                         if (err < 0)
                                 goto out;
                 }
-                ext4_ext_drop_refs(path);
-                kfree(path);
         }
 cont:
 
@@ -2647,19 +2648,27 @@ cont:
          * after i_size and walking into the tree depth-wise.
          */
         depth = ext_depth(inode);
-        path = kzalloc(sizeof(struct ext4_ext_path) * (depth + 1), GFP_NOFS);
-        if (path == NULL) {
-                ext4_journal_stop(handle);
-                return -ENOMEM;
-        }
-        path[0].p_depth = depth;
-        path[0].p_hdr = ext_inode_hdr(inode);
+        if (path) {
+                int k = i = depth;
+                while (--k > 0)
+                        path[k].p_block =
+                                le16_to_cpu(path[k].p_hdr->eh_entries)+1;
+        } else {
+                path = kzalloc(sizeof(struct ext4_ext_path) * (depth + 1),
+                               GFP_NOFS);
+                if (path == NULL) {
+                        ext4_journal_stop(handle);
+                        return -ENOMEM;
+                }
+                path[0].p_depth = depth;
+                path[0].p_hdr = ext_inode_hdr(inode);
 
-        if (ext4_ext_check(inode, path[0].p_hdr, depth)) {
-                err = -EIO;
-                goto out;
+                if (ext4_ext_check(inode, path[0].p_hdr, depth)) {
+                        err = -EIO;
+                        goto out;
+                }
         }
-        i = err = 0;
+        err = 0;
 
         while (i >= 0 && err == 0) {
                 if (i == depth) {
@@ -2773,8 +2782,10 @@ cont:
 out:
         ext4_ext_drop_refs(path);
         kfree(path);
-        if (err == -EAGAIN)
+        if (err == -EAGAIN) {
+                path = NULL;
                 goto again;
+        }
         ext4_journal_stop(handle);
 
         return err;
@@ -4420,6 +4431,8 @@ retry:
                 ext4_falloc_update_inode(inode, mode, new_size,
                                          (map.m_flags & EXT4_MAP_NEW));
                 ext4_mark_inode_dirty(handle, inode);
+                if ((file->f_flags & O_SYNC) && ret >= max_blocks)
+                        ext4_handle_sync(handle);
                 ret2 = ext4_journal_stop(handle);
                 if (ret2)
                         break;
diff --git a/fs/ext4/file.c b/fs/ext4/file.c
index 782eecb57e43..3b0e3bdaabfc 100644
--- a/fs/ext4/file.c
+++ b/fs/ext4/file.c
@@ -90,11 +90,91 @@ ext4_unaligned_aio(struct inode *inode, const struct iovec *iov,
 }
 
 static ssize_t
+ext4_file_dio_write(struct kiocb *iocb, const struct iovec *iov,
+                    unsigned long nr_segs, loff_t pos)
+{
+        struct file *file = iocb->ki_filp;
+        struct inode *inode = file->f_mapping->host;
+        struct blk_plug plug;
+        int unaligned_aio = 0;
+        ssize_t ret;
+        int overwrite = 0;
+        size_t length = iov_length(iov, nr_segs);
+
+        if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS) &&
+            !is_sync_kiocb(iocb))
+                unaligned_aio = ext4_unaligned_aio(inode, iov, nr_segs, pos);
+
+        /* Unaligned direct AIO must be serialized; see comment above */
+        if (unaligned_aio) {
+                static unsigned long unaligned_warn_time;
+
+                /* Warn about this once per day */
+                if (printk_timed_ratelimit(&unaligned_warn_time, 60*60*24*HZ))
+                        ext4_msg(inode->i_sb, KERN_WARNING,
+                                 "Unaligned AIO/DIO on inode %ld by %s; "
+                                 "performance will be poor.",
+                                 inode->i_ino, current->comm);
+                mutex_lock(ext4_aio_mutex(inode));
+                ext4_aiodio_wait(inode);
+        }
+
+        BUG_ON(iocb->ki_pos != pos);
+
+        mutex_lock(&inode->i_mutex);
+        blk_start_plug(&plug);
+
+        iocb->private = &overwrite;
+
+        /* check whether we do a DIO overwrite or not */
+        if (ext4_should_dioread_nolock(inode) && !unaligned_aio &&
+            !file->f_mapping->nrpages && pos + length <= i_size_read(inode)) {
+                struct ext4_map_blocks map;
+                unsigned int blkbits = inode->i_blkbits;
+                int err, len;
+
+                map.m_lblk = pos >> blkbits;
+                map.m_len = (EXT4_BLOCK_ALIGN(pos + length, blkbits) >> blkbits)
+                        - map.m_lblk;
+                len = map.m_len;
+
+                err = ext4_map_blocks(NULL, inode, &map, 0);
+                /*
+                 * 'err==len' means that all of blocks has been preallocated no
+                 * matter they are initialized or not.  For excluding
+                 * uninitialized extents, we need to check m_flags.  There are
+                 * two conditions that indicate for initialized extents.
+                 * 1) If we hit extent cache, EXT4_MAP_MAPPED flag is returned;
+                 * 2) If we do a real lookup, non-flags are returned.
+                 * So we should check these two conditions.
+                 */
+                if (err == len && (map.m_flags & EXT4_MAP_MAPPED))
+                        overwrite = 1;
+        }
+
+        ret = __generic_file_aio_write(iocb, iov, nr_segs, &iocb->ki_pos);
+        mutex_unlock(&inode->i_mutex);
+
+        if (ret > 0 || ret == -EIOCBQUEUED) {
+                ssize_t err;
+
+                err = generic_write_sync(file, pos, ret);
+                if (err < 0 && ret > 0)
+                        ret = err;
+        }
+        blk_finish_plug(&plug);
+
+        if (unaligned_aio)
+                mutex_unlock(ext4_aio_mutex(inode));
+
+        return ret;
+}
+
+static ssize_t
 ext4_file_write(struct kiocb *iocb, const struct iovec *iov,
                 unsigned long nr_segs, loff_t pos)
 {
         struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
-        int unaligned_aio = 0;
         ssize_t ret;
 
         /*
@@ -114,29 +194,12 @@ ext4_file_write(struct kiocb *iocb, const struct iovec *iov,
                         nr_segs = iov_shorten((struct iovec *)iov, nr_segs,
                                               sbi->s_bitmap_maxbytes - pos);
                 }
-        } else if (unlikely((iocb->ki_filp->f_flags & O_DIRECT) &&
-                   !is_sync_kiocb(iocb))) {
-                unaligned_aio = ext4_unaligned_aio(inode, iov, nr_segs, pos);
         }
 
-        /* Unaligned direct AIO must be serialized; see comment above */
-        if (unaligned_aio) {
-                static unsigned long unaligned_warn_time;
-
-                /* Warn about this once per day */
-                if (printk_timed_ratelimit(&unaligned_warn_time, 60*60*24*HZ))
-                        ext4_msg(inode->i_sb, KERN_WARNING,
-                                 "Unaligned AIO/DIO on inode %ld by %s; "
-                                 "performance will be poor.",
-                                 inode->i_ino, current->comm);
-                mutex_lock(ext4_aio_mutex(inode));
-                ext4_aiodio_wait(inode);
-        }
-
-        ret = generic_file_aio_write(iocb, iov, nr_segs, pos);
-
-        if (unaligned_aio)
-                mutex_unlock(ext4_aio_mutex(inode));
+        if (unlikely(iocb->ki_filp->f_flags & O_DIRECT))
+                ret = ext4_file_dio_write(iocb, iov, nr_segs, pos);
+        else
+                ret = generic_file_aio_write(iocb, iov, nr_segs, pos);
 
         return ret;
 }
@@ -181,9 +244,21 @@ static int ext4_file_open(struct inode * inode, struct file * filp)
                 path.dentry = mnt->mnt_root;
                 cp = d_path(&path, buf, sizeof(buf));
                 if (!IS_ERR(cp)) {
+                        handle_t *handle;
+                        int err;
+
+                        handle = ext4_journal_start_sb(sb, 1);
+                        if (IS_ERR(handle))
+                                return PTR_ERR(handle);
+                        err = ext4_journal_get_write_access(handle, sbi->s_sbh);
+                        if (err) {
+                                ext4_journal_stop(handle);
+                                return err;
+                        }
                         strlcpy(sbi->s_es->s_last_mounted, cp,
                                 sizeof(sbi->s_es->s_last_mounted));
-                        ext4_mark_super_dirty(sb);
+                        ext4_handle_dirty_super(handle, sb);
+                        ext4_journal_stop(handle);
                 }
         }
         /*
diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c
index d48e8b14928c..26154b81b836 100644
--- a/fs/ext4/ialloc.c
+++ b/fs/ext4/ialloc.c
@@ -315,7 +315,6 @@ out:
                 err = ext4_handle_dirty_metadata(handle, NULL, bitmap_bh);
                 if (!fatal)
                         fatal = err;
-                ext4_mark_super_dirty(sb);
         } else
                 ext4_error(sb, "bit already cleared for inode %lu", ino);
 
@@ -830,7 +829,6 @@ got:
         percpu_counter_dec(&sbi->s_freeinodes_counter);
         if (S_ISDIR(mode))
                 percpu_counter_inc(&sbi->s_dirs_counter);
-        ext4_mark_super_dirty(sb);
 
         if (sbi->s_log_groups_per_flex) {
                 flex_group = ext4_flex_group(sbi, group);
@@ -1054,7 +1052,8 @@ unsigned long ext4_count_free_inodes(struct super_block *sb)
                 if (!bitmap_bh)
                         continue;
 
-                x = ext4_count_free(bitmap_bh, EXT4_INODES_PER_GROUP(sb) / 8);
+                x = ext4_count_free(bitmap_bh->b_data,
+                                    EXT4_INODES_PER_GROUP(sb) / 8);
                 printk(KERN_DEBUG "group %lu: stored = %d, counted = %lu\n",
                         (unsigned long) i, ext4_free_inodes_count(sb, gdp), x);
                 bitmap_count += x;
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 02bc8cbe7281..89b59cb7f9b8 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -346,6 +346,15 @@ void ext4_da_update_reserve_space(struct inode *inode,
                 used = ei->i_reserved_data_blocks;
         }
 
+        if (unlikely(ei->i_allocated_meta_blocks > ei->i_reserved_meta_blocks)) {
+                ext4_msg(inode->i_sb, KERN_NOTICE, "%s: ino %lu, allocated %d "
+                         "with only %d reserved metadata blocks\n", __func__,
+                         inode->i_ino, ei->i_allocated_meta_blocks,
+                         ei->i_reserved_meta_blocks);
+                WARN_ON(1);
+                ei->i_allocated_meta_blocks = ei->i_reserved_meta_blocks;
+        }
+
         /* Update per-inode reservations */
         ei->i_reserved_data_blocks -= used;
         ei->i_reserved_meta_blocks -= ei->i_allocated_meta_blocks;
@@ -544,7 +553,8 @@ int ext4_map_blocks(handle_t *handle, struct inode *inode,
          * Try to see if we can get the block without requesting a new
          * file system block.
          */
-        down_read((&EXT4_I(inode)->i_data_sem));
+        if (!(flags & EXT4_GET_BLOCKS_NO_LOCK))
+                down_read((&EXT4_I(inode)->i_data_sem));
         if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
                 retval = ext4_ext_map_blocks(handle, inode, map, flags &
                                              EXT4_GET_BLOCKS_KEEP_SIZE);
@@ -552,7 +562,8 @@ int ext4_map_blocks(handle_t *handle, struct inode *inode,
                 retval = ext4_ind_map_blocks(handle, inode, map, flags &
                                              EXT4_GET_BLOCKS_KEEP_SIZE);
         }
-        up_read((&EXT4_I(inode)->i_data_sem));
+        if (!(flags & EXT4_GET_BLOCKS_NO_LOCK))
+                up_read((&EXT4_I(inode)->i_data_sem));
 
         if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED) {
                 int ret = check_block_validity(inode, map);
@@ -1171,6 +1182,17 @@ static int ext4_da_reserve_space(struct inode *inode, ext4_lblk_t lblock)
         struct ext4_inode_info *ei = EXT4_I(inode);
         unsigned int md_needed;
         int ret;
+        ext4_lblk_t save_last_lblock;
+        int save_len;
+
+        /*
+         * We will charge metadata quota at writeout time; this saves
+         * us from metadata over-estimation, though we may go over by
+         * a small amount in the end.  Here we just reserve for data.
+         */
+        ret = dquot_reserve_block(inode, EXT4_C2B(sbi, 1));
+        if (ret)
+                return ret;
 
         /*
          * recalculate the amount of metadata blocks to reserve
@@ -1179,32 +1201,31 @@ static int ext4_da_reserve_space(struct inode *inode, ext4_lblk_t lblock)
          */
 repeat:
         spin_lock(&ei->i_block_reservation_lock);
+        /*
+         * ext4_calc_metadata_amount() has side effects, which we have
+         * to be prepared undo if we fail to claim space.
+         */
+        save_len = ei->i_da_metadata_calc_len;
+        save_last_lblock = ei->i_da_metadata_calc_last_lblock;
         md_needed = EXT4_NUM_B2C(sbi,
                                  ext4_calc_metadata_amount(inode, lblock));
         trace_ext4_da_reserve_space(inode, md_needed);
-        spin_unlock(&ei->i_block_reservation_lock);
 
         /*
-         * We will charge metadata quota at writeout time; this saves
-         * us from metadata over-estimation, though we may go over by
-         * a small amount in the end.  Here we just reserve for data.
-         */
-        ret = dquot_reserve_block(inode, EXT4_C2B(sbi, 1));
-        if (ret)
-                return ret;
-        /*
          * We do still charge estimated metadata to the sb though;
          * we cannot afford to run out of free blocks.
          */
         if (ext4_claim_free_clusters(sbi, md_needed + 1, 0)) {
-                dquot_release_reservation_block(inode, EXT4_C2B(sbi, 1));
+                ei->i_da_metadata_calc_len = save_len;
+                ei->i_da_metadata_calc_last_lblock = save_last_lblock;
+                spin_unlock(&ei->i_block_reservation_lock);
                 if (ext4_should_retry_alloc(inode->i_sb, &retries)) {
                         yield();
                         goto repeat;
                 }
+                dquot_release_reservation_block(inode, EXT4_C2B(sbi, 1));
                 return -ENOSPC;
         }
-        spin_lock(&ei->i_block_reservation_lock);
         ei->i_reserved_data_blocks++;
         ei->i_reserved_meta_blocks += md_needed;
         spin_unlock(&ei->i_block_reservation_lock);
@@ -2818,6 +2839,32 @@ static int ext4_get_block_write(struct inode *inode, sector_t iblock,
                                EXT4_GET_BLOCKS_IO_CREATE_EXT);
 }
 
+static int ext4_get_block_write_nolock(struct inode *inode, sector_t iblock,
+                   struct buffer_head *bh_result, int flags)
+{
+        handle_t *handle = ext4_journal_current_handle();
+        struct ext4_map_blocks map;
+        int ret = 0;
+
+        ext4_debug("ext4_get_block_write_nolock: inode %lu, flag %d\n",
+                   inode->i_ino, flags);
+
+        flags = EXT4_GET_BLOCKS_NO_LOCK;
+
+        map.m_lblk = iblock;
+        map.m_len = bh_result->b_size >> inode->i_blkbits;
+
+        ret = ext4_map_blocks(handle, inode, &map, flags);
+        if (ret > 0) {
+                map_bh(bh_result, inode->i_sb, map.m_pblk);
+                bh_result->b_state = (bh_result->b_state & ~EXT4_MAP_FLAGS) |
+                                        map.m_flags;
+                bh_result->b_size = inode->i_sb->s_blocksize * map.m_len;
+                ret = 0;
+        }
+        return ret;
+}
+
 static void ext4_end_io_dio(struct kiocb *iocb, loff_t offset,
                             ssize_t size, void *private, int ret,
                             bool is_async)
@@ -2966,6 +3013,18 @@ static ssize_t ext4_ext_direct_IO(int rw, struct kiocb *iocb,
 
         loff_t final_size = offset + count;
         if (rw == WRITE && final_size <= inode->i_size) {
+                int overwrite = 0;
+
+                BUG_ON(iocb->private == NULL);
+
+                /* If we do a overwrite dio, i_mutex locking can be released */
+                overwrite = *((int *)iocb->private);
+
+                if (overwrite) {
+                        down_read(&EXT4_I(inode)->i_data_sem);
+                        mutex_unlock(&inode->i_mutex);
+                }
+
                 /*
                  * We could direct write to holes and fallocate.
                  *
@@ -2991,8 +3050,10 @@ static ssize_t ext4_ext_direct_IO(int rw, struct kiocb *iocb,
                 if (!is_sync_kiocb(iocb)) {
                         ext4_io_end_t *io_end =
                                 ext4_init_io_end(inode, GFP_NOFS);
-                        if (!io_end)
-                                return -ENOMEM;
+                        if (!io_end) {
+                                ret = -ENOMEM;
+                                goto retake_lock;
+                        }
                         io_end->flag |= EXT4_IO_END_DIRECT;
                         iocb->private = io_end;
                         /*
@@ -3005,13 +3066,22 @@ static ssize_t ext4_ext_direct_IO(int rw, struct kiocb *iocb,
                         EXT4_I(inode)->cur_aio_dio = iocb->private;
                 }
 
-                ret = __blockdev_direct_IO(rw, iocb, inode,
-                                         inode->i_sb->s_bdev, iov,
-                                         offset, nr_segs,
-                                         ext4_get_block_write,
-                                         ext4_end_io_dio,
-                                         NULL,
-                                         DIO_LOCKING);
+                if (overwrite)
+                        ret = __blockdev_direct_IO(rw, iocb, inode,
+                                                 inode->i_sb->s_bdev, iov,
+                                                 offset, nr_segs,
+                                                 ext4_get_block_write_nolock,
+                                                 ext4_end_io_dio,
+                                                 NULL,
+                                                 0);
+                else
+                        ret = __blockdev_direct_IO(rw, iocb, inode,
+                                                 inode->i_sb->s_bdev, iov,
+                                                 offset, nr_segs,
+                                                 ext4_get_block_write,
+                                                 ext4_end_io_dio,
+                                                 NULL,
+                                                 DIO_LOCKING);
                 if (iocb->private)
                         EXT4_I(inode)->cur_aio_dio = NULL;
                 /*
@@ -3031,7 +3101,7 @@ static ssize_t ext4_ext_direct_IO(int rw, struct kiocb *iocb,
                 if (ret != -EIOCBQUEUED && ret <= 0 && iocb->private) {
                         ext4_free_io_end(iocb->private);
                         iocb->private = NULL;
-                } else if (ret > 0 && ext4_test_inode_state(inode,
+                } else if (ret > 0 && !overwrite && ext4_test_inode_state(inode,
                                                 EXT4_STATE_DIO_UNWRITTEN)) {
                         int err;
                         /*
@@ -3044,6 +3114,14 @@ static ssize_t ext4_ext_direct_IO(int rw, struct kiocb *iocb,
                                 ret = err;
                         ext4_clear_inode_state(inode, EXT4_STATE_DIO_UNWRITTEN);
                 }
+
+        retake_lock:
+                /* take i_mutex locking again if we do a ovewrite dio */
+                if (overwrite) {
+                        up_read(&EXT4_I(inode)->i_data_sem);
+                        mutex_lock(&inode->i_mutex);
+                }
+
                 return ret;
         }
 
@@ -4034,7 +4112,7 @@ static int ext4_do_update_inode(handle_t *handle,
                         EXT4_SET_RO_COMPAT_FEATURE(sb,
                                         EXT4_FEATURE_RO_COMPAT_LARGE_FILE);
                         ext4_handle_sync(handle);
-                        err = ext4_handle_dirty_super_now(handle, sb);
+                        err = ext4_handle_dirty_super(handle, sb);
                 }
         }
         raw_inode->i_generation = cpu_to_le32(inode->i_generation);
diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
index 1cd6994fc446..8eae94771c45 100644
--- a/fs/ext4/mballoc.c
+++ b/fs/ext4/mballoc.c
@@ -969,7 +969,6 @@ static int ext4_mb_get_buddy_page_lock(struct super_block *sb,
 
         block++;
         pnum = block / blocks_per_page;
-        poff = block % blocks_per_page;
         page = find_or_create_page(inode->i_mapping, pnum, GFP_NOFS);
         if (!page)
                 return -EIO;
@@ -2077,8 +2076,9 @@ static int ext4_mb_seq_groups_show(struct seq_file *seq, void *v)
         struct super_block *sb = seq->private;
         ext4_group_t group = (ext4_group_t) ((unsigned long) v);
         int i;
-        int err;
+        int err, buddy_loaded = 0;
         struct ext4_buddy e4b;
+        struct ext4_group_info *grinfo;
         struct sg {
                 struct ext4_group_info info;
                 ext4_grpblk_t counters[16];
@@ -2095,15 +2095,21 @@ static int ext4_mb_seq_groups_show(struct seq_file *seq, void *v)
 
         i = (sb->s_blocksize_bits + 2) * sizeof(sg.info.bb_counters[0]) +
                 sizeof(struct ext4_group_info);
-        err = ext4_mb_load_buddy(sb, group, &e4b);
-        if (err) {
-                seq_printf(seq, "#%-5u: I/O error\n", group);
-                return 0;
+        grinfo = ext4_get_group_info(sb, group);
+        /* Load the group info in memory only if not already loaded. */
+        if (unlikely(EXT4_MB_GRP_NEED_INIT(grinfo))) {
+                err = ext4_mb_load_buddy(sb, group, &e4b);
+                if (err) {
+                        seq_printf(seq, "#%-5u: I/O error\n", group);
+                        return 0;
+                }
+                buddy_loaded = 1;
         }
-        ext4_lock_group(sb, group);
+
         memcpy(&sg, ext4_get_group_info(sb, group), i);
-        ext4_unlock_group(sb, group);
-        ext4_mb_unload_buddy(&e4b);
+
+        if (buddy_loaded)
+                ext4_mb_unload_buddy(&e4b);
 
         seq_printf(seq, "#%-5u: %-5u %-5u %-5u [", group, sg.info.bb_free,
                         sg.info.bb_fragments, sg.info.bb_first_free);
@@ -2825,7 +2831,6 @@ ext4_mb_mark_diskspace_used(struct ext4_allocation_context *ac,
         err = ext4_handle_dirty_metadata(handle, NULL, gdp_bh);
 
 out_err:
-        ext4_mark_super_dirty(sb);
         brelse(bitmap_bh);
         return err;
 }
@@ -4694,7 +4699,6 @@ do_more:
                 put_bh(bitmap_bh);
                 goto do_more;
         }
-        ext4_mark_super_dirty(sb);
 error_return:
         brelse(bitmap_bh);
         ext4_std_error(sb, err);
diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
index d0d3f0e87f99..2a42cc04466f 100644
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -2397,7 +2397,7 @@ int ext4_orphan_add(handle_t *handle, struct inode *inode)
         /* Insert this inode at the head of the on-disk orphan list... */
         NEXT_ORPHAN(inode) = le32_to_cpu(EXT4_SB(sb)->s_es->s_last_orphan);
         EXT4_SB(sb)->s_es->s_last_orphan = cpu_to_le32(inode->i_ino);
-        err = ext4_handle_dirty_super_now(handle, sb);
+        err = ext4_handle_dirty_super(handle, sb);
         rc = ext4_mark_iloc_dirty(handle, inode, &iloc);
         if (!err)
                 err = rc;
@@ -2470,7 +2470,7 @@ int ext4_orphan_del(handle_t *handle, struct inode *inode)
                 if (err)
                         goto out_brelse;
                 sbi->s_es->s_last_orphan = cpu_to_le32(ino_next);
-                err = ext4_handle_dirty_super_now(handle, inode->i_sb);
+                err = ext4_handle_dirty_super(handle, inode->i_sb);
         } else {
                 struct ext4_iloc iloc2;
                 struct inode *i_prev =
@@ -2918,8 +2918,15 @@ static int ext4_rename(struct inode *old_dir, struct dentry *old_dentry,
                 PARENT_INO(dir_bh->b_data, new_dir->i_sb->s_blocksize) =
                                                 cpu_to_le32(new_dir->i_ino);
                 BUFFER_TRACE(dir_bh, "call ext4_handle_dirty_metadata");
-                retval = ext4_handle_dirty_dirent_node(handle, old_inode,
-                                                       dir_bh);
+                if (is_dx(old_inode)) {
+                        retval = ext4_handle_dirty_dx_node(handle,
+                                                           old_inode,
+                                                           dir_bh);
+                } else {
+                        retval = ext4_handle_dirty_dirent_node(handle,
+                                                               old_inode,
+                                                               dir_bh);
+                }
                 if (retval) {
                         ext4_std_error(old_dir->i_sb, retval);
                         goto end_rename;
diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
index 7ea6cbb44121..41f6ef68e2e1 100644
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -798,7 +798,7 @@ static int add_new_gdb(handle_t *handle, struct inode *inode,
         ext4_kvfree(o_group_desc);
 
         le16_add_cpu(&es->s_reserved_gdt_blocks, -1);
-        err = ext4_handle_dirty_super_now(handle, sb);
+        err = ext4_handle_dirty_super(handle, sb);
         if (err)
                 ext4_std_error(sb, err);
 
@@ -1272,6 +1272,11 @@ static void ext4_update_super(struct super_block *sb,
                            &sbi->s_flex_groups[flex_group].free_inodes);
         }
 
+        /*
+         * Update the fs overhead information
+         */
+        ext4_calculate_overhead(sb);
+
         if (test_opt(sb, DEBUG))
                 printk(KERN_DEBUG "EXT4-fs: added group %u:"
                        "%llu blocks(%llu free %llu reserved)\n", flex_gd->count,
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index d8759401ecae..2d51cd9af225 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -74,7 +74,6 @@ static const char *ext4_decode_error(struct super_block *sb, int errno,
 static int ext4_remount(struct super_block *sb, int *flags, char *data);
 static int ext4_statfs(struct dentry *dentry, struct kstatfs *buf);
 static int ext4_unfreeze(struct super_block *sb);
-static void ext4_write_super(struct super_block *sb);
 static int ext4_freeze(struct super_block *sb);
 static struct dentry *ext4_mount(struct file_system_type *fs_type, int flags,
                        const char *dev_name, void *data);
@@ -896,7 +895,7 @@ static void ext4_put_super(struct super_block *sb)
                 EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
                 es->s_state = cpu_to_le16(sbi->s_mount_state);
         }
-        if (sb->s_dirt || !(sb->s_flags & MS_RDONLY))
+        if (!(sb->s_flags & MS_RDONLY))
                 ext4_commit_super(sb, 1);
 
         if (sbi->s_proc) {
@@ -1137,12 +1136,18 @@ static int ext4_mark_dquot_dirty(struct dquot *dquot);
 static int ext4_write_info(struct super_block *sb, int type);
 static int ext4_quota_on(struct super_block *sb, int type, int format_id,
                          struct path *path);
+static int ext4_quota_on_sysfile(struct super_block *sb, int type,
+                                 int format_id);
 static int ext4_quota_off(struct super_block *sb, int type);
+static int ext4_quota_off_sysfile(struct super_block *sb, int type);
 static int ext4_quota_on_mount(struct super_block *sb, int type);
 static ssize_t ext4_quota_read(struct super_block *sb, int type, char *data,
                                size_t len, loff_t off);
 static ssize_t ext4_quota_write(struct super_block *sb, int type,
                                 const char *data, size_t len, loff_t off);
+static int ext4_quota_enable(struct super_block *sb, int type, int format_id,
+                             unsigned int flags);
+static int ext4_enable_quotas(struct super_block *sb);
 
 static const struct dquot_operations ext4_quota_operations = {
         .get_reserved_space = ext4_get_reserved_space,
@@ -1164,6 +1169,16 @@ static const struct quotactl_ops ext4_qctl_operations = {
         .get_dqblk      = dquot_get_dqblk,
         .set_dqblk      = dquot_set_dqblk
 };
+
+static const struct quotactl_ops ext4_qctl_sysfile_operations = {
+        .quota_on_meta  = ext4_quota_on_sysfile,
+        .quota_off      = ext4_quota_off_sysfile,
+        .quota_sync     = dquot_quota_sync,
+        .get_info       = dquot_get_dqinfo,
+        .set_info       = dquot_set_dqinfo,
+        .get_dqblk      = dquot_get_dqblk,
+        .set_dqblk      = dquot_set_dqblk
+};
 #endif
 
 static const struct super_operations ext4_sops = {
@@ -1194,7 +1209,6 @@ static const struct super_operations ext4_nojournal_sops = {
         .dirty_inode    = ext4_dirty_inode,
         .drop_inode     = ext4_drop_inode,
         .evict_inode    = ext4_evict_inode,
-        .write_super    = ext4_write_super,
         .put_super      = ext4_put_super,
         .statfs         = ext4_statfs,
         .remount_fs     = ext4_remount,
@@ -2661,6 +2675,16 @@ static int ext4_feature_set_ok(struct super_block *sb, int readonly)
                          "extents feature\n");
                 return 0;
         }
+
+#ifndef CONFIG_QUOTA
+        if (EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_QUOTA) &&
+            !readonly) {
+                ext4_msg(sb, KERN_ERR,
+                         "Filesystem with quota feature cannot be mounted RDWR "
+                         "without CONFIG_QUOTA");
+                return 0;
+        }
+#endif  /* CONFIG_QUOTA */
         return 1;
 }
 
@@ -3085,6 +3109,114 @@ static int set_journal_csum_feature_set(struct super_block *sb)
         return ret;
 }
 
+/*
+ * Note: calculating the overhead so we can be compatible with
+ * historical BSD practice is quite difficult in the face of
+ * clusters/bigalloc.  This is because multiple metadata blocks from
+ * different block group can end up in the same allocation cluster.
+ * Calculating the exact overhead in the face of clustered allocation
+ * requires either O(all block bitmaps) in memory or O(number of block
+ * groups**2) in time.  We will still calculate the superblock for
+ * older file systems --- and if we come across with a bigalloc file
+ * system with zero in s_overhead_clusters the estimate will be close to
+ * correct especially for very large cluster sizes --- but for newer
+ * file systems, it's better to calculate this figure once at mkfs
+ * time, and store it in the superblock.  If the superblock value is
+ * present (even for non-bigalloc file systems), we will use it.
+ */
+static int count_overhead(struct super_block *sb, ext4_group_t grp,
+                          char *buf)
+{
+        struct ext4_sb_info     *sbi = EXT4_SB(sb);
+        struct ext4_group_desc  *gdp;
+        ext4_fsblk_t            first_block, last_block, b;
+        ext4_group_t            i, ngroups = ext4_get_groups_count(sb);
+        int                     s, j, count = 0;
+
+        first_block = le32_to_cpu(sbi->s_es->s_first_data_block) +
+                (grp * EXT4_BLOCKS_PER_GROUP(sb));
+        last_block = first_block + EXT4_BLOCKS_PER_GROUP(sb) - 1;
+        for (i = 0; i < ngroups; i++) {
+                gdp = ext4_get_group_desc(sb, i, NULL);
+                b = ext4_block_bitmap(sb, gdp);
+                if (b >= first_block && b <= last_block) {
+                        ext4_set_bit(EXT4_B2C(sbi, b - first_block), buf);
+                        count++;
+                }
+                b = ext4_inode_bitmap(sb, gdp);
+                if (b >= first_block && b <= last_block) {
+                        ext4_set_bit(EXT4_B2C(sbi, b - first_block), buf);
+                        count++;
+                }
+                b = ext4_inode_table(sb, gdp);
+                if (b >= first_block && b + sbi->s_itb_per_group <= last_block)
+                        for (j = 0; j < sbi->s_itb_per_group; j++, b++) {
+                                int c = EXT4_B2C(sbi, b - first_block);
+                                ext4_set_bit(c, buf);
+                                count++;
+                        }
+                if (i != grp)
+                        continue;
+                s = 0;
+                if (ext4_bg_has_super(sb, grp)) {
+                        ext4_set_bit(s++, buf);
+                        count++;
+                }
+                for (j = ext4_bg_num_gdb(sb, grp); j > 0; j--) {
+                        ext4_set_bit(EXT4_B2C(sbi, s++), buf);
+                        count++;
+                }
+        }
+        if (!count)
+                return 0;
+        return EXT4_CLUSTERS_PER_GROUP(sb) -
+                ext4_count_free(buf, EXT4_CLUSTERS_PER_GROUP(sb) / 8);
+}
+
+/*
+ * Compute the overhead and stash it in sbi->s_overhead
+ */
+int ext4_calculate_overhead(struct super_block *sb)
+{
+        struct ext4_sb_info *sbi = EXT4_SB(sb);
+        struct ext4_super_block *es = sbi->s_es;
+        ext4_group_t i, ngroups = ext4_get_groups_count(sb);
+        ext4_fsblk_t overhead = 0;
+        char *buf = (char *) get_zeroed_page(GFP_KERNEL);
+
+        memset(buf, 0, PAGE_SIZE);
+        if (!buf)
+                return -ENOMEM;
+
+        /*
+         * 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.
+         */
+
+        /*
+         * All of the blocks before first_data_block are overhead
+         */
+        overhead = EXT4_B2C(sbi, le32_to_cpu(es->s_first_data_block));
+
+        /*
+         * Add the overhead found in each block group
+         */
+        for (i = 0; i < ngroups; i++) {
+                int blks;
+
+                blks = count_overhead(sb, i, buf);
+                overhead += blks;
+                if (blks)
+                        memset(buf, 0, PAGE_SIZE);
+                cond_resched();
+        }
+        sbi->s_overhead = overhead;
+        smp_wmb();
+        free_page((unsigned long) buf);
+        return 0;
+}
+
 static int ext4_fill_super(struct super_block *sb, void *data, int silent)
 {
         char *orig_data = kstrdup(data, GFP_KERNEL);
@@ -3640,6 +3772,11 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
 #ifdef CONFIG_QUOTA
         sb->s_qcop = &ext4_qctl_operations;
         sb->dq_op = &ext4_quota_operations;
+
+        if (EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_QUOTA)) {
+                /* Use qctl operations for hidden quota files. */
+                sb->s_qcop = &ext4_qctl_sysfile_operations;
+        }
 #endif
         memcpy(sb->s_uuid, es->s_uuid, sizeof(es->s_uuid));
 
@@ -3735,6 +3872,18 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)
 
 no_journal:
         /*
+         * Get the # of file system overhead blocks from the
+         * superblock if present.
+         */
+        if (es->s_overhead_clusters)
+                sbi->s_overhead = le32_to_cpu(es->s_overhead_clusters);
+        else {
+                ret = ext4_calculate_overhead(sb);
+                if (ret)
+                        goto failed_mount_wq;
+        }
+
+        /*
          * The maximum number of concurrent works can be high and
          * concurrency isn't really necessary.  Limit it to 1.
          */
@@ -3840,6 +3989,16 @@ no_journal:
         } else
                 descr = "out journal";
 
+#ifdef CONFIG_QUOTA
+        /* Enable quota usage during mount. */
+        if (EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_QUOTA) &&
+            !(sb->s_flags & MS_RDONLY)) {
+                ret = ext4_enable_quotas(sb);
+                if (ret)
+                        goto failed_mount7;
+        }
+#endif  /* CONFIG_QUOTA */
+
         ext4_msg(sb, KERN_INFO, "mounted filesystem with%s. "
                  "Opts: %s%s%s", descr, sbi->s_es->s_mount_opts,
                  *sbi->s_es->s_mount_opts ? "; " : "", orig_data);
@@ -4203,7 +4362,6 @@ static int ext4_commit_super(struct super_block *sb, int sync)
         es->s_free_inodes_count =
                 cpu_to_le32(percpu_counter_sum_positive(
                                 &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);
@@ -4310,13 +4468,6 @@ int ext4_force_commit(struct super_block *sb)
         return ret;
 }
 
-static void ext4_write_super(struct super_block *sb)
-{
-        lock_super(sb);
-        ext4_commit_super(sb, 1);
-        unlock_super(sb);
-}
-
 static int ext4_sync_fs(struct super_block *sb, int wait)
 {
         int ret = 0;
@@ -4567,16 +4718,26 @@ static int ext4_remount(struct super_block *sb, int *flags, char *data)
         if (sbi->s_journal == NULL)
                 ext4_commit_super(sb, 1);
 
+        unlock_super(sb);
 #ifdef CONFIG_QUOTA
         /* Release old quota file names */
         for (i = 0; i < MAXQUOTAS; i++)
                 if (old_opts.s_qf_names[i] &&
                     old_opts.s_qf_names[i] != sbi->s_qf_names[i])
                         kfree(old_opts.s_qf_names[i]);
+        if (enable_quota) {
+                if (sb_any_quota_suspended(sb))
+                        dquot_resume(sb, -1);
+                else if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
+                                        EXT4_FEATURE_RO_COMPAT_QUOTA)) {
+                        err = ext4_enable_quotas(sb);
+                        if (err) {
+                                lock_super(sb);
+                                goto restore_opts;
+                        }
+                }
+        }
 #endif
-        unlock_super(sb);
-        if (enable_quota)
-                dquot_resume(sb, -1);
 
         ext4_msg(sb, KERN_INFO, "re-mounted. Opts: %s", orig_data);
         kfree(orig_data);
@@ -4605,67 +4766,21 @@ restore_opts:
         return err;
 }
 
-/*
- * Note: calculating the overhead so we can be compatible with
- * historical BSD practice is quite difficult in the face of
- * clusters/bigalloc.  This is because multiple metadata blocks from
- * different block group can end up in the same allocation cluster.
- * Calculating the exact overhead in the face of clustered allocation
- * requires either O(all block bitmaps) in memory or O(number of block
- * groups**2) in time.  We will still calculate the superblock for
- * older file systems --- and if we come across with a bigalloc file
- * system with zero in s_overhead_clusters the estimate will be close to
- * correct especially for very large cluster sizes --- but for newer
- * file systems, it's better to calculate this figure once at mkfs
- * time, and store it in the superblock.  If the superblock value is
- * present (even for non-bigalloc file systems), we will use it.
- */
 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;
-        struct ext4_group_desc *gdp;
+        ext4_fsblk_t overhead = 0;
         u64 fsid;
         s64 bfree;
 
-        if (test_opt(sb, MINIX_DF)) {
-                sbi->s_overhead_last = 0;
-        } else if (es->s_overhead_clusters) {
-                sbi->s_overhead_last = le32_to_cpu(es->s_overhead_clusters);
-        } else if (sbi->s_blocks_last != ext4_blocks_count(es)) {
-                ext4_group_t i, ngroups = ext4_get_groups_count(sb);
-                ext4_fsblk_t overhead = 0;
-
-                /*
-                 * 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.
-                 */
-
-                /*
-                 * All of the blocks before first_data_block are
-                 * overhead
-                 */
-                overhead = EXT4_B2C(sbi, le32_to_cpu(es->s_first_data_block));
-
-                /*
-                 * Add the overhead found in each block group
-                 */
-                for (i = 0; i < ngroups; i++) {
-                        gdp = ext4_get_group_desc(sb, i, NULL);
-                        overhead += ext4_num_overhead_clusters(sb, i, gdp);
-                        cond_resched();
-                }
-                sbi->s_overhead_last = overhead;
-                smp_wmb();
-                sbi->s_blocks_last = ext4_blocks_count(es);
-        }
+        if (!test_opt(sb, MINIX_DF))
+                overhead = sbi->s_overhead;
 
         buf->f_type = EXT4_SUPER_MAGIC;
         buf->f_bsize = sb->s_blocksize;
-        buf->f_blocks = (ext4_blocks_count(es) -
-                         EXT4_C2B(sbi, sbi->s_overhead_last));
+        buf->f_blocks = ext4_blocks_count(es) - EXT4_C2B(sbi, sbi->s_overhead);
         bfree = percpu_counter_sum_positive(&sbi->s_freeclusters_counter) -
                 percpu_counter_sum_positive(&sbi->s_dirtyclusters_counter);
         /* prevent underflow in case that few free space is available */
@@ -4835,6 +4950,74 @@ static int ext4_quota_on(struct super_block *sb, int type, int format_id,
         return dquot_quota_on(sb, type, format_id, path);
 }
 
+static int ext4_quota_enable(struct super_block *sb, int type, int format_id,
+                             unsigned int flags)
+{
+        int err;
+        struct inode *qf_inode;
+        unsigned long qf_inums[MAXQUOTAS] = {
+                le32_to_cpu(EXT4_SB(sb)->s_es->s_usr_quota_inum),
+                le32_to_cpu(EXT4_SB(sb)->s_es->s_grp_quota_inum)
+        };
+
+        BUG_ON(!EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_QUOTA));
+
+        if (!qf_inums[type])
+                return -EPERM;
+
+        qf_inode = ext4_iget(sb, qf_inums[type]);
+        if (IS_ERR(qf_inode)) {
+                ext4_error(sb, "Bad quota inode # %lu", qf_inums[type]);
+                return PTR_ERR(qf_inode);
+        }
+
+        err = dquot_enable(qf_inode, type, format_id, flags);
+        iput(qf_inode);
+
+        return err;
+}
+
+/* Enable usage tracking for all quota types. */
+static int ext4_enable_quotas(struct super_block *sb)
+{
+        int type, err = 0;
+        unsigned long qf_inums[MAXQUOTAS] = {
+                le32_to_cpu(EXT4_SB(sb)->s_es->s_usr_quota_inum),
+                le32_to_cpu(EXT4_SB(sb)->s_es->s_grp_quota_inum)
+        };
+
+        sb_dqopt(sb)->flags |= DQUOT_QUOTA_SYS_FILE;
+        for (type = 0; type < MAXQUOTAS; type++) {
+                if (qf_inums[type]) {
+                        err = ext4_quota_enable(sb, type, QFMT_VFS_V1,
+                                                DQUOT_USAGE_ENABLED);
+                        if (err) {
+                                ext4_warning(sb,
+                                        "Failed to enable quota (type=%d) "
+                                        "tracking. Please run e2fsck to fix.",
+                                        type);
+                                return err;
+                        }
+                }
+        }
+        return 0;
+}
+
+/*
+ * quota_on function that is used when QUOTA feature is set.
+ */
+static int ext4_quota_on_sysfile(struct super_block *sb, int type,
+                                 int format_id)
+{
+        if (!EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_QUOTA))
+                return -EINVAL;
+
+        /*
+         * USAGE was enabled at mount time. Only need to enable LIMITS now.
+         */
+        return ext4_quota_enable(sb, type, format_id, DQUOT_LIMITS_ENABLED);
+}
+
 static int ext4_quota_off(struct super_block *sb, int type)
 {
         struct inode *inode = sb_dqopt(sb)->files[type];
@@ -4861,6 +5044,18 @@ out:
         return dquot_quota_off(sb, type);
 }
 
+/*
+ * quota_off function that is used when QUOTA feature is set.
+ */
+static int ext4_quota_off_sysfile(struct super_block *sb, int type)
+{
+        if (!EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_QUOTA))
+                return -EINVAL;
+
+        /* Disable only the limits. */
+        return dquot_disable(sb, type, DQUOT_LIMITS_ENABLED);
+}
+
 /* Read data from quotafile - avoid pagecache and such because we cannot afford
  * acquiring the locks... As quota files are never truncated and quota code
  * itself serializes the operations (and no one else should touch the files)
diff --git a/fs/ext4/xattr.c b/fs/ext4/xattr.c
index e56c9ed7d6e3..2cdb98d62980 100644
--- a/fs/ext4/xattr.c
+++ b/fs/ext4/xattr.c
@@ -127,19 +127,16 @@ static __le32 ext4_xattr_block_csum(struct inode *inode,
                                     struct ext4_xattr_header *hdr)
 {
         struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
-        struct ext4_inode_info *ei = EXT4_I(inode);
         __u32 csum, old;
 
         old = hdr->h_checksum;
         hdr->h_checksum = 0;
-        if (le32_to_cpu(hdr->h_refcount) != 1) {
-                block_nr = cpu_to_le64(block_nr);
-                csum = ext4_chksum(sbi, sbi->s_csum_seed, (__u8 *)&block_nr,
-                                   sizeof(block_nr));
-        } else
-                csum = ei->i_csum_seed;
+        block_nr = cpu_to_le64(block_nr);
+        csum = ext4_chksum(sbi, sbi->s_csum_seed, (__u8 *)&block_nr,
+                           sizeof(block_nr));
         csum = ext4_chksum(sbi, csum, (__u8 *)hdr,
                            EXT4_BLOCK_SIZE(inode->i_sb));
+
         hdr->h_checksum = old;
         return cpu_to_le32(csum);
 }