introduce a parallel variant of ->iterate()

New method: ->iterate_shared().  Same arguments as in ->iterate(),
called with the directory locked only shared.  Once all filesystems
switch, the old one will be gone.

Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

5 files changed, 48 insertions, 11 deletions

diff --git a/Documentation/filesystems/porting b/Documentation/filesystems/porting
index 1567a53857bd..12c57abdaac9 100644
--- a/Documentation/filesystems/porting
+++ b/Documentation/filesystems/porting
@@ -557,3 +557,21 @@ in your dentry operations instead.
         will not happen in parallel ("same" in the sense of your ->d_compare()).
         Lookups on different names in the same directory can and do happen in
         parallel now.
+--
+[recommended]
+        ->iterate_shared() is added; it's a parallel variant of ->iterate().
+        Exclusion on struct file level is still provided (as well as that
+        between it and lseek on the same struct file), but if your directory
+        has been opened several times, you can get these called in parallel.
+        Exclusion between that method and all directory-modifying ones is
+        still provided, of course.
+
+        Often enough ->iterate() can serve as ->iterate_shared() without any
+        changes - it is a read-only operation, after all.  If you have any
+        per-inode or per-dentry in-core data structures modified by ->iterate(),
+        you might need something to serialize the access to them.  If you
+        do dcache pre-seeding, you'll need to switch to d_alloc_parallel() for
+        that; look for in-tree examples.
+
+        Old method is only used if the new one is absent; eventually it will
+        be removed.  Switch while you still can; the old one won't stay.
diff --git a/fs/coda/dir.c b/fs/coda/dir.c
index 42e731b8c80a..6fb8672c0892 100644
--- a/fs/coda/dir.c
+++ b/fs/coda/dir.c
@@ -424,16 +424,22 @@ static int coda_readdir(struct file *coda_file, struct dir_context *ctx)
         BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC);
         host_file = cfi->cfi_container;
 
-        if (host_file->f_op->iterate) {
+        if (host_file->f_op->iterate || host_file->f_op->iterate_shared) {
                 struct inode *host_inode = file_inode(host_file);
-
-                inode_lock(host_inode);
                 ret = -ENOENT;
                 if (!IS_DEADDIR(host_inode)) {
-                        ret = host_file->f_op->iterate(host_file, ctx);
-                        file_accessed(host_file);
+                        if (host_file->f_op->iterate_shared) {
+                                inode_lock_shared(host_inode);
+                                ret = host_file->f_op->iterate_shared(host_file, ctx);
+                                file_accessed(host_file);
+                                inode_unlock_shared(host_inode);
+                        } else {
+                                inode_lock(host_inode);
+                                ret = host_file->f_op->iterate(host_file, ctx);
+                                file_accessed(host_file);
+                                inode_unlock(host_inode);
+                        }
                 }
-                inode_unlock(host_inode);
                 return ret;
         }
         /* Venus: we must read Venus dirents from a file */
diff --git a/fs/exportfs/expfs.c b/fs/exportfs/expfs.c
index 402c5caab5ca..207ba8d627ca 100644
--- a/fs/exportfs/expfs.c
+++ b/fs/exportfs/expfs.c
@@ -312,7 +312,7 @@ static int get_name(const struct path *path, char *name, struct dentry *child)
                 goto out;
 
         error = -EINVAL;
-        if (!file->f_op->iterate)
+        if (!file->f_op->iterate && !file->f_op->iterate_shared)
                 goto out_close;
 
         buffer.sequence = 0;
diff --git a/fs/readdir.c b/fs/readdir.c
index d7308b8f6cf7..a86c6c04b9bc 100644
--- a/fs/readdir.c
+++ b/fs/readdir.c
@@ -24,15 +24,21 @@
 int iterate_dir(struct file *file, struct dir_context *ctx)
 {
         struct inode *inode = file_inode(file);
+        bool shared = false;
         int res = -ENOTDIR;
-        if (!file->f_op->iterate)
+        if (file->f_op->iterate_shared)
+                shared = true;
+        else if (!file->f_op->iterate)
                 goto out;
 
         res = security_file_permission(file, MAY_READ);
         if (res)
                 goto out;
 
-        inode_lock(inode);
+        if (shared)
+                inode_lock_shared(inode);
+        else
+                inode_lock(inode);
         // res = mutex_lock_killable(&inode->i_mutex);
         // if (res)
         //      goto out;
@@ -40,12 +46,18 @@ int iterate_dir(struct file *file, struct dir_context *ctx)
         res = -ENOENT;
         if (!IS_DEADDIR(inode)) {
                 ctx->pos = file->f_pos;
-                res = file->f_op->iterate(file, ctx);
+                if (shared)
+                        res = file->f_op->iterate_shared(file, ctx);
+                else
+                        res = file->f_op->iterate(file, ctx);
                 file->f_pos = ctx->pos;
                 fsnotify_access(file);
                 file_accessed(file);
         }
-        inode_unlock(inode);
+        if (shared)
+                inode_unlock_shared(inode);
+        else
+                inode_unlock(inode);
 out:
         return res;
 }
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 3018f31f7aa0..3dc0258a2b64 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -1674,6 +1674,7 @@ struct file_operations {
         ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
         ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
         int (*iterate) (struct file *, struct dir_context *);
+        int (*iterate_shared) (struct file *, struct dir_context *);
         unsigned int (*poll) (struct file *, struct poll_table_struct *);
         long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
         long (*compat_ioctl) (struct file *, unsigned int, unsigned long);