xref: /openbmc/linux/fs/tracefs/event_inode.c (revision 39f555fb)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  *  event_inode.c - part of tracefs, a pseudo file system for activating tracing
4  *
5  *  Copyright (C) 2020-23 VMware Inc, author: Steven Rostedt (VMware) <rostedt@goodmis.org>
6  *  Copyright (C) 2020-23 VMware Inc, author: Ajay Kaher <akaher@vmware.com>
7  *
8  *  eventfs is used to dynamically create inodes and dentries based on the
9  *  meta data provided by the tracing system.
10  *
11  *  eventfs stores the meta-data of files/dirs and holds off on creating
12  *  inodes/dentries of the files. When accessed, the eventfs will create the
13  *  inodes/dentries in a just-in-time (JIT) manner. The eventfs will clean up
14  *  and delete the inodes/dentries when they are no longer referenced.
15  */
16 #include <linux/fsnotify.h>
17 #include <linux/fs.h>
18 #include <linux/namei.h>
19 #include <linux/workqueue.h>
20 #include <linux/security.h>
21 #include <linux/tracefs.h>
22 #include <linux/kref.h>
23 #include <linux/delay.h>
24 #include "internal.h"
25 
26 struct eventfs_inode {
27 	struct list_head	e_top_files;
28 };
29 
30 /*
31  * struct eventfs_file - hold the properties of the eventfs files and
32  *                       directories.
33  * @name:	the name of the file or directory to create
34  * @d_parent:   holds parent's dentry
35  * @dentry:     once accessed holds dentry
36  * @list:	file or directory to be added to parent directory
37  * @ei:		list of files and directories within directory
38  * @fop:	file_operations for file or directory
39  * @iop:	inode_operations for file or directory
40  * @data:	something that the caller will want to get to later on
41  * @is_freed:	Flag set if the eventfs is on its way to be freed
42  * @mode:	the permission that the file or directory should have
43  * @uid:	saved uid if changed
44  * @gid:	saved gid if changed
45  */
46 struct eventfs_file {
47 	const char			*name;
48 	struct dentry			*d_parent;
49 	struct dentry			*dentry;
50 	struct list_head		list;
51 	struct eventfs_inode		*ei;
52 	const struct file_operations	*fop;
53 	const struct inode_operations	*iop;
54 	/*
55 	 * Union - used for deletion
56 	 * @llist:	for calling dput() if needed after RCU
57 	 * @rcu:	eventfs_file to delete in RCU
58 	 */
59 	union {
60 		struct llist_node	llist;
61 		struct rcu_head		rcu;
62 	};
63 	void				*data;
64 	unsigned int			is_freed:1;
65 	unsigned int			mode:31;
66 	kuid_t				uid;
67 	kgid_t				gid;
68 };
69 
70 static DEFINE_MUTEX(eventfs_mutex);
71 DEFINE_STATIC_SRCU(eventfs_srcu);
72 
73 /* Mode is unsigned short, use the upper bits for flags */
74 enum {
75 	EVENTFS_SAVE_MODE	= BIT(16),
76 	EVENTFS_SAVE_UID	= BIT(17),
77 	EVENTFS_SAVE_GID	= BIT(18),
78 };
79 
80 #define EVENTFS_MODE_MASK	(EVENTFS_SAVE_MODE - 1)
81 
82 static struct dentry *eventfs_root_lookup(struct inode *dir,
83 					  struct dentry *dentry,
84 					  unsigned int flags);
85 static int dcache_dir_open_wrapper(struct inode *inode, struct file *file);
86 static int dcache_readdir_wrapper(struct file *file, struct dir_context *ctx);
87 static int eventfs_release(struct inode *inode, struct file *file);
88 
89 static void update_attr(struct eventfs_file *ef, struct iattr *iattr)
90 {
91 	unsigned int ia_valid = iattr->ia_valid;
92 
93 	if (ia_valid & ATTR_MODE) {
94 		ef->mode = (ef->mode & ~EVENTFS_MODE_MASK) |
95 			(iattr->ia_mode & EVENTFS_MODE_MASK) |
96 			EVENTFS_SAVE_MODE;
97 	}
98 	if (ia_valid & ATTR_UID) {
99 		ef->mode |= EVENTFS_SAVE_UID;
100 		ef->uid = iattr->ia_uid;
101 	}
102 	if (ia_valid & ATTR_GID) {
103 		ef->mode |= EVENTFS_SAVE_GID;
104 		ef->gid = iattr->ia_gid;
105 	}
106 }
107 
108 static int eventfs_set_attr(struct mnt_idmap *idmap, struct dentry *dentry,
109 			     struct iattr *iattr)
110 {
111 	struct eventfs_file *ef;
112 	int ret;
113 
114 	mutex_lock(&eventfs_mutex);
115 	ef = dentry->d_fsdata;
116 	if (ef->is_freed) {
117 		/* Do not allow changes if the event is about to be removed. */
118 		mutex_unlock(&eventfs_mutex);
119 		return -ENODEV;
120 	}
121 
122 	ret = simple_setattr(idmap, dentry, iattr);
123 	if (!ret)
124 		update_attr(ef, iattr);
125 	mutex_unlock(&eventfs_mutex);
126 	return ret;
127 }
128 
129 static const struct inode_operations eventfs_root_dir_inode_operations = {
130 	.lookup		= eventfs_root_lookup,
131 	.setattr	= eventfs_set_attr,
132 };
133 
134 static const struct inode_operations eventfs_file_inode_operations = {
135 	.setattr	= eventfs_set_attr,
136 };
137 
138 static const struct file_operations eventfs_file_operations = {
139 	.open		= dcache_dir_open_wrapper,
140 	.read		= generic_read_dir,
141 	.iterate_shared	= dcache_readdir_wrapper,
142 	.llseek		= generic_file_llseek,
143 	.release	= eventfs_release,
144 };
145 
146 static void update_inode_attr(struct inode *inode, struct eventfs_file *ef)
147 {
148 	inode->i_mode = ef->mode & EVENTFS_MODE_MASK;
149 
150 	if (ef->mode & EVENTFS_SAVE_UID)
151 		inode->i_uid = ef->uid;
152 
153 	if (ef->mode & EVENTFS_SAVE_GID)
154 		inode->i_gid = ef->gid;
155 }
156 
157 /**
158  * create_file - create a file in the tracefs filesystem
159  * @ef: the eventfs_file
160  * @parent: parent dentry for this file.
161  * @data: something that the caller will want to get to later on.
162  * @fop: struct file_operations that should be used for this file.
163  *
164  * This is the basic "create a file" function for tracefs.  It allows for a
165  * wide range of flexibility in creating a file.
166  *
167  * This function will return a pointer to a dentry if it succeeds.  This
168  * pointer must be passed to the tracefs_remove() function when the file is
169  * to be removed (no automatic cleanup happens if your module is unloaded,
170  * you are responsible here.)  If an error occurs, %NULL will be returned.
171  *
172  * If tracefs is not enabled in the kernel, the value -%ENODEV will be
173  * returned.
174  */
175 static struct dentry *create_file(struct eventfs_file *ef,
176 				  struct dentry *parent, void *data,
177 				  const struct file_operations *fop)
178 {
179 	struct tracefs_inode *ti;
180 	struct dentry *dentry;
181 	struct inode *inode;
182 
183 	if (!(ef->mode & S_IFMT))
184 		ef->mode |= S_IFREG;
185 
186 	if (WARN_ON_ONCE(!S_ISREG(ef->mode)))
187 		return NULL;
188 
189 	dentry = eventfs_start_creating(ef->name, parent);
190 
191 	if (IS_ERR(dentry))
192 		return dentry;
193 
194 	inode = tracefs_get_inode(dentry->d_sb);
195 	if (unlikely(!inode))
196 		return eventfs_failed_creating(dentry);
197 
198 	/* If the user updated the directory's attributes, use them */
199 	update_inode_attr(inode, ef);
200 
201 	inode->i_op = &eventfs_file_inode_operations;
202 	inode->i_fop = fop;
203 	inode->i_private = data;
204 
205 	ti = get_tracefs(inode);
206 	ti->flags |= TRACEFS_EVENT_INODE;
207 	d_instantiate(dentry, inode);
208 	fsnotify_create(dentry->d_parent->d_inode, dentry);
209 	return eventfs_end_creating(dentry);
210 };
211 
212 /**
213  * create_dir - create a dir in the tracefs filesystem
214  * @ei: the eventfs_inode that represents the directory to create
215  * @parent: parent dentry for this file.
216  * @data: something that the caller will want to get to later on.
217  *
218  * This is the basic "create a dir" function for eventfs.  It allows for a
219  * wide range of flexibility in creating a dir.
220  *
221  * This function will return a pointer to a dentry if it succeeds.  This
222  * pointer must be passed to the tracefs_remove() function when the file is
223  * to be removed (no automatic cleanup happens if your module is unloaded,
224  * you are responsible here.)  If an error occurs, %NULL will be returned.
225  *
226  * If tracefs is not enabled in the kernel, the value -%ENODEV will be
227  * returned.
228  */
229 static struct dentry *create_dir(struct eventfs_file *ef,
230 				 struct dentry *parent, void *data)
231 {
232 	struct tracefs_inode *ti;
233 	struct dentry *dentry;
234 	struct inode *inode;
235 
236 	dentry = eventfs_start_creating(ef->name, parent);
237 	if (IS_ERR(dentry))
238 		return dentry;
239 
240 	inode = tracefs_get_inode(dentry->d_sb);
241 	if (unlikely(!inode))
242 		return eventfs_failed_creating(dentry);
243 
244 	update_inode_attr(inode, ef);
245 
246 	inode->i_op = &eventfs_root_dir_inode_operations;
247 	inode->i_fop = &eventfs_file_operations;
248 	inode->i_private = data;
249 
250 	ti = get_tracefs(inode);
251 	ti->flags |= TRACEFS_EVENT_INODE;
252 
253 	inc_nlink(inode);
254 	d_instantiate(dentry, inode);
255 	inc_nlink(dentry->d_parent->d_inode);
256 	fsnotify_mkdir(dentry->d_parent->d_inode, dentry);
257 	return eventfs_end_creating(dentry);
258 }
259 
260 static void free_ef(struct eventfs_file *ef)
261 {
262 	kfree(ef->name);
263 	kfree(ef->ei);
264 	kfree(ef);
265 }
266 
267 /**
268  * eventfs_set_ef_status_free - set the ef->status to free
269  * @ti: the tracefs_inode of the dentry
270  * @dentry: dentry who's status to be freed
271  *
272  * eventfs_set_ef_status_free will be called if no more
273  * references remain
274  */
275 void eventfs_set_ef_status_free(struct tracefs_inode *ti, struct dentry *dentry)
276 {
277 	struct eventfs_inode *ei;
278 	struct eventfs_file *ef;
279 
280 	/* The top level events directory may be freed by this */
281 	if (unlikely(ti->flags & TRACEFS_EVENT_TOP_INODE)) {
282 		mutex_lock(&eventfs_mutex);
283 		ei = ti->private;
284 
285 		/* Nothing should access this, but just in case! */
286 		ti->private = NULL;
287 		mutex_unlock(&eventfs_mutex);
288 
289 		ef = dentry->d_fsdata;
290 		if (ef)
291 			free_ef(ef);
292 		return;
293 	}
294 
295 	mutex_lock(&eventfs_mutex);
296 
297 	ef = dentry->d_fsdata;
298 	if (!ef)
299 		goto out;
300 
301 	if (ef->is_freed) {
302 		free_ef(ef);
303 	} else {
304 		ef->dentry = NULL;
305 	}
306 
307 	dentry->d_fsdata = NULL;
308 out:
309 	mutex_unlock(&eventfs_mutex);
310 }
311 
312 /**
313  * eventfs_post_create_dir - post create dir routine
314  * @ef: eventfs_file of recently created dir
315  *
316  * Map the meta-data of files within an eventfs dir to their parent dentry
317  */
318 static void eventfs_post_create_dir(struct eventfs_file *ef)
319 {
320 	struct eventfs_file *ef_child;
321 	struct tracefs_inode *ti;
322 
323 	/* srcu lock already held */
324 	/* fill parent-child relation */
325 	list_for_each_entry_srcu(ef_child, &ef->ei->e_top_files, list,
326 				 srcu_read_lock_held(&eventfs_srcu)) {
327 		ef_child->d_parent = ef->dentry;
328 	}
329 
330 	ti = get_tracefs(ef->dentry->d_inode);
331 	ti->private = ef->ei;
332 }
333 
334 /**
335  * create_dentry - helper function to create dentry
336  * @ef: eventfs_file of file or directory to create
337  * @parent: parent dentry
338  * @lookup: true if called from lookup routine
339  *
340  * Used to create a dentry for file/dir, executes post dentry creation routine
341  */
342 static struct dentry *
343 create_dentry(struct eventfs_file *ef, struct dentry *parent, bool lookup)
344 {
345 	bool invalidate = false;
346 	struct dentry *dentry;
347 
348 	mutex_lock(&eventfs_mutex);
349 	if (ef->is_freed) {
350 		mutex_unlock(&eventfs_mutex);
351 		return NULL;
352 	}
353 	if (ef->dentry) {
354 		dentry = ef->dentry;
355 		/* On dir open, up the ref count */
356 		if (!lookup)
357 			dget(dentry);
358 		mutex_unlock(&eventfs_mutex);
359 		return dentry;
360 	}
361 	mutex_unlock(&eventfs_mutex);
362 
363 	if (!lookup)
364 		inode_lock(parent->d_inode);
365 
366 	if (ef->ei)
367 		dentry = create_dir(ef, parent, ef->data);
368 	else
369 		dentry = create_file(ef, parent, ef->data, ef->fop);
370 
371 	if (!lookup)
372 		inode_unlock(parent->d_inode);
373 
374 	mutex_lock(&eventfs_mutex);
375 	if (IS_ERR_OR_NULL(dentry)) {
376 		/* If the ef was already updated get it */
377 		dentry = ef->dentry;
378 		if (dentry && !lookup)
379 			dget(dentry);
380 		mutex_unlock(&eventfs_mutex);
381 		return dentry;
382 	}
383 
384 	if (!ef->dentry && !ef->is_freed) {
385 		ef->dentry = dentry;
386 		if (ef->ei)
387 			eventfs_post_create_dir(ef);
388 		dentry->d_fsdata = ef;
389 	} else {
390 		/* A race here, should try again (unless freed) */
391 		invalidate = true;
392 
393 		/*
394 		 * Should never happen unless we get here due to being freed.
395 		 * Otherwise it means two dentries exist with the same name.
396 		 */
397 		WARN_ON_ONCE(!ef->is_freed);
398 	}
399 	mutex_unlock(&eventfs_mutex);
400 	if (invalidate)
401 		d_invalidate(dentry);
402 
403 	if (lookup || invalidate)
404 		dput(dentry);
405 
406 	return invalidate ? NULL : dentry;
407 }
408 
409 static bool match_event_file(struct eventfs_file *ef, const char *name)
410 {
411 	bool ret;
412 
413 	mutex_lock(&eventfs_mutex);
414 	ret = !ef->is_freed && strcmp(ef->name, name) == 0;
415 	mutex_unlock(&eventfs_mutex);
416 
417 	return ret;
418 }
419 
420 /**
421  * eventfs_root_lookup - lookup routine to create file/dir
422  * @dir: in which a lookup is being done
423  * @dentry: file/dir dentry
424  * @flags: to pass as flags parameter to simple lookup
425  *
426  * Used to create a dynamic file/dir within @dir. Use the eventfs_inode
427  * list of meta data to find the information needed to create the file/dir.
428  */
429 static struct dentry *eventfs_root_lookup(struct inode *dir,
430 					  struct dentry *dentry,
431 					  unsigned int flags)
432 {
433 	struct tracefs_inode *ti;
434 	struct eventfs_inode *ei;
435 	struct eventfs_file *ef;
436 	struct dentry *ret = NULL;
437 	int idx;
438 
439 	ti = get_tracefs(dir);
440 	if (!(ti->flags & TRACEFS_EVENT_INODE))
441 		return NULL;
442 
443 	ei = ti->private;
444 	idx = srcu_read_lock(&eventfs_srcu);
445 	list_for_each_entry_srcu(ef, &ei->e_top_files, list,
446 				 srcu_read_lock_held(&eventfs_srcu)) {
447 		if (!match_event_file(ef, dentry->d_name.name))
448 			continue;
449 		ret = simple_lookup(dir, dentry, flags);
450 		create_dentry(ef, ef->d_parent, true);
451 		break;
452 	}
453 	srcu_read_unlock(&eventfs_srcu, idx);
454 	return ret;
455 }
456 
457 struct dentry_list {
458 	void			*cursor;
459 	struct dentry		**dentries;
460 };
461 
462 /**
463  * eventfs_release - called to release eventfs file/dir
464  * @inode: inode to be released
465  * @file: file to be released (not used)
466  */
467 static int eventfs_release(struct inode *inode, struct file *file)
468 {
469 	struct tracefs_inode *ti;
470 	struct dentry_list *dlist = file->private_data;
471 	void *cursor;
472 	int i;
473 
474 	ti = get_tracefs(inode);
475 	if (!(ti->flags & TRACEFS_EVENT_INODE))
476 		return -EINVAL;
477 
478 	if (WARN_ON_ONCE(!dlist))
479 		return -EINVAL;
480 
481 	for (i = 0; dlist->dentries && dlist->dentries[i]; i++) {
482 		dput(dlist->dentries[i]);
483 	}
484 
485 	cursor = dlist->cursor;
486 	kfree(dlist->dentries);
487 	kfree(dlist);
488 	file->private_data = cursor;
489 	return dcache_dir_close(inode, file);
490 }
491 
492 /**
493  * dcache_dir_open_wrapper - eventfs open wrapper
494  * @inode: not used
495  * @file: dir to be opened (to create its child)
496  *
497  * Used to dynamically create the file/dir within @file. @file is really a
498  * directory and all the files/dirs of the children within @file will be
499  * created. If any of the files/dirs have already been created, their
500  * reference count will be incremented.
501  */
502 static int dcache_dir_open_wrapper(struct inode *inode, struct file *file)
503 {
504 	struct tracefs_inode *ti;
505 	struct eventfs_inode *ei;
506 	struct eventfs_file *ef;
507 	struct dentry_list *dlist;
508 	struct dentry **dentries = NULL;
509 	struct dentry *dentry = file_dentry(file);
510 	struct dentry *d;
511 	struct inode *f_inode = file_inode(file);
512 	int cnt = 0;
513 	int idx;
514 	int ret;
515 
516 	ti = get_tracefs(f_inode);
517 	if (!(ti->flags & TRACEFS_EVENT_INODE))
518 		return -EINVAL;
519 
520 	if (WARN_ON_ONCE(file->private_data))
521 		return -EINVAL;
522 
523 	dlist = kmalloc(sizeof(*dlist), GFP_KERNEL);
524 	if (!dlist)
525 		return -ENOMEM;
526 
527 	ei = ti->private;
528 	idx = srcu_read_lock(&eventfs_srcu);
529 	list_for_each_entry_srcu(ef, &ei->e_top_files, list,
530 				 srcu_read_lock_held(&eventfs_srcu)) {
531 		d = create_dentry(ef, dentry, false);
532 		if (d) {
533 			struct dentry **tmp;
534 
535 
536 			tmp = krealloc(dentries, sizeof(d) * (cnt + 2), GFP_KERNEL);
537 			if (!tmp)
538 				break;
539 			tmp[cnt] = d;
540 			tmp[cnt + 1] = NULL;
541 			cnt++;
542 			dentries = tmp;
543 		}
544 	}
545 	srcu_read_unlock(&eventfs_srcu, idx);
546 	ret = dcache_dir_open(inode, file);
547 
548 	/*
549 	 * dcache_dir_open() sets file->private_data to a dentry cursor.
550 	 * Need to save that but also save all the dentries that were
551 	 * opened by this function.
552 	 */
553 	dlist->cursor = file->private_data;
554 	dlist->dentries = dentries;
555 	file->private_data = dlist;
556 	return ret;
557 }
558 
559 /*
560  * This just sets the file->private_data back to the cursor and back.
561  */
562 static int dcache_readdir_wrapper(struct file *file, struct dir_context *ctx)
563 {
564 	struct dentry_list *dlist = file->private_data;
565 	int ret;
566 
567 	file->private_data = dlist->cursor;
568 	ret = dcache_readdir(file, ctx);
569 	dlist->cursor = file->private_data;
570 	file->private_data = dlist;
571 	return ret;
572 }
573 
574 /**
575  * eventfs_prepare_ef - helper function to prepare eventfs_file
576  * @name: the name of the file/directory to create.
577  * @mode: the permission that the file should have.
578  * @fop: struct file_operations that should be used for this file/directory.
579  * @iop: struct inode_operations that should be used for this file/directory.
580  * @data: something that the caller will want to get to later on. The
581  *        inode.i_private pointer will point to this value on the open() call.
582  *
583  * This function allocates and fills the eventfs_file structure.
584  */
585 static struct eventfs_file *eventfs_prepare_ef(const char *name, umode_t mode,
586 					const struct file_operations *fop,
587 					const struct inode_operations *iop,
588 					void *data)
589 {
590 	struct eventfs_file *ef;
591 
592 	ef = kzalloc(sizeof(*ef), GFP_KERNEL);
593 	if (!ef)
594 		return ERR_PTR(-ENOMEM);
595 
596 	ef->name = kstrdup(name, GFP_KERNEL);
597 	if (!ef->name) {
598 		kfree(ef);
599 		return ERR_PTR(-ENOMEM);
600 	}
601 
602 	if (S_ISDIR(mode)) {
603 		ef->ei = kzalloc(sizeof(*ef->ei), GFP_KERNEL);
604 		if (!ef->ei) {
605 			kfree(ef->name);
606 			kfree(ef);
607 			return ERR_PTR(-ENOMEM);
608 		}
609 		INIT_LIST_HEAD(&ef->ei->e_top_files);
610 		ef->mode = S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO;
611 	} else {
612 		ef->ei = NULL;
613 		ef->mode = mode;
614 	}
615 
616 	ef->iop = iop;
617 	ef->fop = fop;
618 	ef->data = data;
619 	return ef;
620 }
621 
622 /**
623  * eventfs_create_events_dir - create the trace event structure
624  * @name: the name of the directory to create.
625  * @parent: parent dentry for this file.  This should be a directory dentry
626  *          if set.  If this parameter is NULL, then the directory will be
627  *          created in the root of the tracefs filesystem.
628  *
629  * This function creates the top of the trace event directory.
630  */
631 struct dentry *eventfs_create_events_dir(const char *name,
632 					 struct dentry *parent)
633 {
634 	struct dentry *dentry = tracefs_start_creating(name, parent);
635 	struct eventfs_inode *ei;
636 	struct tracefs_inode *ti;
637 	struct inode *inode;
638 
639 	if (security_locked_down(LOCKDOWN_TRACEFS))
640 		return NULL;
641 
642 	if (IS_ERR(dentry))
643 		return dentry;
644 
645 	ei = kzalloc(sizeof(*ei), GFP_KERNEL);
646 	if (!ei)
647 		return ERR_PTR(-ENOMEM);
648 	inode = tracefs_get_inode(dentry->d_sb);
649 	if (unlikely(!inode)) {
650 		kfree(ei);
651 		tracefs_failed_creating(dentry);
652 		return ERR_PTR(-ENOMEM);
653 	}
654 
655 	INIT_LIST_HEAD(&ei->e_top_files);
656 
657 	ti = get_tracefs(inode);
658 	ti->flags |= TRACEFS_EVENT_INODE | TRACEFS_EVENT_TOP_INODE;
659 	ti->private = ei;
660 
661 	inode->i_mode = S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO;
662 	inode->i_op = &eventfs_root_dir_inode_operations;
663 	inode->i_fop = &eventfs_file_operations;
664 
665 	/* directory inodes start off with i_nlink == 2 (for "." entry) */
666 	inc_nlink(inode);
667 	d_instantiate(dentry, inode);
668 	inc_nlink(dentry->d_parent->d_inode);
669 	fsnotify_mkdir(dentry->d_parent->d_inode, dentry);
670 	return tracefs_end_creating(dentry);
671 }
672 
673 /**
674  * eventfs_add_subsystem_dir - add eventfs subsystem_dir to list to create later
675  * @name: the name of the file to create.
676  * @parent: parent dentry for this dir.
677  *
678  * This function adds eventfs subsystem dir to list.
679  * And all these dirs are created on the fly when they are looked up,
680  * and the dentry and inodes will be removed when they are done.
681  */
682 struct eventfs_file *eventfs_add_subsystem_dir(const char *name,
683 					       struct dentry *parent)
684 {
685 	struct tracefs_inode *ti_parent;
686 	struct eventfs_inode *ei_parent;
687 	struct eventfs_file *ef;
688 
689 	if (security_locked_down(LOCKDOWN_TRACEFS))
690 		return NULL;
691 
692 	if (!parent)
693 		return ERR_PTR(-EINVAL);
694 
695 	ti_parent = get_tracefs(parent->d_inode);
696 	ei_parent = ti_parent->private;
697 
698 	ef = eventfs_prepare_ef(name, S_IFDIR, NULL, NULL, NULL);
699 	if (IS_ERR(ef))
700 		return ef;
701 
702 	mutex_lock(&eventfs_mutex);
703 	list_add_tail(&ef->list, &ei_parent->e_top_files);
704 	ef->d_parent = parent;
705 	mutex_unlock(&eventfs_mutex);
706 	return ef;
707 }
708 
709 /**
710  * eventfs_add_dir - add eventfs dir to list to create later
711  * @name: the name of the file to create.
712  * @ef_parent: parent eventfs_file for this dir.
713  *
714  * This function adds eventfs dir to list.
715  * And all these dirs are created on the fly when they are looked up,
716  * and the dentry and inodes will be removed when they are done.
717  */
718 struct eventfs_file *eventfs_add_dir(const char *name,
719 				     struct eventfs_file *ef_parent)
720 {
721 	struct eventfs_file *ef;
722 
723 	if (security_locked_down(LOCKDOWN_TRACEFS))
724 		return NULL;
725 
726 	if (!ef_parent)
727 		return ERR_PTR(-EINVAL);
728 
729 	ef = eventfs_prepare_ef(name, S_IFDIR, NULL, NULL, NULL);
730 	if (IS_ERR(ef))
731 		return ef;
732 
733 	mutex_lock(&eventfs_mutex);
734 	list_add_tail(&ef->list, &ef_parent->ei->e_top_files);
735 	ef->d_parent = ef_parent->dentry;
736 	mutex_unlock(&eventfs_mutex);
737 	return ef;
738 }
739 
740 /**
741  * eventfs_add_events_file - add the data needed to create a file for later reference
742  * @name: the name of the file to create.
743  * @mode: the permission that the file should have.
744  * @parent: parent dentry for this file.
745  * @data: something that the caller will want to get to later on.
746  * @fop: struct file_operations that should be used for this file.
747  *
748  * This function is used to add the information needed to create a
749  * dentry/inode within the top level events directory. The file created
750  * will have the @mode permissions. The @data will be used to fill the
751  * inode.i_private when the open() call is done. The dentry and inodes are
752  * all created when they are referenced, and removed when they are no
753  * longer referenced.
754  */
755 int eventfs_add_events_file(const char *name, umode_t mode,
756 			 struct dentry *parent, void *data,
757 			 const struct file_operations *fop)
758 {
759 	struct tracefs_inode *ti;
760 	struct eventfs_inode *ei;
761 	struct eventfs_file *ef;
762 
763 	if (security_locked_down(LOCKDOWN_TRACEFS))
764 		return -ENODEV;
765 
766 	if (!parent)
767 		return -EINVAL;
768 
769 	if (!(mode & S_IFMT))
770 		mode |= S_IFREG;
771 
772 	if (!parent->d_inode)
773 		return -EINVAL;
774 
775 	ti = get_tracefs(parent->d_inode);
776 	if (!(ti->flags & TRACEFS_EVENT_INODE))
777 		return -EINVAL;
778 
779 	ei = ti->private;
780 	ef = eventfs_prepare_ef(name, mode, fop, NULL, data);
781 
782 	if (IS_ERR(ef))
783 		return -ENOMEM;
784 
785 	mutex_lock(&eventfs_mutex);
786 	list_add_tail(&ef->list, &ei->e_top_files);
787 	ef->d_parent = parent;
788 	mutex_unlock(&eventfs_mutex);
789 	return 0;
790 }
791 
792 /**
793  * eventfs_add_file - add eventfs file to list to create later
794  * @name: the name of the file to create.
795  * @mode: the permission that the file should have.
796  * @ef_parent: parent eventfs_file for this file.
797  * @data: something that the caller will want to get to later on.
798  * @fop: struct file_operations that should be used for this file.
799  *
800  * This function is used to add the information needed to create a
801  * file within a subdirectory of the events directory. The file created
802  * will have the @mode permissions. The @data will be used to fill the
803  * inode.i_private when the open() call is done. The dentry and inodes are
804  * all created when they are referenced, and removed when they are no
805  * longer referenced.
806  */
807 int eventfs_add_file(const char *name, umode_t mode,
808 		     struct eventfs_file *ef_parent,
809 		     void *data,
810 		     const struct file_operations *fop)
811 {
812 	struct eventfs_file *ef;
813 
814 	if (security_locked_down(LOCKDOWN_TRACEFS))
815 		return -ENODEV;
816 
817 	if (!ef_parent)
818 		return -EINVAL;
819 
820 	if (!(mode & S_IFMT))
821 		mode |= S_IFREG;
822 
823 	ef = eventfs_prepare_ef(name, mode, fop, NULL, data);
824 	if (IS_ERR(ef))
825 		return -ENOMEM;
826 
827 	mutex_lock(&eventfs_mutex);
828 	list_add_tail(&ef->list, &ef_parent->ei->e_top_files);
829 	ef->d_parent = ef_parent->dentry;
830 	mutex_unlock(&eventfs_mutex);
831 	return 0;
832 }
833 
834 static LLIST_HEAD(free_list);
835 
836 static void eventfs_workfn(struct work_struct *work)
837 {
838         struct eventfs_file *ef, *tmp;
839         struct llist_node *llnode;
840 
841 	llnode = llist_del_all(&free_list);
842         llist_for_each_entry_safe(ef, tmp, llnode, llist) {
843 		/* This should only get here if it had a dentry */
844 		if (!WARN_ON_ONCE(!ef->dentry))
845 			dput(ef->dentry);
846         }
847 }
848 
849 static DECLARE_WORK(eventfs_work, eventfs_workfn);
850 
851 static void free_rcu_ef(struct rcu_head *head)
852 {
853 	struct eventfs_file *ef = container_of(head, struct eventfs_file, rcu);
854 
855 	if (ef->dentry) {
856 		/* Do not free the ef until all references of dentry are gone */
857 		if (llist_add(&ef->llist, &free_list))
858 			queue_work(system_unbound_wq, &eventfs_work);
859 		return;
860 	}
861 
862 	free_ef(ef);
863 }
864 
865 static void unhook_dentry(struct dentry *dentry)
866 {
867 	if (!dentry)
868 		return;
869 	/*
870 	 * Need to add a reference to the dentry that is expected by
871 	 * simple_recursive_removal(), which will include a dput().
872 	 */
873 	dget(dentry);
874 
875 	/*
876 	 * Also add a reference for the dput() in eventfs_workfn().
877 	 * That is required as that dput() will free the ei after
878 	 * the SRCU grace period is over.
879 	 */
880 	dget(dentry);
881 }
882 
883 /**
884  * eventfs_remove_rec - remove eventfs dir or file from list
885  * @ef: eventfs_file to be removed.
886  * @level: to check recursion depth
887  *
888  * The helper function eventfs_remove_rec() is used to clean up and free the
889  * associated data from eventfs for both of the added functions.
890  */
891 static void eventfs_remove_rec(struct eventfs_file *ef, int level)
892 {
893 	struct eventfs_file *ef_child;
894 
895 	if (!ef)
896 		return;
897 	/*
898 	 * Check recursion depth. It should never be greater than 3:
899 	 * 0 - events/
900 	 * 1 - events/group/
901 	 * 2 - events/group/event/
902 	 * 3 - events/group/event/file
903 	 */
904 	if (WARN_ON_ONCE(level > 3))
905 		return;
906 
907 	if (ef->ei) {
908 		/* search for nested folders or files */
909 		list_for_each_entry_srcu(ef_child, &ef->ei->e_top_files, list,
910 					 lockdep_is_held(&eventfs_mutex)) {
911 			eventfs_remove_rec(ef_child, level + 1);
912 		}
913 	}
914 
915 	ef->is_freed = 1;
916 
917 	unhook_dentry(ef->dentry);
918 
919 	list_del_rcu(&ef->list);
920 	call_srcu(&eventfs_srcu, &ef->rcu, free_rcu_ef);
921 }
922 
923 /**
924  * eventfs_remove - remove eventfs dir or file from list
925  * @ef: eventfs_file to be removed.
926  *
927  * This function acquire the eventfs_mutex lock and call eventfs_remove_rec()
928  */
929 void eventfs_remove(struct eventfs_file *ef)
930 {
931 	struct dentry *dentry;
932 
933 	if (!ef)
934 		return;
935 
936 	mutex_lock(&eventfs_mutex);
937 	dentry = ef->dentry;
938 	eventfs_remove_rec(ef, 0);
939 	mutex_unlock(&eventfs_mutex);
940 
941 	/*
942 	 * If any of the ei children has a dentry, then the ei itself
943 	 * must have a dentry.
944 	 */
945 	if (dentry)
946 		simple_recursive_removal(dentry, NULL);
947 }
948 
949 /**
950  * eventfs_remove_events_dir - remove eventfs dir or file from list
951  * @dentry: events's dentry to be removed.
952  *
953  * This function remove events main directory
954  */
955 void eventfs_remove_events_dir(struct dentry *dentry)
956 {
957 	struct eventfs_file *ef_child;
958 	struct eventfs_inode *ei;
959 	struct tracefs_inode *ti;
960 
961 	if (!dentry || !dentry->d_inode)
962 		return;
963 
964 	ti = get_tracefs(dentry->d_inode);
965 	if (!ti || !(ti->flags & TRACEFS_EVENT_INODE))
966 		return;
967 
968 	mutex_lock(&eventfs_mutex);
969 	ei = ti->private;
970 	list_for_each_entry_srcu(ef_child, &ei->e_top_files, list,
971 				 lockdep_is_held(&eventfs_mutex)) {
972 		eventfs_remove_rec(ef_child, 0);
973 	}
974 	mutex_unlock(&eventfs_mutex);
975 }
976