// SPDX-License-Identifier: GPL-2.0-only /* * event_inode.c - part of tracefs, a pseudo file system for activating tracing * * Copyright (C) 2020-23 VMware Inc, author: Steven Rostedt (VMware) * Copyright (C) 2020-23 VMware Inc, author: Ajay Kaher * * eventfs is used to dynamically create inodes and dentries based on the * meta data provided by the tracing system. * * eventfs stores the meta-data of files/dirs and holds off on creating * inodes/dentries of the files. When accessed, the eventfs will create the * inodes/dentries in a just-in-time (JIT) manner. The eventfs will clean up * and delete the inodes/dentries when they are no longer referenced. */ #include #include #include #include #include #include #include #include #include "internal.h" struct eventfs_inode { struct list_head e_top_files; }; /* * struct eventfs_file - hold the properties of the eventfs files and * directories. * @name: the name of the file or directory to create * @d_parent: holds parent's dentry * @dentry: once accessed holds dentry * @list: file or directory to be added to parent directory * @ei: list of files and directories within directory * @fop: file_operations for file or directory * @iop: inode_operations for file or directory * @data: something that the caller will want to get to later on * @is_freed: Flag set if the eventfs is on its way to be freed * @mode: the permission that the file or directory should have * @uid: saved uid if changed * @gid: saved gid if changed */ struct eventfs_file { const char *name; struct dentry *d_parent; struct dentry *dentry; struct list_head list; struct eventfs_inode *ei; const struct file_operations *fop; const struct inode_operations *iop; /* * Union - used for deletion * @llist: for calling dput() if needed after RCU * @rcu: eventfs_file to delete in RCU */ union { struct llist_node llist; struct rcu_head rcu; }; void *data; unsigned int is_freed:1; unsigned int mode:31; kuid_t uid; kgid_t gid; }; static DEFINE_MUTEX(eventfs_mutex); DEFINE_STATIC_SRCU(eventfs_srcu); /* Mode is unsigned short, use the upper bits for flags */ enum { EVENTFS_SAVE_MODE = BIT(16), EVENTFS_SAVE_UID = BIT(17), EVENTFS_SAVE_GID = BIT(18), }; #define EVENTFS_MODE_MASK (EVENTFS_SAVE_MODE - 1) 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 void update_attr(struct eventfs_file *ef, struct iattr *iattr) { unsigned int ia_valid = iattr->ia_valid; if (ia_valid & ATTR_MODE) { ef->mode = (ef->mode & ~EVENTFS_MODE_MASK) | (iattr->ia_mode & EVENTFS_MODE_MASK) | EVENTFS_SAVE_MODE; } if (ia_valid & ATTR_UID) { ef->mode |= EVENTFS_SAVE_UID; ef->uid = iattr->ia_uid; } if (ia_valid & ATTR_GID) { ef->mode |= EVENTFS_SAVE_GID; ef->gid = iattr->ia_gid; } } static int eventfs_set_attr(struct mnt_idmap *idmap, struct dentry *dentry, struct iattr *iattr) { struct eventfs_file *ef; int ret; mutex_lock(&eventfs_mutex); ef = dentry->d_fsdata; if (ef && ef->is_freed) { /* Do not allow changes if the event is about to be removed. */ mutex_unlock(&eventfs_mutex); return -ENODEV; } ret = simple_setattr(idmap, dentry, iattr); if (!ret && ef) update_attr(ef, iattr); mutex_unlock(&eventfs_mutex); return ret; } static const struct inode_operations eventfs_root_dir_inode_operations = { .lookup = eventfs_root_lookup, .setattr = eventfs_set_attr, }; static const struct inode_operations eventfs_file_inode_operations = { .setattr = eventfs_set_attr, }; static const struct file_operations eventfs_file_operations = { .open = dcache_dir_open_wrapper, .read = generic_read_dir, .iterate_shared = dcache_readdir_wrapper, .llseek = generic_file_llseek, .release = eventfs_release, }; static void update_inode_attr(struct inode *inode, struct eventfs_file *ef) { inode->i_mode = ef->mode & EVENTFS_MODE_MASK; if (ef->mode & EVENTFS_SAVE_UID) inode->i_uid = ef->uid; if (ef->mode & EVENTFS_SAVE_GID) inode->i_gid = ef->gid; } /** * create_file - create a file in the tracefs filesystem * @ef: the eventfs_file * @parent: parent dentry for this file. * @data: something that the caller will want to get to later on. * @fop: struct file_operations that should be used for this file. * * This is the basic "create a file" function for tracefs. It allows for a * wide range of flexibility in creating a file. * * This function will return a pointer to a dentry if it succeeds. This * pointer must be passed to the tracefs_remove() function when the file is * to be removed (no automatic cleanup happens if your module is unloaded, * you are responsible here.) If an error occurs, %NULL will be returned. * * If tracefs is not enabled in the kernel, the value -%ENODEV will be * returned. */ static struct dentry *create_file(struct eventfs_file *ef, struct dentry *parent, void *data, const struct file_operations *fop) { struct tracefs_inode *ti; struct dentry *dentry; struct inode *inode; if (!(ef->mode & S_IFMT)) ef->mode |= S_IFREG; if (WARN_ON_ONCE(!S_ISREG(ef->mode))) return NULL; dentry = eventfs_start_creating(ef->name, parent); if (IS_ERR(dentry)) return dentry; inode = tracefs_get_inode(dentry->d_sb); if (unlikely(!inode)) return eventfs_failed_creating(dentry); /* If the user updated the directory's attributes, use them */ update_inode_attr(inode, ef); inode->i_op = &eventfs_file_inode_operations; inode->i_fop = fop; inode->i_private = data; ti = get_tracefs(inode); ti->flags |= TRACEFS_EVENT_INODE; d_instantiate(dentry, inode); fsnotify_create(dentry->d_parent->d_inode, dentry); return eventfs_end_creating(dentry); }; /** * create_dir - create a dir in the tracefs filesystem * @ei: the eventfs_inode that represents the directory to create * @parent: parent dentry for this file. * @data: something that the caller will want to get to later on. * * This is the basic "create a dir" function for eventfs. It allows for a * wide range of flexibility in creating a dir. * * This function will return a pointer to a dentry if it succeeds. This * pointer must be passed to the tracefs_remove() function when the file is * to be removed (no automatic cleanup happens if your module is unloaded, * you are responsible here.) If an error occurs, %NULL will be returned. * * If tracefs is not enabled in the kernel, the value -%ENODEV will be * returned. */ static struct dentry *create_dir(struct eventfs_file *ef, struct dentry *parent, void *data) { struct tracefs_inode *ti; struct dentry *dentry; struct inode *inode; dentry = eventfs_start_creating(ef->name, parent); if (IS_ERR(dentry)) return dentry; inode = tracefs_get_inode(dentry->d_sb); if (unlikely(!inode)) return eventfs_failed_creating(dentry); update_inode_attr(inode, ef); inode->i_op = &eventfs_root_dir_inode_operations; inode->i_fop = &eventfs_file_operations; inode->i_private = data; ti = get_tracefs(inode); ti->flags |= TRACEFS_EVENT_INODE; inc_nlink(inode); d_instantiate(dentry, inode); inc_nlink(dentry->d_parent->d_inode); fsnotify_mkdir(dentry->d_parent->d_inode, dentry); return eventfs_end_creating(dentry); } static void free_ef(struct eventfs_file *ef) { kfree(ef->name); kfree(ef->ei); kfree(ef); } /** * eventfs_set_ef_status_free - set the ef->status to free * @ti: the tracefs_inode of the dentry * @dentry: dentry who's status to be freed * * eventfs_set_ef_status_free will be called if no more * references remain */ void eventfs_set_ef_status_free(struct tracefs_inode *ti, struct dentry *dentry) { struct eventfs_inode *ei; struct eventfs_file *ef; /* The top level events directory may be freed by this */ if (unlikely(ti->flags & TRACEFS_EVENT_TOP_INODE)) { mutex_lock(&eventfs_mutex); ei = ti->private; /* Nothing should access this, but just in case! */ ti->private = NULL; mutex_unlock(&eventfs_mutex); ef = dentry->d_fsdata; if (ef) free_ef(ef); return; } mutex_lock(&eventfs_mutex); ef = dentry->d_fsdata; if (!ef) goto out; if (ef->is_freed) { free_ef(ef); } else { ef->dentry = NULL; } dentry->d_fsdata = NULL; out: mutex_unlock(&eventfs_mutex); } /** * eventfs_post_create_dir - post create dir routine * @ef: eventfs_file of recently created dir * * Map the meta-data of files within an eventfs dir to their parent dentry */ static void eventfs_post_create_dir(struct eventfs_file *ef) { struct eventfs_file *ef_child; struct tracefs_inode *ti; /* srcu lock already held */ /* fill parent-child relation */ list_for_each_entry_srcu(ef_child, &ef->ei->e_top_files, list, srcu_read_lock_held(&eventfs_srcu)) { ef_child->d_parent = ef->dentry; } ti = get_tracefs(ef->dentry->d_inode); ti->private = ef->ei; } /** * create_dentry - helper function to create dentry * @ef: eventfs_file of file or directory to create * @parent: parent dentry * @lookup: true if called from lookup routine * * Used to create a dentry for file/dir, executes post dentry creation routine */ static struct dentry * create_dentry(struct eventfs_file *ef, struct dentry *parent, bool lookup) { bool invalidate = false; struct dentry *dentry; mutex_lock(&eventfs_mutex); if (ef->is_freed) { mutex_unlock(&eventfs_mutex); return NULL; } if (ef->dentry) { dentry = ef->dentry; /* On dir open, up the ref count */ if (!lookup) dget(dentry); mutex_unlock(&eventfs_mutex); return dentry; } mutex_unlock(&eventfs_mutex); if (!lookup) inode_lock(parent->d_inode); if (ef->ei) dentry = create_dir(ef, parent, ef->data); else dentry = create_file(ef, parent, ef->data, ef->fop); if (!lookup) inode_unlock(parent->d_inode); mutex_lock(&eventfs_mutex); if (IS_ERR_OR_NULL(dentry)) { /* If the ef was already updated get it */ dentry = ef->dentry; if (dentry && !lookup) dget(dentry); mutex_unlock(&eventfs_mutex); return dentry; } if (!ef->dentry && !ef->is_freed) { ef->dentry = dentry; if (ef->ei) eventfs_post_create_dir(ef); dentry->d_fsdata = ef; } else { /* A race here, should try again (unless freed) */ invalidate = true; /* * Should never happen unless we get here due to being freed. * Otherwise it means two dentries exist with the same name. */ WARN_ON_ONCE(!ef->is_freed); } mutex_unlock(&eventfs_mutex); if (invalidate) d_invalidate(dentry); if (lookup || invalidate) dput(dentry); return invalidate ? NULL : dentry; } static bool match_event_file(struct eventfs_file *ef, const char *name) { bool ret; mutex_lock(&eventfs_mutex); ret = !ef->is_freed && strcmp(ef->name, name) == 0; mutex_unlock(&eventfs_mutex); return ret; } /** * eventfs_root_lookup - lookup routine to create file/dir * @dir: in which a lookup is being done * @dentry: file/dir dentry * @flags: to pass as flags parameter to simple lookup * * Used to create a dynamic file/dir within @dir. Use the eventfs_inode * list of meta data to find the information needed to create the file/dir. */ static struct dentry *eventfs_root_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags) { struct tracefs_inode *ti; struct eventfs_inode *ei; struct eventfs_file *ef; struct dentry *ret = NULL; int idx; ti = get_tracefs(dir); if (!(ti->flags & TRACEFS_EVENT_INODE)) return NULL; ei = ti->private; idx = srcu_read_lock(&eventfs_srcu); list_for_each_entry_srcu(ef, &ei->e_top_files, list, srcu_read_lock_held(&eventfs_srcu)) { if (!match_event_file(ef, dentry->d_name.name)) continue; ret = simple_lookup(dir, dentry, flags); create_dentry(ef, ef->d_parent, true); break; } srcu_read_unlock(&eventfs_srcu, idx); 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); } /** * dcache_dir_open_wrapper - eventfs open wrapper * @inode: not used * @file: dir to be opened (to create its child) * * Used to dynamically create the file/dir within @file. @file is really a * directory and all the files/dirs of the children within @file will be * created. If any of the files/dirs have already been created, their * reference count will be incremented. */ static int dcache_dir_open_wrapper(struct inode *inode, struct file *file) { struct tracefs_inode *ti; struct eventfs_inode *ei; struct eventfs_file *ef; struct dentry_list *dlist; struct dentry **dentries = NULL; struct dentry *dentry = file_dentry(file); struct dentry *d; struct inode *f_inode = file_inode(file); int cnt = 0; int idx; int ret; ti = get_tracefs(f_inode); if (!(ti->flags & TRACEFS_EVENT_INODE)) return -EINVAL; if (WARN_ON_ONCE(file->private_data)) return -EINVAL; dlist = kmalloc(sizeof(*dlist), GFP_KERNEL); if (!dlist) return -ENOMEM; ei = ti->private; idx = srcu_read_lock(&eventfs_srcu); list_for_each_entry_srcu(ef, &ei->e_top_files, list, srcu_read_lock_held(&eventfs_srcu)) { d = create_dentry(ef, dentry, false); if (d) { struct dentry **tmp; tmp = krealloc(dentries, sizeof(d) * (cnt + 2), GFP_KERNEL); if (!tmp) break; tmp[cnt] = d; tmp[cnt + 1] = NULL; cnt++; dentries = tmp; } } 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; } /* * 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; file->private_data = dlist->cursor; ret = dcache_readdir(file, ctx); dlist->cursor = file->private_data; file->private_data = dlist; return ret; } /** * eventfs_prepare_ef - helper function to prepare eventfs_file * @name: the name of the file/directory to create. * @mode: the permission that the file should have. * @fop: struct file_operations that should be used for this file/directory. * @iop: struct inode_operations that should be used for this file/directory. * @data: something that the caller will want to get to later on. The * inode.i_private pointer will point to this value on the open() call. * * This function allocates and fills the eventfs_file structure. */ static struct eventfs_file *eventfs_prepare_ef(const char *name, umode_t mode, const struct file_operations *fop, const struct inode_operations *iop, void *data) { struct eventfs_file *ef; ef = kzalloc(sizeof(*ef), GFP_KERNEL); if (!ef) return ERR_PTR(-ENOMEM); ef->name = kstrdup(name, GFP_KERNEL); if (!ef->name) { kfree(ef); return ERR_PTR(-ENOMEM); } if (S_ISDIR(mode)) { ef->ei = kzalloc(sizeof(*ef->ei), GFP_KERNEL); if (!ef->ei) { kfree(ef->name); kfree(ef); return ERR_PTR(-ENOMEM); } INIT_LIST_HEAD(&ef->ei->e_top_files); ef->mode = S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO; } else { ef->ei = NULL; ef->mode = mode; } ef->iop = iop; ef->fop = fop; ef->data = data; return ef; } /** * eventfs_create_events_dir - create the trace event structure * @name: the name of the directory to create. * @parent: parent dentry for this file. This should be a directory dentry * if set. If this parameter is NULL, then the directory will be * created in the root of the tracefs filesystem. * * This function creates the top of the trace event directory. */ struct dentry *eventfs_create_events_dir(const char *name, struct dentry *parent) { struct dentry *dentry = tracefs_start_creating(name, parent); struct eventfs_inode *ei; struct tracefs_inode *ti; struct inode *inode; if (security_locked_down(LOCKDOWN_TRACEFS)) return NULL; if (IS_ERR(dentry)) return dentry; ei = kzalloc(sizeof(*ei), GFP_KERNEL); if (!ei) return ERR_PTR(-ENOMEM); inode = tracefs_get_inode(dentry->d_sb); if (unlikely(!inode)) { kfree(ei); tracefs_failed_creating(dentry); return ERR_PTR(-ENOMEM); } INIT_LIST_HEAD(&ei->e_top_files); ti = get_tracefs(inode); ti->flags |= TRACEFS_EVENT_INODE | TRACEFS_EVENT_TOP_INODE; ti->private = ei; inode->i_mode = S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO; inode->i_op = &eventfs_root_dir_inode_operations; inode->i_fop = &eventfs_file_operations; /* directory inodes start off with i_nlink == 2 (for "." entry) */ inc_nlink(inode); d_instantiate(dentry, inode); inc_nlink(dentry->d_parent->d_inode); fsnotify_mkdir(dentry->d_parent->d_inode, dentry); return tracefs_end_creating(dentry); } /** * eventfs_add_subsystem_dir - add eventfs subsystem_dir to list to create later * @name: the name of the file to create. * @parent: parent dentry for this dir. * * This function adds eventfs subsystem dir to list. * And all these dirs are created on the fly when they are looked up, * and the dentry and inodes will be removed when they are done. */ struct eventfs_file *eventfs_add_subsystem_dir(const char *name, struct dentry *parent) { struct tracefs_inode *ti_parent; struct eventfs_inode *ei_parent; struct eventfs_file *ef; if (security_locked_down(LOCKDOWN_TRACEFS)) return NULL; if (!parent) return ERR_PTR(-EINVAL); ti_parent = get_tracefs(parent->d_inode); ei_parent = ti_parent->private; ef = eventfs_prepare_ef(name, S_IFDIR, NULL, NULL, NULL); if (IS_ERR(ef)) return ef; mutex_lock(&eventfs_mutex); list_add_tail(&ef->list, &ei_parent->e_top_files); ef->d_parent = parent; mutex_unlock(&eventfs_mutex); return ef; } /** * eventfs_add_dir - add eventfs dir to list to create later * @name: the name of the file to create. * @ef_parent: parent eventfs_file for this dir. * * This function adds eventfs dir to list. * And all these dirs are created on the fly when they are looked up, * and the dentry and inodes will be removed when they are done. */ struct eventfs_file *eventfs_add_dir(const char *name, struct eventfs_file *ef_parent) { struct eventfs_file *ef; if (security_locked_down(LOCKDOWN_TRACEFS)) return NULL; if (!ef_parent) return ERR_PTR(-EINVAL); ef = eventfs_prepare_ef(name, S_IFDIR, NULL, NULL, NULL); if (IS_ERR(ef)) return ef; mutex_lock(&eventfs_mutex); list_add_tail(&ef->list, &ef_parent->ei->e_top_files); ef->d_parent = ef_parent->dentry; mutex_unlock(&eventfs_mutex); return ef; } /** * eventfs_add_events_file - add the data needed to create a file for later reference * @name: the name of the file to create. * @mode: the permission that the file should have. * @parent: parent dentry for this file. * @data: something that the caller will want to get to later on. * @fop: struct file_operations that should be used for this file. * * This function is used to add the information needed to create a * dentry/inode within the top level events directory. The file created * will have the @mode permissions. The @data will be used to fill the * inode.i_private when the open() call is done. The dentry and inodes are * all created when they are referenced, and removed when they are no * longer referenced. */ int eventfs_add_events_file(const char *name, umode_t mode, struct dentry *parent, void *data, const struct file_operations *fop) { struct tracefs_inode *ti; struct eventfs_inode *ei; struct eventfs_file *ef; if (security_locked_down(LOCKDOWN_TRACEFS)) return -ENODEV; if (!parent) return -EINVAL; if (!(mode & S_IFMT)) mode |= S_IFREG; if (!parent->d_inode) return -EINVAL; ti = get_tracefs(parent->d_inode); if (!(ti->flags & TRACEFS_EVENT_INODE)) return -EINVAL; ei = ti->private; ef = eventfs_prepare_ef(name, mode, fop, NULL, data); if (IS_ERR(ef)) return -ENOMEM; mutex_lock(&eventfs_mutex); list_add_tail(&ef->list, &ei->e_top_files); ef->d_parent = parent; mutex_unlock(&eventfs_mutex); return 0; } /** * eventfs_add_file - add eventfs file to list to create later * @name: the name of the file to create. * @mode: the permission that the file should have. * @ef_parent: parent eventfs_file for this file. * @data: something that the caller will want to get to later on. * @fop: struct file_operations that should be used for this file. * * This function is used to add the information needed to create a * file within a subdirectory of the events directory. The file created * will have the @mode permissions. The @data will be used to fill the * inode.i_private when the open() call is done. The dentry and inodes are * all created when they are referenced, and removed when they are no * longer referenced. */ int eventfs_add_file(const char *name, umode_t mode, struct eventfs_file *ef_parent, void *data, const struct file_operations *fop) { struct eventfs_file *ef; if (security_locked_down(LOCKDOWN_TRACEFS)) return -ENODEV; if (!ef_parent) return -EINVAL; if (!(mode & S_IFMT)) mode |= S_IFREG; ef = eventfs_prepare_ef(name, mode, fop, NULL, data); if (IS_ERR(ef)) return -ENOMEM; mutex_lock(&eventfs_mutex); list_add_tail(&ef->list, &ef_parent->ei->e_top_files); ef->d_parent = ef_parent->dentry; mutex_unlock(&eventfs_mutex); return 0; } static LLIST_HEAD(free_list); static void eventfs_workfn(struct work_struct *work) { struct eventfs_file *ef, *tmp; struct llist_node *llnode; llnode = llist_del_all(&free_list); llist_for_each_entry_safe(ef, tmp, llnode, llist) { /* This should only get here if it had a dentry */ if (!WARN_ON_ONCE(!ef->dentry)) dput(ef->dentry); } } static DECLARE_WORK(eventfs_work, eventfs_workfn); static void free_rcu_ef(struct rcu_head *head) { struct eventfs_file *ef = container_of(head, struct eventfs_file, rcu); if (ef->dentry) { /* Do not free the ef until all references of dentry are gone */ if (llist_add(&ef->llist, &free_list)) queue_work(system_unbound_wq, &eventfs_work); return; } free_ef(ef); } static void unhook_dentry(struct dentry *dentry) { if (!dentry) return; /* * Need to add a reference to the dentry that is expected by * simple_recursive_removal(), which will include a dput(). */ dget(dentry); /* * Also add a reference for the dput() in eventfs_workfn(). * That is required as that dput() will free the ei after * the SRCU grace period is over. */ dget(dentry); } /** * eventfs_remove_rec - remove eventfs dir or file from list * @ef: eventfs_file to be removed. * @level: to check recursion depth * * The helper function eventfs_remove_rec() is used to clean up and free the * associated data from eventfs for both of the added functions. */ static void eventfs_remove_rec(struct eventfs_file *ef, int level) { struct eventfs_file *ef_child; if (!ef) return; /* * Check recursion depth. It should never be greater than 3: * 0 - events/ * 1 - events/group/ * 2 - events/group/event/ * 3 - events/group/event/file */ if (WARN_ON_ONCE(level > 3)) return; if (ef->ei) { /* search for nested folders or files */ list_for_each_entry_srcu(ef_child, &ef->ei->e_top_files, list, lockdep_is_held(&eventfs_mutex)) { eventfs_remove_rec(ef_child, level + 1); } } ef->is_freed = 1; unhook_dentry(ef->dentry); list_del_rcu(&ef->list); call_srcu(&eventfs_srcu, &ef->rcu, free_rcu_ef); } /** * eventfs_remove - remove eventfs dir or file from list * @ef: eventfs_file to be removed. * * This function acquire the eventfs_mutex lock and call eventfs_remove_rec() */ void eventfs_remove(struct eventfs_file *ef) { struct dentry *dentry; if (!ef) return; mutex_lock(&eventfs_mutex); dentry = ef->dentry; eventfs_remove_rec(ef, 0); mutex_unlock(&eventfs_mutex); /* * If any of the ei children has a dentry, then the ei itself * must have a dentry. */ if (dentry) simple_recursive_removal(dentry, NULL); } /** * eventfs_remove_events_dir - remove eventfs dir or file from list * @dentry: events's dentry to be removed. * * This function remove events main directory */ void eventfs_remove_events_dir(struct dentry *dentry) { struct eventfs_file *ef_child; struct eventfs_inode *ei; struct tracefs_inode *ti; if (!dentry || !dentry->d_inode) return; ti = get_tracefs(dentry->d_inode); if (!ti || !(ti->flags & TRACEFS_EVENT_INODE)) return; mutex_lock(&eventfs_mutex); ei = ti->private; list_for_each_entry_srcu(ef_child, &ei->e_top_files, list, lockdep_is_held(&eventfs_mutex)) { eventfs_remove_rec(ef_child, 0); } mutex_unlock(&eventfs_mutex); }