eventfs: Stop using dcache_readdir() for getdents()

The eventfs creates dynamically allocated dentries and inodes. Using the
dcache_readdir() logic for its own directory lookups requires hiding the
cursor of the dcache logic and playing games to allow the dcache_readdir()
to still have access to the cursor while the eventfs saved what it created
and what it needs to release.

Instead, just have eventfs have its own iterate_shared callback function
that will fill in the dent entries. This simplifies the code quite a bit.

Link: https://lore.kernel.org/linux-trace-kernel/20240104015435.682218477@goodmis.org
Cc: Masami Hiramatsu <mhiramat@kernel.org>
Cc: Mark Rutland <mark.rutland@arm.com>
Cc: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Ajay Kaher <akaher@vmware.com>
Cc: Al Viro <viro@ZenIV.linux.org.uk>
Cc: Christian Brauner <brauner@kernel.org>
Signed-off-by: Steven Rostedt (Google) <rostedt@goodmis.org>

diff --git a/fs/tracefs/event_inode.c b/fs/tracefs/event_inode.c
index c360300fb866ecdb495783e297f8b1ea7b65a16b..41af56f44f0a0c49eaa0c3428ca35f3fbde132cd 100644 (file)
--- a/fs/tracefs/event_inode.c
+++ b/fs/tracefs/event_inode.c
@@ -52,9 +52,7 @@ enum {
 static struct dentry *eventfs_root_lookup(struct inode *dir,
                                          struct dentry *dentry,
                                          unsigned int flags);
-static int dcache_dir_open_wrapper(struct inode *inode, struct file *file);
-static int dcache_readdir_wrapper(struct file *file, struct dir_context *ctx);
-static int eventfs_release(struct inode *inode, struct file *file);
+static int eventfs_iterate(struct file *file, struct dir_context *ctx);
 
 static void update_attr(struct eventfs_attr *attr, struct iattr *iattr)
 {
@@ -148,11 +146,9 @@ static const struct inode_operations eventfs_file_inode_operations = {
 };
 
 static const struct file_operations eventfs_file_operations = {
-       .open           = dcache_dir_open_wrapper,
        .read           = generic_read_dir,
-       .iterate_shared = dcache_readdir_wrapper,
+       .iterate_shared = eventfs_iterate,
        .llseek         = generic_file_llseek,
-       .release        = eventfs_release,
 };
 
 /* Return the evenfs_inode of the "events" directory */
@@ -643,128 +639,87 @@ static struct dentry *eventfs_root_lookup(struct inode *dir,
        return ret;
 }
 
-struct dentry_list {
-       void                    *cursor;
-       struct dentry           **dentries;
-};
-
-/**
- * eventfs_release - called to release eventfs file/dir
- * @inode: inode to be released
- * @file: file to be released (not used)
- */
-static int eventfs_release(struct inode *inode, struct file *file)
-{
-       struct tracefs_inode *ti;
-       struct dentry_list *dlist = file->private_data;
-       void *cursor;
-       int i;
-
-       ti = get_tracefs(inode);
-       if (!(ti->flags & TRACEFS_EVENT_INODE))
-               return -EINVAL;
-
-       if (WARN_ON_ONCE(!dlist))
-               return -EINVAL;
-
-       for (i = 0; dlist->dentries && dlist->dentries[i]; i++) {
-               dput(dlist->dentries[i]);
-       }
-
-       cursor = dlist->cursor;
-       kfree(dlist->dentries);
-       kfree(dlist);
-       file->private_data = cursor;
-       return dcache_dir_close(inode, file);
-}
-
-static int add_dentries(struct dentry ***dentries, struct dentry *d, int cnt)
-{
-       struct dentry **tmp;
-
-       tmp = krealloc(*dentries, sizeof(d) * (cnt + 2), GFP_NOFS);
-       if (!tmp)
-               return -1;
-       tmp[cnt] = d;
-       tmp[cnt + 1] = NULL;
-       *dentries = tmp;
-       return 0;
-}
-
-/**
- * dcache_dir_open_wrapper - eventfs open wrapper
- * @inode: not used
- * @file: dir to be opened (to create it's children)
- *
- * Used to dynamic create file/dir with-in @file, all the
- * file/dir will be created. If already created then references
- * will be increased
+/*
+ * Walk the children of a eventfs_inode to fill in getdents().
  */
-static int dcache_dir_open_wrapper(struct inode *inode, struct file *file)
+static int eventfs_iterate(struct file *file, struct dir_context *ctx)
 {
        const struct file_operations *fops;
+       struct inode *f_inode = file_inode(file);
        const struct eventfs_entry *entry;
        struct eventfs_inode *ei_child;
        struct tracefs_inode *ti;
        struct eventfs_inode *ei;
-       struct dentry_list *dlist;
-       struct dentry **dentries = NULL;
-       struct dentry *parent = file_dentry(file);
-       struct dentry *d;
-       struct inode *f_inode = file_inode(file);
-       const char *name = parent->d_name.name;
+       struct dentry *ei_dentry = NULL;
+       struct dentry *dentry;
+       const char *name;
        umode_t mode;
-       void *data;
-       int cnt = 0;
        int idx;
-       int ret;
-       int i;
-       int r;
+       int ret = -EINVAL;
+       int ino;
+       int i, r, c;
+
+       if (!dir_emit_dots(file, ctx))
+               return 0;
 
        ti = get_tracefs(f_inode);
        if (!(ti->flags & TRACEFS_EVENT_INODE))
                return -EINVAL;
 
-       if (WARN_ON_ONCE(file->private_data))
-               return -EINVAL;
+       c = ctx->pos - 2;
 
        idx = srcu_read_lock(&eventfs_srcu);
 
        mutex_lock(&eventfs_mutex);
        ei = READ_ONCE(ti->private);
+       if (ei && !ei->is_freed)
+               ei_dentry = READ_ONCE(ei->dentry);
        mutex_unlock(&eventfs_mutex);
 
-       if (!ei) {
-               srcu_read_unlock(&eventfs_srcu, idx);
-               return -EINVAL;
-       }
-
-
-       data = ei->data;
+       if (!ei || !ei_dentry)
+               goto out;
 
-       dlist = kmalloc(sizeof(*dlist), GFP_KERNEL);
-       if (!dlist) {
-               srcu_read_unlock(&eventfs_srcu, idx);
-               return -ENOMEM;
-       }
+       ret = 0;
 
-       inode_lock(parent->d_inode);
+       /*
+        * Need to create the dentries and inodes to have a consistent
+        * inode number.
+        */
        list_for_each_entry_srcu(ei_child, &ei->children, list,
                                 srcu_read_lock_held(&eventfs_srcu)) {
-               d = create_dir_dentry(ei, ei_child, parent);
-               if (d) {
-                       ret = add_dentries(&dentries, d, cnt);
-                       dput(d);
-                       if (ret < 0)
-                               break;
-                       cnt++;
+
+               if (c > 0) {
+                       c--;
+                       continue;
                }
+
+               if (ei_child->is_freed)
+                       continue;
+
+               name = ei_child->name;
+
+               dentry = create_dir_dentry(ei, ei_child, ei_dentry);
+               if (!dentry)
+                       goto out;
+               ino = dentry->d_inode->i_ino;
+               dput(dentry);
+
+               if (!dir_emit(ctx, name, strlen(name), ino, DT_DIR))
+                       goto out;
+               ctx->pos++;
        }
 
        for (i = 0; i < ei->nr_entries; i++) {
-               void *cdata = data;
+               void *cdata = ei->data;
+
+               if (c > 0) {
+                       c--;
+                       continue;
+               }
+
                entry = &ei->entries[i];
                name = entry->name;
+
                mutex_lock(&eventfs_mutex);
                /* If ei->is_freed, then the event itself may be too */
                if (!ei->is_freed)
@@ -774,42 +729,21 @@ static int dcache_dir_open_wrapper(struct inode *inode, struct file *file)
                mutex_unlock(&eventfs_mutex);
                if (r <= 0)
                        continue;
-               d = create_file_dentry(ei, i, parent, name, mode, cdata, fops);
-               if (d) {
-                       ret = add_dentries(&dentries, d, cnt);
-                       dput(d);
-                       if (ret < 0)
-                               break;
-                       cnt++;
-               }
-       }
-       inode_unlock(parent->d_inode);
-       srcu_read_unlock(&eventfs_srcu, idx);
-       ret = dcache_dir_open(inode, file);
 
-       /*
-        * dcache_dir_open() sets file->private_data to a dentry cursor.
-        * Need to save that but also save all the dentries that were
-        * opened by this function.
-        */
-       dlist->cursor = file->private_data;
-       dlist->dentries = dentries;
-       file->private_data = dlist;
-       return ret;
-}
+               dentry = create_file_dentry(ei, i, ei_dentry, name, mode, cdata, fops);
+               if (!dentry)
+                       goto out;
+               ino = dentry->d_inode->i_ino;
+               dput(dentry);
 
-/*
- * This just sets the file->private_data back to the cursor and back.
- */
-static int dcache_readdir_wrapper(struct file *file, struct dir_context *ctx)
-{
-       struct dentry_list *dlist = file->private_data;
-       int ret;
+               if (!dir_emit(ctx, name, strlen(name), ino, DT_REG))
+                       goto out;
+               ctx->pos++;
+       }
+       ret = 1;
+ out:
+       srcu_read_unlock(&eventfs_srcu, idx);
 
-       file->private_data = dlist->cursor;
-       ret = dcache_readdir(file, ctx);
-       dlist->cursor = file->private_data;
-       file->private_data = dlist;
        return ret;
 }