Merge commit 'c039c332f23e794deb6d6f37b9f07ff3b27fb2cf' into md

Pull in pre-requisites for adding raid10 support to dm-raid.

6 files changed, 32 insertions, 81 deletions

diff --git a/fs/ext4/dir.c b/fs/ext4/dir.c
index aa39e600d159..8e07d2a5a139 100644
--- a/fs/ext4/dir.c
+++ b/fs/ext4/dir.c
@@ -324,74 +324,27 @@ static inline loff_t ext4_get_htree_eof(struct file *filp)
 
 
 /*
- * ext4_dir_llseek() based on generic_file_llseek() to handle both
- * non-htree and htree directories, where the "offset" is in terms
- * of the filename hash value instead of the byte offset.
+ * ext4_dir_llseek() calls generic_file_llseek_size to handle htree
+ * directories, where the "offset" is in terms of the filename hash
+ * value instead of the byte offset.
  *
- * NOTE: offsets obtained *before* ext4_set_inode_flag(dir, EXT4_INODE_INDEX)
- *       will be invalid once the directory was converted into a dx directory
+ * Because we may return a 64-bit hash that is well beyond offset limits,
+ * we need to pass the max hash as the maximum allowable offset in
+ * the htree directory case.
+ *
+ * For non-htree, ext4_llseek already chooses the proper max offset.
  */
 loff_t ext4_dir_llseek(struct file *file, loff_t offset, int origin)
 {
         struct inode *inode = file->f_mapping->host;
-        loff_t ret = -EINVAL;
         int dx_dir = is_dx_dir(inode);
+        loff_t htree_max = ext4_get_htree_eof(file);
 
-        mutex_lock(&inode->i_mutex);
-
-        /* NOTE: relative offsets with dx directories might not work
-         *       as expected, as it is difficult to figure out the
-         *       correct offset between dx hashes */
-
-        switch (origin) {
-        case SEEK_END:
-                if (unlikely(offset > 0))
-                        goto out_err; /* not supported for directories */
-
-                /* so only negative offsets are left, does that have a
-                 * meaning for directories at all? */
-                if (dx_dir)
-                        offset += ext4_get_htree_eof(file);
-                else
-                        offset += inode->i_size;
-                break;
-        case SEEK_CUR:
-                /*
-                 * Here we special-case the lseek(fd, 0, SEEK_CUR)
-                 * position-querying operation.  Avoid rewriting the "same"
-                 * f_pos value back to the file because a concurrent read(),
-                 * write() or lseek() might have altered it
-                 */
-                if (offset == 0) {
-                        offset = file->f_pos;
-                        goto out_ok;
-                }
-
-                offset += file->f_pos;
-                break;
-        }
-
-        if (unlikely(offset < 0))
-                goto out_err;
-
-        if (!dx_dir) {
-                if (offset > inode->i_sb->s_maxbytes)
-                        goto out_err;
-        } else if (offset > ext4_get_htree_eof(file))
-                goto out_err;
-
-        /* Special lock needed here? */
-        if (offset != file->f_pos) {
-                file->f_pos = offset;
-                file->f_version = 0;
-        }
-
-out_ok:
-        ret = offset;
-out_err:
-        mutex_unlock(&inode->i_mutex);
-
-        return ret;
+        if (likely(dx_dir))
+                return generic_file_llseek_size(file, offset, origin,
+                                                    htree_max, htree_max);
+        else
+                return ext4_llseek(file, offset, origin);
 }
 
 /*
diff --git a/fs/ext4/file.c b/fs/ext4/file.c
index 8c7642a00054..782eecb57e43 100644
--- a/fs/ext4/file.c
+++ b/fs/ext4/file.c
@@ -211,9 +211,9 @@ static int ext4_file_open(struct inode * inode, struct file * filp)
 }
 
 /*
- * ext4_llseek() copied from generic_file_llseek() to handle both
- * block-mapped and extent-mapped maxbytes values. This should
- * otherwise be identical with generic_file_llseek().
+ * ext4_llseek() handles both block-mapped and extent-mapped maxbytes values
+ * by calling generic_file_llseek_size() with the appropriate maxbytes
+ * value for each.
  */
 loff_t ext4_llseek(struct file *file, loff_t offset, int origin)
 {
@@ -225,7 +225,8 @@ loff_t ext4_llseek(struct file *file, loff_t offset, int origin)
         else
                 maxbytes = inode->i_sb->s_maxbytes;
 
-        return generic_file_llseek_size(file, offset, origin, maxbytes);
+        return generic_file_llseek_size(file, offset, origin,
+                                        maxbytes, i_size_read(inode));
 }
 
 const struct file_operations ext4_file_operations = {
diff --git a/fs/ext4/fsync.c b/fs/ext4/fsync.c
index bb6c7d811313..2a1dcea4f12e 100644
--- a/fs/ext4/fsync.c
+++ b/fs/ext4/fsync.c
@@ -135,14 +135,7 @@ static int ext4_sync_parent(struct inode *inode)
         inode = igrab(inode);
         while (ext4_test_inode_state(inode, EXT4_STATE_NEWENTRY)) {
                 ext4_clear_inode_state(inode, EXT4_STATE_NEWENTRY);
-                dentry = NULL;
-                spin_lock(&inode->i_lock);
-                if (!list_empty(&inode->i_dentry)) {
-                        dentry = list_first_entry(&inode->i_dentry,
-                                                  struct dentry, d_alias);
-                        dget(dentry);
-                }
-                spin_unlock(&inode->i_lock);
+                dentry = d_find_any_alias(inode);
                 if (!dentry)
                         break;
                 next = igrab(dentry->d_parent->d_inode);
@@ -232,7 +225,7 @@ int ext4_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
 
         if (!journal) {
                 ret = __sync_inode(inode, datasync);
-                if (!ret && !list_empty(&inode->i_dentry))
+                if (!ret && !hlist_empty(&inode->i_dentry))
                         ret = ext4_sync_parent(inode);
                 goto out;
         }
diff --git a/fs/ext4/ioctl.c b/fs/ext4/ioctl.c
index e34deac3f366..7f7dad787603 100644
--- a/fs/ext4/ioctl.c
+++ b/fs/ext4/ioctl.c
@@ -268,7 +268,6 @@ group_extend_out:
                 err = ext4_move_extents(filp, donor_filp, me.orig_start,
                                         me.donor_start, me.len, &me.moved_len);
                 mnt_drop_write_file(filp);
-                mnt_drop_write(filp->f_path.mnt);
 
                 if (copy_to_user((struct move_extent __user *)arg,
                                  &me, sizeof(me)))
@@ -390,7 +389,7 @@ group_add_out:
                 if (err)
                         return err;
 
-                err = mnt_want_write(filp->f_path.mnt);
+                err = mnt_want_write_file(filp);
                 if (err)
                         goto resizefs_out;
 
@@ -402,7 +401,7 @@ group_add_out:
                 }
                 if (err == 0)
                         err = err2;
-                mnt_drop_write(filp->f_path.mnt);
+                mnt_drop_write_file(filp);
 resizefs_out:
                 ext4_resize_end(sb);
                 return err;
diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
index 5845cd97bf8b..d0d3f0e87f99 100644
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -1312,7 +1312,7 @@ errout:
         return NULL;
 }
 
