1  // SPDX-License-Identifier: GPL-2.0-only
2  /*
3   *  inode.c - part of tracefs, a pseudo file system for activating tracing
4   *
5   * Based on debugfs by: Greg Kroah-Hartman <greg@kroah.com>
6   *
7   *  Copyright (C) 2014 Red Hat Inc, author: Steven Rostedt <srostedt@redhat.com>
8   *
9   * tracefs is the file system that is used by the tracing infrastructure.
10   */
11  
12  #include <linux/module.h>
13  #include <linux/fs.h>
14  #include <linux/fs_context.h>
15  #include <linux/fs_parser.h>
16  #include <linux/kobject.h>
17  #include <linux/namei.h>
18  #include <linux/tracefs.h>
19  #include <linux/fsnotify.h>
20  #include <linux/security.h>
21  #include <linux/seq_file.h>
22  #include <linux/magic.h>
23  #include <linux/slab.h>
24  #include "internal.h"
25  
26  #define TRACEFS_DEFAULT_MODE	0700
27  static struct kmem_cache *tracefs_inode_cachep __ro_after_init;
28  
29  static struct vfsmount *tracefs_mount;
30  static int tracefs_mount_count;
31  static bool tracefs_registered;
32  
33  /*
34   * Keep track of all tracefs_inodes in order to update their
35   * flags if necessary on a remount.
36   */
37  static DEFINE_SPINLOCK(tracefs_inode_lock);
38  static LIST_HEAD(tracefs_inodes);
39  
tracefs_alloc_inode(struct super_block * sb)40  static struct inode *tracefs_alloc_inode(struct super_block *sb)
41  {
42  	struct tracefs_inode *ti;
43  	unsigned long flags;
44  
45  	ti = alloc_inode_sb(sb, tracefs_inode_cachep, GFP_KERNEL);
46  	if (!ti)
47  		return NULL;
48  
49  	spin_lock_irqsave(&tracefs_inode_lock, flags);
50  	list_add_rcu(&ti->list, &tracefs_inodes);
51  	spin_unlock_irqrestore(&tracefs_inode_lock, flags);
52  
53  	return &ti->vfs_inode;
54  }
55  
tracefs_free_inode(struct inode * inode)56  static void tracefs_free_inode(struct inode *inode)
57  {
58  	struct tracefs_inode *ti = get_tracefs(inode);
59  
60  	kmem_cache_free(tracefs_inode_cachep, ti);
61  }
62  
tracefs_destroy_inode(struct inode * inode)63  static void tracefs_destroy_inode(struct inode *inode)
64  {
65  	struct tracefs_inode *ti = get_tracefs(inode);
66  	unsigned long flags;
67  
68  	spin_lock_irqsave(&tracefs_inode_lock, flags);
69  	list_del_rcu(&ti->list);
70  	spin_unlock_irqrestore(&tracefs_inode_lock, flags);
71  }
72  
default_read_file(struct file * file,char __user * buf,size_t count,loff_t * ppos)73  static ssize_t default_read_file(struct file *file, char __user *buf,
74  				 size_t count, loff_t *ppos)
75  {
76  	return 0;
77  }
78  
default_write_file(struct file * file,const char __user * buf,size_t count,loff_t * ppos)79  static ssize_t default_write_file(struct file *file, const char __user *buf,
80  				   size_t count, loff_t *ppos)
81  {
82  	return count;
83  }
84  
85  static const struct file_operations tracefs_file_operations = {
86  	.read =		default_read_file,
87  	.write =	default_write_file,
88  	.open =		simple_open,
89  	.llseek =	noop_llseek,
90  };
91  
92  static struct tracefs_dir_ops {
93  	int (*mkdir)(const char *name);
94  	int (*rmdir)(const char *name);
95  } tracefs_ops __ro_after_init;
96  
get_dname(struct dentry * dentry)97  static char *get_dname(struct dentry *dentry)
98  {
99  	const char *dname;
100  	char *name;
101  	int len = dentry->d_name.len;
102  
103  	dname = dentry->d_name.name;
104  	name = kmalloc(len + 1, GFP_KERNEL);
105  	if (!name)
106  		return NULL;
107  	memcpy(name, dname, len);
108  	name[len] = 0;
109  	return name;
110  }
111  
tracefs_syscall_mkdir(struct mnt_idmap * idmap,struct inode * inode,struct dentry * dentry,umode_t mode)112  static int tracefs_syscall_mkdir(struct mnt_idmap *idmap,
113  				 struct inode *inode, struct dentry *dentry,
114  				 umode_t mode)
115  {
116  	struct tracefs_inode *ti;
117  	char *name;
118  	int ret;
119  
120  	name = get_dname(dentry);
121  	if (!name)
122  		return -ENOMEM;
123  
124  	/*
125  	 * This is a new directory that does not take the default of
126  	 * the rootfs. It becomes the default permissions for all the
127  	 * files and directories underneath it.
128  	 */
129  	ti = get_tracefs(inode);
130  	ti->flags |= TRACEFS_INSTANCE_INODE;
131  	ti->private = inode;
132  
133  	/*
134  	 * The mkdir call can call the generic functions that create
135  	 * the files within the tracefs system. It is up to the individual
136  	 * mkdir routine to handle races.
137  	 */
138  	inode_unlock(inode);
139  	ret = tracefs_ops.mkdir(name);
140  	inode_lock(inode);
141  
142  	kfree(name);
143  
144  	return ret;
145  }
146  
tracefs_syscall_rmdir(struct inode * inode,struct dentry * dentry)147  static int tracefs_syscall_rmdir(struct inode *inode, struct dentry *dentry)
148  {
149  	char *name;
150  	int ret;
151  
152  	name = get_dname(dentry);
153  	if (!name)
154  		return -ENOMEM;
155  
156  	/*
157  	 * The rmdir call can call the generic functions that create
158  	 * the files within the tracefs system. It is up to the individual
159  	 * rmdir routine to handle races.
160  	 * This time we need to unlock not only the parent (inode) but
161  	 * also the directory that is being deleted.
162  	 */
163  	inode_unlock(inode);
164  	inode_unlock(d_inode(dentry));
165  
166  	ret = tracefs_ops.rmdir(name);
167  
168  	inode_lock_nested(inode, I_MUTEX_PARENT);
169  	inode_lock(d_inode(dentry));
170  
171  	kfree(name);
172  
173  	return ret;
174  }
175  
set_tracefs_inode_owner(struct inode * inode)176  static void set_tracefs_inode_owner(struct inode *inode)
177  {
178  	struct tracefs_inode *ti = get_tracefs(inode);
179  	struct inode *root_inode = ti->private;
180  	kuid_t uid;
181  	kgid_t gid;
182  
183  	uid = root_inode->i_uid;
184  	gid = root_inode->i_gid;
185  
186  	/*
187  	 * If the root is not the mount point, then check the root's
188  	 * permissions. If it was never set, then default to the
189  	 * mount point.
190  	 */
191  	if (root_inode != d_inode(root_inode->i_sb->s_root)) {
192  		struct tracefs_inode *rti;
193  
194  		rti = get_tracefs(root_inode);
195  		root_inode = d_inode(root_inode->i_sb->s_root);
196  
197  		if (!(rti->flags & TRACEFS_UID_PERM_SET))
198  			uid = root_inode->i_uid;
199  
200  		if (!(rti->flags & TRACEFS_GID_PERM_SET))
201  			gid = root_inode->i_gid;
202  	}
203  
204  	/*
205  	 * If this inode has never been referenced, then update
206  	 * the permissions to the superblock.
207  	 */
208  	if (!(ti->flags & TRACEFS_UID_PERM_SET))
209  		inode->i_uid = uid;
210  
211  	if (!(ti->flags & TRACEFS_GID_PERM_SET))
212  		inode->i_gid = gid;
213  }
214  
tracefs_permission(struct mnt_idmap * idmap,struct inode * inode,int mask)215  static int tracefs_permission(struct mnt_idmap *idmap,
216  			      struct inode *inode, int mask)
217  {
218  	set_tracefs_inode_owner(inode);
219  	return generic_permission(idmap, inode, mask);
220  }
221  
tracefs_getattr(struct mnt_idmap * idmap,const struct path * path,struct kstat * stat,u32 request_mask,unsigned int flags)222  static int tracefs_getattr(struct mnt_idmap *idmap,
223  			   const struct path *path, struct kstat *stat,
224  			   u32 request_mask, unsigned int flags)
225  {
226  	struct inode *inode = d_backing_inode(path->dentry);
227  
228  	set_tracefs_inode_owner(inode);
229  	generic_fillattr(idmap, request_mask, inode, stat);
230  	return 0;
231  }
232  
tracefs_setattr(struct mnt_idmap * idmap,struct dentry * dentry,struct iattr * attr)233  static int tracefs_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
234  			   struct iattr *attr)
235  {
236  	unsigned int ia_valid = attr->ia_valid;
237  	struct inode *inode = d_inode(dentry);
238  	struct tracefs_inode *ti = get_tracefs(inode);
239  
240  	if (ia_valid & ATTR_UID)
241  		ti->flags |= TRACEFS_UID_PERM_SET;
242  
243  	if (ia_valid & ATTR_GID)
244  		ti->flags |= TRACEFS_GID_PERM_SET;
245  
246  	return simple_setattr(idmap, dentry, attr);
247  }
248  
249  static const struct inode_operations tracefs_instance_dir_inode_operations = {
250  	.lookup		= simple_lookup,
251  	.mkdir		= tracefs_syscall_mkdir,
252  	.rmdir		= tracefs_syscall_rmdir,
253  	.permission	= tracefs_permission,
254  	.getattr	= tracefs_getattr,
255  	.setattr	= tracefs_setattr,
256  };
257  
258  static const struct inode_operations tracefs_dir_inode_operations = {
259  	.lookup		= simple_lookup,
260  	.permission	= tracefs_permission,
261  	.getattr	= tracefs_getattr,
262  	.setattr	= tracefs_setattr,
263  };
264  
265  static const struct inode_operations tracefs_file_inode_operations = {
266  	.permission	= tracefs_permission,
267  	.getattr	= tracefs_getattr,
268  	.setattr	= tracefs_setattr,
269  };
270  
tracefs_get_inode(struct super_block * sb)271  struct inode *tracefs_get_inode(struct super_block *sb)
272  {
273  	struct inode *inode = new_inode(sb);
274  	if (inode) {
275  		inode->i_ino = get_next_ino();
276  		simple_inode_init_ts(inode);
277  	}
278  	return inode;
279  }
280  
281  struct tracefs_fs_info {
282  	kuid_t uid;
283  	kgid_t gid;
284  	umode_t mode;
285  	/* Opt_* bitfield. */
286  	unsigned int opts;
287  };
288  
289  enum {
290  	Opt_uid,
291  	Opt_gid,
292  	Opt_mode,
293  };
294  
295  static const struct fs_parameter_spec tracefs_param_specs[] = {
296  	fsparam_gid	("gid",		Opt_gid),
297  	fsparam_u32oct	("mode",	Opt_mode),
298  	fsparam_uid	("uid",		Opt_uid),
299  	{}
300  };
301  
tracefs_parse_param(struct fs_context * fc,struct fs_parameter * param)302  static int tracefs_parse_param(struct fs_context *fc, struct fs_parameter *param)
303  {
304  	struct tracefs_fs_info *opts = fc->s_fs_info;
305  	struct fs_parse_result result;
306  	int opt;
307  
308  	opt = fs_parse(fc, tracefs_param_specs, param, &result);
309  	if (opt < 0)
310  		return opt;
311  
312  	switch (opt) {
313  	case Opt_uid:
314  		opts->uid = result.uid;
315  		break;
316  	case Opt_gid:
317  		opts->gid = result.gid;
318  		break;
319  	case Opt_mode:
320  		opts->mode = result.uint_32 & S_IALLUGO;
321  		break;
322  	/*
323  	 * We might like to report bad mount options here;
324  	 * but traditionally tracefs has ignored all mount options
325  	 */
326  	}
327  
328  	opts->opts |= BIT(opt);
329  
330  	return 0;
331  }
332  
tracefs_apply_options(struct super_block * sb,bool remount)333  static int tracefs_apply_options(struct super_block *sb, bool remount)
334  {
335  	struct tracefs_fs_info *fsi = sb->s_fs_info;
336  	struct inode *inode = d_inode(sb->s_root);
337  	struct tracefs_inode *ti;
338  	bool update_uid, update_gid;
339  	umode_t tmp_mode;
340  
341  	/*
342  	 * On remount, only reset mode/uid/gid if they were provided as mount
343  	 * options.
344  	 */
345  
346  	if (!remount || fsi->opts & BIT(Opt_mode)) {
347  		tmp_mode = READ_ONCE(inode->i_mode) & ~S_IALLUGO;
348  		tmp_mode |= fsi->mode;
349  		WRITE_ONCE(inode->i_mode, tmp_mode);
350  	}
351  
352  	if (!remount || fsi->opts & BIT(Opt_uid))
353  		inode->i_uid = fsi->uid;
354  
355  	if (!remount || fsi->opts & BIT(Opt_gid))
356  		inode->i_gid = fsi->gid;
357  
358  	if (remount && (fsi->opts & BIT(Opt_uid) || fsi->opts & BIT(Opt_gid))) {
359  
360  		update_uid = fsi->opts & BIT(Opt_uid);
361  		update_gid = fsi->opts & BIT(Opt_gid);
362  
363  		rcu_read_lock();
364  		list_for_each_entry_rcu(ti, &tracefs_inodes, list) {
365  			if (update_uid) {
366  				ti->flags &= ~TRACEFS_UID_PERM_SET;
367  				ti->vfs_inode.i_uid = fsi->uid;
368  			}
369  
370  			if (update_gid) {
371  				ti->flags &= ~TRACEFS_GID_PERM_SET;
372  				ti->vfs_inode.i_gid = fsi->gid;
373  			}
374  
375  			/*
376  			 * Note, the above ti->vfs_inode updates are
377  			 * used in eventfs_remount() so they must come
378  			 * before calling it.
379  			 */
380  			if (ti->flags & TRACEFS_EVENT_INODE)
381  				eventfs_remount(ti, update_uid, update_gid);
382  		}
383  		rcu_read_unlock();
384  	}
385  
386  	return 0;
387  }
388  
tracefs_reconfigure(struct fs_context * fc)389  static int tracefs_reconfigure(struct fs_context *fc)
390  {
391  	struct super_block *sb = fc->root->d_sb;
392  	struct tracefs_fs_info *sb_opts = sb->s_fs_info;
393  	struct tracefs_fs_info *new_opts = fc->s_fs_info;
394  
395  	if (!new_opts)
396  		return 0;
397  
398  	sync_filesystem(sb);
399  	/* structure copy of new mount options to sb */
400  	*sb_opts = *new_opts;
401  
402  	return tracefs_apply_options(sb, true);
403  }
404  
tracefs_show_options(struct seq_file * m,struct dentry * root)405  static int tracefs_show_options(struct seq_file *m, struct dentry *root)
406  {
407  	struct tracefs_fs_info *fsi = root->d_sb->s_fs_info;
408  
409  	if (!uid_eq(fsi->uid, GLOBAL_ROOT_UID))
410  		seq_printf(m, ",uid=%u",
411  			   from_kuid_munged(&init_user_ns, fsi->uid));
412  	if (!gid_eq(fsi->gid, GLOBAL_ROOT_GID))
413  		seq_printf(m, ",gid=%u",
414  			   from_kgid_munged(&init_user_ns, fsi->gid));
415  	if (fsi->mode != TRACEFS_DEFAULT_MODE)
416  		seq_printf(m, ",mode=%o", fsi->mode);
417  
418  	return 0;
419  }
420  
tracefs_drop_inode(struct inode * inode)421  static int tracefs_drop_inode(struct inode *inode)
422  {
423  	struct tracefs_inode *ti = get_tracefs(inode);
424  
425  	/*
426  	 * This inode is being freed and cannot be used for
427  	 * eventfs. Clear the flag so that it doesn't call into
428  	 * eventfs during the remount flag updates. The eventfs_inode
429  	 * gets freed after an RCU cycle, so the content will still
430  	 * be safe if the iteration is going on now.
431  	 */
432  	ti->flags &= ~TRACEFS_EVENT_INODE;
433  
434  	return 1;
435  }
436  
437  static const struct super_operations tracefs_super_operations = {
438  	.alloc_inode    = tracefs_alloc_inode,
439  	.free_inode     = tracefs_free_inode,
440  	.destroy_inode  = tracefs_destroy_inode,
441  	.drop_inode     = tracefs_drop_inode,
442  	.statfs		= simple_statfs,
443  	.show_options	= tracefs_show_options,
444  };
445  
446  /*
447   * It would be cleaner if eventfs had its own dentry ops.
448   *
449   * Note that d_revalidate is called potentially under RCU,
450   * so it can't take the eventfs mutex etc. It's fine - if
451   * we open a file just as it's marked dead, things will
452   * still work just fine, and just see the old stale case.
453   */
tracefs_d_release(struct dentry * dentry)454  static void tracefs_d_release(struct dentry *dentry)
455  {
456  	if (dentry->d_fsdata)
457  		eventfs_d_release(dentry);
458  }
459  
tracefs_d_revalidate(struct dentry * dentry,unsigned int flags)460  static int tracefs_d_revalidate(struct dentry *dentry, unsigned int flags)
461  {
462  	struct eventfs_inode *ei = dentry->d_fsdata;
463  
464  	return !(ei && ei->is_freed);
465  }
466  
467  static const struct dentry_operations tracefs_dentry_operations = {
468  	.d_revalidate = tracefs_d_revalidate,
469  	.d_release = tracefs_d_release,
470  };
471  
tracefs_fill_super(struct super_block * sb,struct fs_context * fc)472  static int tracefs_fill_super(struct super_block *sb, struct fs_context *fc)
473  {
474  	static const struct tree_descr trace_files[] = {{""}};
475  	int err;
476  
477  	err = simple_fill_super(sb, TRACEFS_MAGIC, trace_files);
478  	if (err)
479  		return err;
480  
481  	sb->s_op = &tracefs_super_operations;
482  	sb->s_d_op = &tracefs_dentry_operations;
483  
484  	return 0;
485  }
486  
tracefs_get_tree(struct fs_context * fc)487  static int tracefs_get_tree(struct fs_context *fc)
488  {
489  	int err = get_tree_single(fc, tracefs_fill_super);
490  
491  	if (err)
492  		return err;
493  
494  	return tracefs_reconfigure(fc);
495  }
496  
tracefs_free_fc(struct fs_context * fc)497  static void tracefs_free_fc(struct fs_context *fc)
498  {
499  	kfree(fc->s_fs_info);
500  }
501  
502  static const struct fs_context_operations tracefs_context_ops = {
503  	.free		= tracefs_free_fc,
504  	.parse_param	= tracefs_parse_param,
505  	.get_tree	= tracefs_get_tree,
506  	.reconfigure	= tracefs_reconfigure,
507  };
508  
tracefs_init_fs_context(struct fs_context * fc)509  static int tracefs_init_fs_context(struct fs_context *fc)
510  {
511  	struct tracefs_fs_info *fsi;
512  
513  	fsi = kzalloc(sizeof(struct tracefs_fs_info), GFP_KERNEL);
514  	if (!fsi)
515  		return -ENOMEM;
516  
517  	fsi->mode = TRACEFS_DEFAULT_MODE;
518  
519  	fc->s_fs_info = fsi;
520  	fc->ops = &tracefs_context_ops;
521  	return 0;
522  }
523  
524  static struct file_system_type trace_fs_type = {
525  	.owner =	THIS_MODULE,
526  	.name =		"tracefs",
527  	.init_fs_context = tracefs_init_fs_context,
528  	.parameters	= tracefs_param_specs,
529  	.kill_sb =	kill_litter_super,
530  };
531  MODULE_ALIAS_FS("tracefs");
532  
tracefs_start_creating(const char * name,struct dentry * parent)533  struct dentry *tracefs_start_creating(const char *name, struct dentry *parent)
534  {
535  	struct dentry *dentry;
536  	int error;
537  
538  	pr_debug("tracefs: creating file '%s'\n",name);
539  
540  	error = simple_pin_fs(&trace_fs_type, &tracefs_mount,
541  			      &tracefs_mount_count);
542  	if (error)
543  		return ERR_PTR(error);
544  
545  	/* If the parent is not specified, we create it in the root.
546  	 * We need the root dentry to do this, which is in the super
547  	 * block. A pointer to that is in the struct vfsmount that we
548  	 * have around.
549  	 */
550  	if (!parent)
551  		parent = tracefs_mount->mnt_root;
552  
553  	inode_lock(d_inode(parent));
554  	if (unlikely(IS_DEADDIR(d_inode(parent))))
555  		dentry = ERR_PTR(-ENOENT);
556  	else
557  		dentry = lookup_one_len(name, parent, strlen(name));
558  	if (!IS_ERR(dentry) && d_inode(dentry)) {
559  		dput(dentry);
560  		dentry = ERR_PTR(-EEXIST);
561  	}
562  
563  	if (IS_ERR(dentry)) {
564  		inode_unlock(d_inode(parent));
565  		simple_release_fs(&tracefs_mount, &tracefs_mount_count);
566  	}
567  
568  	return dentry;
569  }
570  
tracefs_failed_creating(struct dentry * dentry)571  struct dentry *tracefs_failed_creating(struct dentry *dentry)
572  {
573  	inode_unlock(d_inode(dentry->d_parent));
574  	dput(dentry);
575  	simple_release_fs(&tracefs_mount, &tracefs_mount_count);
576  	return NULL;
577  }
578  
tracefs_end_creating(struct dentry * dentry)579  struct dentry *tracefs_end_creating(struct dentry *dentry)
580  {
581  	inode_unlock(d_inode(dentry->d_parent));
582  	return dentry;
583  }
584  
585  /* Find the inode that this will use for default */
instance_inode(struct dentry * parent,struct inode * inode)586  static struct inode *instance_inode(struct dentry *parent, struct inode *inode)
587  {
588  	struct tracefs_inode *ti;
589  
590  	/* If parent is NULL then use root inode */
591  	if (!parent)
592  		return d_inode(inode->i_sb->s_root);
593  
594  	/* Find the inode that is flagged as an instance or the root inode */
595  	while (!IS_ROOT(parent)) {
596  		ti = get_tracefs(d_inode(parent));
597  		if (ti->flags & TRACEFS_INSTANCE_INODE)
598  			break;
599  		parent = parent->d_parent;
600  	}
601  
602  	return d_inode(parent);
603  }
604  
605  /**
606   * tracefs_create_file - create a file in the tracefs filesystem
607   * @name: a pointer to a string containing the name of the file to create.
608   * @mode: the permission that the file should have.
609   * @parent: a pointer to the parent dentry for this file.  This should be a
610   *          directory dentry if set.  If this parameter is NULL, then the
611   *          file will be created in the root of the tracefs filesystem.
612   * @data: a pointer to something that the caller will want to get to later
613   *        on.  The inode.i_private pointer will point to this value on
614   *        the open() call.
615   * @fops: a pointer to a struct file_operations that should be used for
616   *        this file.
617   *
618   * This is the basic "create a file" function for tracefs.  It allows for a
619   * wide range of flexibility in creating a file, or a directory (if you want
620   * to create a directory, the tracefs_create_dir() function is
621   * recommended to be used instead.)
622   *
623   * This function will return a pointer to a dentry if it succeeds.  This
624   * pointer must be passed to the tracefs_remove() function when the file is
625   * to be removed (no automatic cleanup happens if your module is unloaded,
626   * you are responsible here.)  If an error occurs, %NULL will be returned.
627   *
628   * If tracefs is not enabled in the kernel, the value -%ENODEV will be
629   * returned.
630   */
tracefs_create_file(const char * name,umode_t mode,struct dentry * parent,void * data,const struct file_operations * fops)631  struct dentry *tracefs_create_file(const char *name, umode_t mode,
632  				   struct dentry *parent, void *data,
633  				   const struct file_operations *fops)
634  {
635  	struct tracefs_inode *ti;
636  	struct dentry *dentry;
637  	struct inode *inode;
638  
639  	if (security_locked_down(LOCKDOWN_TRACEFS))
640  		return NULL;
641  
642  	if (!(mode & S_IFMT))
643  		mode |= S_IFREG;
644  	BUG_ON(!S_ISREG(mode));
645  	dentry = tracefs_start_creating(name, parent);
646  
647  	if (IS_ERR(dentry))
648  		return NULL;
649  
650  	inode = tracefs_get_inode(dentry->d_sb);
651  	if (unlikely(!inode))
652  		return tracefs_failed_creating(dentry);
653  
654  	ti = get_tracefs(inode);
655  	ti->private = instance_inode(parent, inode);
656  
657  	inode->i_mode = mode;
658  	inode->i_op = &tracefs_file_inode_operations;
659  	inode->i_fop = fops ? fops : &tracefs_file_operations;
660  	inode->i_private = data;
661  	inode->i_uid = d_inode(dentry->d_parent)->i_uid;
662  	inode->i_gid = d_inode(dentry->d_parent)->i_gid;
663  	d_instantiate(dentry, inode);
664  	fsnotify_create(d_inode(dentry->d_parent), dentry);
665  	return tracefs_end_creating(dentry);
666  }
667  
__create_dir(const char * name,struct dentry * parent,const struct inode_operations * ops)668  static struct dentry *__create_dir(const char *name, struct dentry *parent,
669  				   const struct inode_operations *ops)
670  {
671  	struct tracefs_inode *ti;
672  	struct dentry *dentry = tracefs_start_creating(name, parent);
673  	struct inode *inode;
674  
675  	if (IS_ERR(dentry))
676  		return NULL;
677  
678  	inode = tracefs_get_inode(dentry->d_sb);
679  	if (unlikely(!inode))
680  		return tracefs_failed_creating(dentry);
681  
682  	/* Do not set bits for OTH */
683  	inode->i_mode = S_IFDIR | S_IRWXU | S_IRUSR| S_IRGRP | S_IXUSR | S_IXGRP;
684  	inode->i_op = ops;
685  	inode->i_fop = &simple_dir_operations;
686  	inode->i_uid = d_inode(dentry->d_parent)->i_uid;
687  	inode->i_gid = d_inode(dentry->d_parent)->i_gid;
688  
689  	ti = get_tracefs(inode);
690  	ti->private = instance_inode(parent, inode);
691  
692  	/* directory inodes start off with i_nlink == 2 (for "." entry) */
693  	inc_nlink(inode);
694  	d_instantiate(dentry, inode);
695  	inc_nlink(d_inode(dentry->d_parent));
696  	fsnotify_mkdir(d_inode(dentry->d_parent), dentry);
697  	return tracefs_end_creating(dentry);
698  }
699  
700  /**
701   * tracefs_create_dir - create a directory in the tracefs filesystem
702   * @name: a pointer to a string containing the name of the directory to
703   *        create.
704   * @parent: a pointer to the parent dentry for this file.  This should be a
705   *          directory dentry if set.  If this parameter is NULL, then the
706   *          directory will be created in the root of the tracefs filesystem.
707   *
708   * This function creates a directory in tracefs with the given name.
709   *
710   * This function will return a pointer to a dentry if it succeeds.  This
711   * pointer must be passed to the tracefs_remove() function when the file is
712   * to be removed. If an error occurs, %NULL will be returned.
713   *
714   * If tracing is not enabled in the kernel, the value -%ENODEV will be
715   * returned.
716   */
tracefs_create_dir(const char * name,struct dentry * parent)717  struct dentry *tracefs_create_dir(const char *name, struct dentry *parent)
718  {
719  	if (security_locked_down(LOCKDOWN_TRACEFS))
720  		return NULL;
721  
722  	return __create_dir(name, parent, &tracefs_dir_inode_operations);
723  }
724  
725  /**
726   * tracefs_create_instance_dir - create the tracing instances directory
727   * @name: The name of the instances directory to create
728   * @parent: The parent directory that the instances directory will exist
729   * @mkdir: The function to call when a mkdir is performed.
730   * @rmdir: The function to call when a rmdir is performed.
731   *
732   * Only one instances directory is allowed.
733   *
734   * The instances directory is special as it allows for mkdir and rmdir
735   * to be done by userspace. When a mkdir or rmdir is performed, the inode
736   * locks are released and the methods passed in (@mkdir and @rmdir) are
737   * called without locks and with the name of the directory being created
738   * within the instances directory.
739   *
740   * Returns the dentry of the instances directory.
741   */
tracefs_create_instance_dir(const char * name,struct dentry * parent,int (* mkdir)(const char * name),int (* rmdir)(const char * name))742  __init struct dentry *tracefs_create_instance_dir(const char *name,
743  					  struct dentry *parent,
744  					  int (*mkdir)(const char *name),
745  					  int (*rmdir)(const char *name))
746  {
747  	struct dentry *dentry;
748  
749  	/* Only allow one instance of the instances directory. */
750  	if (WARN_ON(tracefs_ops.mkdir || tracefs_ops.rmdir))
751  		return NULL;
752  
753  	dentry = __create_dir(name, parent, &tracefs_instance_dir_inode_operations);
754  	if (!dentry)
755  		return NULL;
756  
757  	tracefs_ops.mkdir = mkdir;
758  	tracefs_ops.rmdir = rmdir;
759  
760  	return dentry;
761  }
762  
remove_one(struct dentry * victim)763  static void remove_one(struct dentry *victim)
764  {
765  	simple_release_fs(&tracefs_mount, &tracefs_mount_count);
766  }
767  
768  /**
769   * tracefs_remove - recursively removes a directory
770   * @dentry: a pointer to a the dentry of the directory to be removed.
771   *
772   * This function recursively removes a directory tree in tracefs that
773   * was previously created with a call to another tracefs function
774   * (like tracefs_create_file() or variants thereof.)
775   */
tracefs_remove(struct dentry * dentry)776  void tracefs_remove(struct dentry *dentry)
777  {
778  	if (IS_ERR_OR_NULL(dentry))
779  		return;
780  
781  	simple_pin_fs(&trace_fs_type, &tracefs_mount, &tracefs_mount_count);
782  	simple_recursive_removal(dentry, remove_one);
783  	simple_release_fs(&tracefs_mount, &tracefs_mount_count);
784  }
785  
786  /**
787   * tracefs_initialized - Tells whether tracefs has been registered
788   */
tracefs_initialized(void)789  bool tracefs_initialized(void)
790  {
791  	return tracefs_registered;
792  }
793  
init_once(void * foo)794  static void init_once(void *foo)
795  {
796  	struct tracefs_inode *ti = (struct tracefs_inode *) foo;
797  
798  	/* inode_init_once() calls memset() on the vfs_inode portion */
799  	inode_init_once(&ti->vfs_inode);
800  
801  	/* Zero out the rest */
802  	memset_after(ti, 0, vfs_inode);
803  }
804  
tracefs_init(void)805  static int __init tracefs_init(void)
806  {
807  	int retval;
808  
809  	tracefs_inode_cachep = kmem_cache_create("tracefs_inode_cache",
810  						 sizeof(struct tracefs_inode),
811  						 0, (SLAB_RECLAIM_ACCOUNT|
812  						     SLAB_ACCOUNT),
813  						 init_once);
814  	if (!tracefs_inode_cachep)
815  		return -ENOMEM;
816  
817  	retval = sysfs_create_mount_point(kernel_kobj, "tracing");
818  	if (retval)
819  		return -EINVAL;
820  
821  	retval = register_filesystem(&trace_fs_type);
822  	if (!retval)
823  		tracefs_registered = true;
824  
825  	return retval;
826  }
827  core_initcall(tracefs_init);
828