Merge remote-tracking branch 'linus/master' into testing

1 files changed, 55 insertions, 39 deletions

diff --git a/fs/gfs2/file.c b/fs/gfs2/file.c
index ad0dc38d87ab..72c3866a7320 100644
--- a/fs/gfs2/file.c
+++ b/fs/gfs2/file.c
@@ -82,35 +82,28 @@ static loff_t gfs2_llseek(struct file *file, loff_t offset, int whence)
 }
 
 /**
- * gfs2_readdir - Read directory entries from a directory
+ * gfs2_readdir - Iterator for a directory
  * @file: The directory to read from
- * @dirent: Buffer for dirents
- * @filldir: Function used to do the copying
+ * @ctx: What to feed directory entries to
  *
  * Returns: errno
  */
 
-static int gfs2_readdir(struct file *file, void *dirent, filldir_t filldir)
+static int gfs2_readdir(struct file *file, struct dir_context *ctx)
 {
         struct inode *dir = file->f_mapping->host;
         struct gfs2_inode *dip = GFS2_I(dir);
         struct gfs2_holder d_gh;
-        u64 offset = file->f_pos;
         int error;
 
-        gfs2_holder_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
-        error = gfs2_glock_nq(&d_gh);
-        if (error) {
-                gfs2_holder_uninit(&d_gh);
+        error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh);
+        if (error)
                 return error;
-        }
 
-        error = gfs2_dir_read(dir, &offset, dirent, filldir, &file->f_ra);
+        error = gfs2_dir_read(dir, ctx, &file->f_ra);
 
         gfs2_glock_dq_uninit(&d_gh);
 
-        file->f_pos = offset;
-
         return error;
 }
 
@@ -538,21 +531,30 @@ static int gfs2_mmap(struct file *file, struct vm_area_struct *vma)
 }
 
 /**
- * gfs2_open - open a file
- * @inode: the inode to open
- * @file: the struct file for this opening
+ * gfs2_open_common - This is common to open and atomic_open
+ * @inode: The inode being opened
+ * @file: The file being opened
  *
- * Returns: errno
+ * This maybe called under a glock or not depending upon how it has
+ * been called. We must always be called under a glock for regular
+ * files, however. For other file types, it does not matter whether
+ * we hold the glock or not.
+ *
+ * Returns: Error code or 0 for success
  */
 
-static int gfs2_open(struct inode *inode, struct file *file)
+int gfs2_open_common(struct inode *inode, struct file *file)
 {
-        struct gfs2_inode *ip = GFS2_I(inode);
-        struct gfs2_holder i_gh;
         struct gfs2_file *fp;
-        int error;
+        int ret;
+
+        if (S_ISREG(inode->i_mode)) {
+                ret = generic_file_open(inode, file);
+                if (ret)
+                        return ret;
+        }
 
-        fp = kzalloc(sizeof(struct gfs2_file), GFP_KERNEL);
+        fp = kzalloc(sizeof(struct gfs2_file), GFP_NOFS);
         if (!fp)
                 return -ENOMEM;
 
@@ -560,29 +562,43 @@ static int gfs2_open(struct inode *inode, struct file *file)
 
         gfs2_assert_warn(GFS2_SB(inode), !file->private_data);
         file->private_data = fp;
+        return 0;
+}
+
+/**
+ * gfs2_open - open a file
+ * @inode: the inode to open
+ * @file: the struct file for this opening
+ *
+ * After atomic_open, this function is only used for opening files
+ * which are already cached. We must still get the glock for regular
+ * files to ensure that we have the file size uptodate for the large
+ * file check which is in the common code. That is only an issue for
+ * regular files though.
+ *
+ * Returns: errno
+ */
+
+static int gfs2_open(struct inode *inode, struct file *file)
+{
+        struct gfs2_inode *ip = GFS2_I(inode);
+        struct gfs2_holder i_gh;
+        int error;
+        bool need_unlock = false;
 
         if (S_ISREG(ip->i_inode.i_mode)) {
                 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
                                            &i_gh);
                 if (error)
-                        goto fail;
+                        return error;
+                need_unlock = true;
+        }
 
-                if (!(file->f_flags & O_LARGEFILE) &&
-                    i_size_read(inode) > MAX_NON_LFS) {
-                        error = -EOVERFLOW;
-                        goto fail_gunlock;
-                }
+        error = gfs2_open_common(inode, file);
 
+        if (need_unlock)
                 gfs2_glock_dq_uninit(&i_gh);
-        }
 
-        return 0;
-
-fail_gunlock:
-        gfs2_glock_dq_uninit(&i_gh);
-fail:
-        file->private_data = NULL;
-        kfree(fp);
         return error;
 }
 
@@ -896,7 +912,7 @@ out_uninit:
  * cluster; until we do, disable leases (by just returning -EINVAL),
  * unless the administrator has requested purely local locking.
  *
- * Locking: called under lock_flocks
+ * Locking: called under i_lock
  *
  * Returns: errno
  */
@@ -1048,7 +1064,7 @@ const struct file_operations gfs2_file_fops = {
 };
 
 const struct file_operations gfs2_dir_fops = {
-        .readdir        = gfs2_readdir,
+        .iterate        = gfs2_readdir,
         .unlocked_ioctl = gfs2_ioctl,
         .open           = gfs2_open,
         .release        = gfs2_release,
@@ -1078,7 +1094,7 @@ const struct file_operations gfs2_file_fops_nolock = {
 };
 
 const struct file_operations gfs2_dir_fops_nolock = {
-        .readdir        = gfs2_readdir,
+        .iterate        = gfs2_readdir,
         .unlocked_ioctl = gfs2_ioctl,
         .open           = gfs2_open,
         .release        = gfs2_release,