-static struct dentry *ext4_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
+static struct dentry *ext4_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
 {
         struct inode *inode;
         struct ext4_dir_entry_2 *de;
@@ -2072,8 +2072,8 @@ static int ext4_add_nondir(handle_t *handle,
         int err = ext4_add_entry(handle, dentry, inode);
         if (!err) {
                 ext4_mark_inode_dirty(handle, inode);
-                d_instantiate(dentry, inode);
                 unlock_new_inode(inode);
+                d_instantiate(dentry, inode);
                 return 0;
         }
         drop_nlink(inode);
@@ -2091,7 +2091,7 @@ static int ext4_add_nondir(handle_t *handle,
  * with d_instantiate().
  */
 static int ext4_create(struct inode *dir, struct dentry *dentry, umode_t mode,
-                       struct nameidata *nd)
+                       bool excl)
 {
         handle_t *handle;
         struct inode *inode;
@@ -2249,8 +2249,8 @@ out_clear_inode:
         err = ext4_mark_inode_dirty(handle, dir);
         if (err)
                 goto out_clear_inode;
-        d_instantiate(dentry, inode);
         unlock_new_inode(inode);
+        d_instantiate(dentry, inode);
 out_stop:
         brelse(dir_block);
         ext4_journal_stop(handle);
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index eb7aa3e4ef05..d8759401ecae 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -4325,6 +4325,11 @@ static int ext4_sync_fs(struct super_block *sb, int wait)
 
         trace_ext4_sync_fs(sb, wait);
         flush_workqueue(sbi->dio_unwritten_wq);
+        /*
+         * Writeback quota in non-journalled quota case - journalled quota has
+         * no dirty dquots
+         */
+        dquot_writeback_dquots(sb, -1);
         if (jbd2_journal_start_commit(sbi->s_journal, &target)) {
                 if (wait)
                         jbd2_log_wait_commit(sbi->s_journal, target);