xref: /openbmc/linux/fs/tracefs/inode.c (revision 726f4c24)
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/mount.h>
15 #include <linux/kobject.h>
16 #include <linux/namei.h>
17 #include <linux/tracefs.h>
18 #include <linux/fsnotify.h>
19 #include <linux/security.h>
20 #include <linux/seq_file.h>
21 #include <linux/parser.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 		inode->i_atime = inode->i_mtime = inode_set_ctime_current(inode);
277 	}
278 	return inode;
279 }
280 
281 struct tracefs_mount_opts {
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 	Opt_err
294 };
295 
296 static const match_table_t tokens = {
297 	{Opt_uid, "uid=%u"},
298 	{Opt_gid, "gid=%u"},
299 	{Opt_mode, "mode=%o"},
300 	{Opt_err, NULL}
301 };
302 
303 struct tracefs_fs_info {
304 	struct tracefs_mount_opts mount_opts;
305 };
306 
tracefs_parse_options(char * data,struct tracefs_mount_opts * opts)307 static int tracefs_parse_options(char *data, struct tracefs_mount_opts *opts)
308 {
309 	substring_t args[MAX_OPT_ARGS];
310 	int option;
311 	int token;
312 	kuid_t uid;
313 	kgid_t gid;
314 	char *p;
315 
316 	opts->opts = 0;
317 	opts->mode = TRACEFS_DEFAULT_MODE;
318 
319 	while ((p = strsep(&data, ",")) != NULL) {
320 		if (!*p)
321 			continue;
322 
323 		token = match_token(p, tokens, args);
324 		switch (token) {
325 		case Opt_uid:
326 			if (match_int(&args[0], &option))
327 				return -EINVAL;
328 			uid = make_kuid(current_user_ns(), option);
329 			if (!uid_valid(uid))
330 				return -EINVAL;
331 			opts->uid = uid;
332 			break;
333 		case Opt_gid:
334 			if (match_int(&args[0], &option))
335 				return -EINVAL;
336 			gid = make_kgid(current_user_ns(), option);
337 			if (!gid_valid(gid))
338 				return -EINVAL;
339 			opts->gid = gid;
340 			break;
341 		case Opt_mode:
342 			if (match_octal(&args[0], &option))
343 				return -EINVAL;
344 			opts->mode = option & S_IALLUGO;
345 			break;
346 		/*
347 		 * We might like to report bad mount options here;
348 		 * but traditionally tracefs has ignored all mount options
349 		 */
350 		}
351 
352 		opts->opts |= BIT(token);
353 	}
354 
355 	return 0;
356 }
357 
tracefs_apply_options(struct super_block * sb,bool remount)358 static int tracefs_apply_options(struct super_block *sb, bool remount)
359 {
360 	struct tracefs_fs_info *fsi = sb->s_fs_info;
361 	struct inode *inode = d_inode(sb->s_root);
362 	struct tracefs_mount_opts *opts = &fsi->mount_opts;
363 	struct tracefs_inode *ti;
364 	bool update_uid, update_gid;
365 	umode_t tmp_mode;
366 
367 	/*
368 	 * On remount, only reset mode/uid/gid if they were provided as mount
369 	 * options.
370 	 */
371 
372 	if (!remount || opts->opts & BIT(Opt_mode)) {
373 		tmp_mode = READ_ONCE(inode->i_mode) & ~S_IALLUGO;
374 		tmp_mode |= opts->mode;
375 		WRITE_ONCE(inode->i_mode, tmp_mode);
376 	}
377 
378 	if (!remount || opts->opts & BIT(Opt_uid))
379 		inode->i_uid = opts->uid;
380 
381 	if (!remount || opts->opts & BIT(Opt_gid))
382 		inode->i_gid = opts->gid;
383 
384 	if (remount && (opts->opts & BIT(Opt_uid) || opts->opts & BIT(Opt_gid))) {
385 
386 		update_uid = opts->opts & BIT(Opt_uid);
387 		update_gid = opts->opts & BIT(Opt_gid);
388 
389 		rcu_read_lock();
390 		list_for_each_entry_rcu(ti, &tracefs_inodes, list) {
391 			if (update_uid)
392 				ti->flags &= ~TRACEFS_UID_PERM_SET;
393 
394 			if (update_gid)
395 				ti->flags &= ~TRACEFS_GID_PERM_SET;
396 
397 			if (ti->flags & TRACEFS_EVENT_INODE)
398 				eventfs_remount(ti, update_uid, update_gid);
399 		}
400 		rcu_read_unlock();
401 	}
402 
403 	return 0;
404 }
405 
tracefs_remount(struct super_block * sb,int * flags,char * data)406 static int tracefs_remount(struct super_block *sb, int *flags, char *data)
407 {
408 	int err;
409 	struct tracefs_fs_info *fsi = sb->s_fs_info;
410 
411 	sync_filesystem(sb);
412 	err = tracefs_parse_options(data, &fsi->mount_opts);
413 	if (err)
414 		goto fail;
415 
416 	tracefs_apply_options(sb, true);
417 
418 fail:
419 	return err;
420 }
421 
tracefs_show_options(struct seq_file * m,struct dentry * root)422 static int tracefs_show_options(struct seq_file *m, struct dentry *root)
423 {
424 	struct tracefs_fs_info *fsi = root->d_sb->s_fs_info;
425 	struct tracefs_mount_opts *opts = &fsi->mount_opts;
426 
427 	if (!uid_eq(opts->uid, GLOBAL_ROOT_UID))
428 		seq_printf(m, ",uid=%u",
429 			   from_kuid_munged(&init_user_ns, opts->uid));
430 	if (!gid_eq(opts->gid, GLOBAL_ROOT_GID))
431 		seq_printf(m, ",gid=%u",
432 			   from_kgid_munged(&init_user_ns, opts->gid));
433 	if (opts->mode != TRACEFS_DEFAULT_MODE)
434 		seq_printf(m, ",mode=%o", opts->mode);
435 
436 	return 0;
437 }
438 
tracefs_drop_inode(struct inode * inode)439 static int tracefs_drop_inode(struct inode *inode)
440 {
441 	struct tracefs_inode *ti = get_tracefs(inode);
442 
443 	/*
444 	 * This inode is being freed and cannot be used for
445 	 * eventfs. Clear the flag so that it doesn't call into
446 	 * eventfs during the remount flag updates. The eventfs_inode
447 	 * gets freed after an RCU cycle, so the content will still
448 	 * be safe if the iteration is going on now.
449 	 */
450 	ti->flags &= ~TRACEFS_EVENT_INODE;
451 
452 	return 1;
453 }
454 
455 static const struct super_operations tracefs_super_operations = {
456 	.alloc_inode    = tracefs_alloc_inode,
457 	.free_inode     = tracefs_free_inode,
458 	.destroy_inode  = tracefs_destroy_inode,
459 	.drop_inode     = tracefs_drop_inode,
460 	.statfs		= simple_statfs,
461 	.remount_fs	= tracefs_remount,
462 	.show_options	= tracefs_show_options,
463 };
464 
465 /*
466  * It would be cleaner if eventfs had its own dentry ops.
467  *
468  * Note that d_revalidate is called potentially under RCU,
469  * so it can't take the eventfs mutex etc. It's fine - if
470  * we open a file just as it's marked dead, things will
471  * still work just fine, and just see the old stale case.
472  */
tracefs_d_release(struct dentry * dentry)473 static void tracefs_d_release(struct dentry *dentry)
474 {
475 	if (dentry->d_fsdata)
476 		eventfs_d_release(dentry);
477 }
478 
tracefs_d_revalidate(struct dentry * dentry,unsigned int flags)479 static int tracefs_d_revalidate(struct dentry *dentry, unsigned int flags)
480 {
481 	struct eventfs_inode *ei = dentry->d_fsdata;
482 
483 	return !(ei && ei->is_freed);
484 }
485 
486 static const struct dentry_operations tracefs_dentry_operations = {
487 	.d_revalidate = tracefs_d_revalidate,
488 	.d_release = tracefs_d_release,
489 };
490 
trace_fill_super(struct super_block * sb,void * data,int silent)491 static int trace_fill_super(struct super_block *sb, void *data, int silent)
492 {
493 	static const struct tree_descr trace_files[] = {{""}};
494 	struct tracefs_fs_info *fsi;
495 	int err;
496 
497 	fsi = kzalloc(sizeof(struct tracefs_fs_info), GFP_KERNEL);
498 	sb->s_fs_info = fsi;
499 	if (!fsi) {
500 		err = -ENOMEM;
501 		goto fail;
502 	}
503 
504 	err = tracefs_parse_options(data, &fsi->mount_opts);
505 	if (err)
506 		goto fail;
507 
508 	err  =  simple_fill_super(sb, TRACEFS_MAGIC, trace_files);
509 	if (err)
510 		goto fail;
511 
512 	sb->s_op = &tracefs_super_operations;
513 	sb->s_d_op = &tracefs_dentry_operations;
514 
515 	tracefs_apply_options(sb, false);
516 
517 	return 0;
518 
519 fail:
520 	kfree(fsi);
521 	sb->s_fs_info = NULL;
522 	return err;
523 }
524 
trace_mount(struct file_system_type * fs_type,int flags,const char * dev_name,void * data)525 static struct dentry *trace_mount(struct file_system_type *fs_type,
526 			int flags, const char *dev_name,
527 			void *data)
528 {
529 	return mount_single(fs_type, flags, data, trace_fill_super);
530 }
531 
532 static struct file_system_type trace_fs_type = {
533 	.owner =	THIS_MODULE,
534 	.name =		"tracefs",
535 	.mount =	trace_mount,
536 	.kill_sb =	kill_litter_super,
537 };
538 MODULE_ALIAS_FS("tracefs");
539 
tracefs_start_creating(const char * name,struct dentry * parent)540 struct dentry *tracefs_start_creating(const char *name, struct dentry *parent)
541 {
542 	struct dentry *dentry;
543 	int error;
544 
545 	pr_debug("tracefs: creating file '%s'\n",name);
546 
547 	error = simple_pin_fs(&trace_fs_type, &tracefs_mount,
548 			      &tracefs_mount_count);
549 	if (error)
550 		return ERR_PTR(error);
551 
552 	/* If the parent is not specified, we create it in the root.
553 	 * We need the root dentry to do this, which is in the super
554 	 * block. A pointer to that is in the struct vfsmount that we
555 	 * have around.
556 	 */
557 	if (!parent)
558 		parent = tracefs_mount->mnt_root;
559 
560 	inode_lock(d_inode(parent));
561 	if (unlikely(IS_DEADDIR(d_inode(parent))))
562 		dentry = ERR_PTR(-ENOENT);
563 	else
564 		dentry = lookup_one_len(name, parent, strlen(name));
565 	if (!IS_ERR(dentry) && d_inode(dentry)) {
566 		dput(dentry);
567 		dentry = ERR_PTR(-EEXIST);
568 	}
569 
570 	if (IS_ERR(dentry)) {
571 		inode_unlock(d_inode(parent));
572 		simple_release_fs(&tracefs_mount, &tracefs_mount_count);
573 	}
574 
575 	return dentry;
576 }
577 
tracefs_failed_creating(struct dentry * dentry)578 struct dentry *tracefs_failed_creating(struct dentry *dentry)
579 {
580 	inode_unlock(d_inode(dentry->d_parent));
581 	dput(dentry);
582 	simple_release_fs(&tracefs_mount, &tracefs_mount_count);
583 	return NULL;
584 }
585 
tracefs_end_creating(struct dentry * dentry)586 struct dentry *tracefs_end_creating(struct dentry *dentry)
587 {
588 	inode_unlock(d_inode(dentry->d_parent));
589 	return dentry;
590 }
591 
592 /* Find the inode that this will use for default */
instance_inode(struct dentry * parent,struct inode * inode)593 static struct inode *instance_inode(struct dentry *parent, struct inode *inode)
594 {
595 	struct tracefs_inode *ti;
596 
597 	/* If parent is NULL then use root inode */
598 	if (!parent)
599 		return d_inode(inode->i_sb->s_root);
600 
601 	/* Find the inode that is flagged as an instance or the root inode */
602 	while (!IS_ROOT(parent)) {
603 		ti = get_tracefs(d_inode(parent));
604 		if (ti->flags & TRACEFS_INSTANCE_INODE)
605 			break;
606 		parent = parent->d_parent;
607 	}
608 
609 	return d_inode(parent);
610 }
611 
612 /**
613  * tracefs_create_file - create a file in the tracefs filesystem
614  * @name: a pointer to a string containing the name of the file to create.
615  * @mode: the permission that the file should have.
616  * @parent: a pointer to the parent dentry for this file.  This should be a
617  *          directory dentry if set.  If this parameter is NULL, then the
618  *          file will be created in the root of the tracefs filesystem.
619  * @data: a pointer to something that the caller will want to get to later
620  *        on.  The inode.i_private pointer will point to this value on
621  *        the open() call.
622  * @fops: a pointer to a struct file_operations that should be used for
623  *        this file.
624  *
625  * This is the basic "create a file" function for tracefs.  It allows for a
626  * wide range of flexibility in creating a file, or a directory (if you want
627  * to create a directory, the tracefs_create_dir() function is
628  * recommended to be used instead.)
629  *
630  * This function will return a pointer to a dentry if it succeeds.  This
631  * pointer must be passed to the tracefs_remove() function when the file is
632  * to be removed (no automatic cleanup happens if your module is unloaded,
633  * you are responsible here.)  If an error occurs, %NULL will be returned.
634  *
635  * If tracefs is not enabled in the kernel, the value -%ENODEV will be
636  * returned.
637  */
tracefs_create_file(const char * name,umode_t mode,struct dentry * parent,void * data,const struct file_operations * fops)638 struct dentry *tracefs_create_file(const char *name, umode_t mode,
639 				   struct dentry *parent, void *data,
640 				   const struct file_operations *fops)
641 {
642 	struct tracefs_inode *ti;
643 	struct dentry *dentry;
644 	struct inode *inode;
645 
646 	if (security_locked_down(LOCKDOWN_TRACEFS))
647 		return NULL;
648 
649 	if (!(mode & S_IFMT))
650 		mode |= S_IFREG;
651 	BUG_ON(!S_ISREG(mode));
652 	dentry = tracefs_start_creating(name, parent);
653 
654 	if (IS_ERR(dentry))
655 		return NULL;
656 
657 	inode = tracefs_get_inode(dentry->d_sb);
658 	if (unlikely(!inode))
659 		return tracefs_failed_creating(dentry);
660 
661 	ti = get_tracefs(inode);
662 	ti->private = instance_inode(parent, inode);
663 
664 	inode->i_mode = mode;
665 	inode->i_op = &tracefs_file_inode_operations;
666 	inode->i_fop = fops ? fops : &tracefs_file_operations;
667 	inode->i_private = data;
668 	inode->i_uid = d_inode(dentry->d_parent)->i_uid;
669 	inode->i_gid = d_inode(dentry->d_parent)->i_gid;
670 	d_instantiate(dentry, inode);
671 	fsnotify_create(d_inode(dentry->d_parent), dentry);
672 	return tracefs_end_creating(dentry);
673 }
674 
__create_dir(const char * name,struct dentry * parent,const struct inode_operations * ops)675 static struct dentry *__create_dir(const char *name, struct dentry *parent,
676 				   const struct inode_operations *ops)
677 {
678 	struct tracefs_inode *ti;
679 	struct dentry *dentry = tracefs_start_creating(name, parent);
680 	struct inode *inode;
681 
682 	if (IS_ERR(dentry))
683 		return NULL;
684 
685 	inode = tracefs_get_inode(dentry->d_sb);
686 	if (unlikely(!inode))
687 		return tracefs_failed_creating(dentry);
688 
689 	/* Do not set bits for OTH */
690 	inode->i_mode = S_IFDIR | S_IRWXU | S_IRUSR| S_IRGRP | S_IXUSR | S_IXGRP;
691 	inode->i_op = ops;
692 	inode->i_fop = &simple_dir_operations;
693 	inode->i_uid = d_inode(dentry->d_parent)->i_uid;
694 	inode->i_gid = d_inode(dentry->d_parent)->i_gid;
695 
696 	ti = get_tracefs(inode);
697 	ti->private = instance_inode(parent, inode);
698 
699 	/* directory inodes start off with i_nlink == 2 (for "." entry) */
700 	inc_nlink(inode);
701 	d_instantiate(dentry, inode);
702 	inc_nlink(d_inode(dentry->d_parent));
703 	fsnotify_mkdir(d_inode(dentry->d_parent), dentry);
704 	return tracefs_end_creating(dentry);
705 }
706 
707 /**
708  * tracefs_create_dir - create a directory in the tracefs filesystem
709  * @name: a pointer to a string containing the name of the directory to
710  *        create.
711  * @parent: a pointer to the parent dentry for this file.  This should be a
712  *          directory dentry if set.  If this parameter is NULL, then the
713  *          directory will be created in the root of the tracefs filesystem.
714  *
715  * This function creates a directory in tracefs with the given name.
716  *
717  * This function will return a pointer to a dentry if it succeeds.  This
718  * pointer must be passed to the tracefs_remove() function when the file is
719  * to be removed. If an error occurs, %NULL will be returned.
720  *
721  * If tracing is not enabled in the kernel, the value -%ENODEV will be
722  * returned.
723  */
tracefs_create_dir(const char * name,struct dentry * parent)724 struct dentry *tracefs_create_dir(const char *name, struct dentry *parent)
725 {
726 	if (security_locked_down(LOCKDOWN_TRACEFS))
727 		return NULL;
728 
729 	return __create_dir(name, parent, &tracefs_dir_inode_operations);
730 }
731 
732 /**
733  * tracefs_create_instance_dir - create the tracing instances directory
734  * @name: The name of the instances directory to create
735  * @parent: The parent directory that the instances directory will exist
736  * @mkdir: The function to call when a mkdir is performed.
737  * @rmdir: The function to call when a rmdir is performed.
738  *
739  * Only one instances directory is allowed.
740  *
741  * The instances directory is special as it allows for mkdir and rmdir
742  * to be done by userspace. When a mkdir or rmdir is performed, the inode
743  * locks are released and the methods passed in (@mkdir and @rmdir) are
744  * called without locks and with the name of the directory being created
745  * within the instances directory.
746  *
747  * Returns the dentry of the instances directory.
748  */
tracefs_create_instance_dir(const char * name,struct dentry * parent,int (* mkdir)(const char * name),int (* rmdir)(const char * name))749 __init struct dentry *tracefs_create_instance_dir(const char *name,
750 					  struct dentry *parent,
751 					  int (*mkdir)(const char *name),
752 					  int (*rmdir)(const char *name))
753 {
754 	struct dentry *dentry;
755 
756 	/* Only allow one instance of the instances directory. */
757 	if (WARN_ON(tracefs_ops.mkdir || tracefs_ops.rmdir))
758 		return NULL;
759 
760 	dentry = __create_dir(name, parent, &tracefs_instance_dir_inode_operations);
761 	if (!dentry)
762 		return NULL;
763 
764 	tracefs_ops.mkdir = mkdir;
765 	tracefs_ops.rmdir = rmdir;
766 
767 	return dentry;
768 }
769 
remove_one(struct dentry * victim)770 static void remove_one(struct dentry *victim)
771 {
772 	simple_release_fs(&tracefs_mount, &tracefs_mount_count);
773 }
774 
775 /**
776  * tracefs_remove - recursively removes a directory
777  * @dentry: a pointer to a the dentry of the directory to be removed.
778  *
779  * This function recursively removes a directory tree in tracefs that
780  * was previously created with a call to another tracefs function
781  * (like tracefs_create_file() or variants thereof.)
782  */
tracefs_remove(struct dentry * dentry)783 void tracefs_remove(struct dentry *dentry)
784 {
785 	if (IS_ERR_OR_NULL(dentry))
786 		return;
787 
788 	simple_pin_fs(&trace_fs_type, &tracefs_mount, &tracefs_mount_count);
789 	simple_recursive_removal(dentry, remove_one);
790 	simple_release_fs(&tracefs_mount, &tracefs_mount_count);
791 }
792 
793 /**
794  * tracefs_initialized - Tells whether tracefs has been registered
795  */
tracefs_initialized(void)796 bool tracefs_initialized(void)
797 {
798 	return tracefs_registered;
799 }
800 
init_once(void * foo)801 static void init_once(void *foo)
802 {
803 	struct tracefs_inode *ti = (struct tracefs_inode *) foo;
804 
805 	/* inode_init_once() calls memset() on the vfs_inode portion */
806 	inode_init_once(&ti->vfs_inode);
807 
808 	/* Zero out the rest */
809 	memset_after(ti, 0, vfs_inode);
810 }
811 
tracefs_init(void)812 static int __init tracefs_init(void)
813 {
814 	int retval;
815 
816 	tracefs_inode_cachep = kmem_cache_create("tracefs_inode_cache",
817 						 sizeof(struct tracefs_inode),
818 						 0, (SLAB_RECLAIM_ACCOUNT|
819 						     SLAB_MEM_SPREAD|
820 						     SLAB_ACCOUNT),
821 						 init_once);
822 	if (!tracefs_inode_cachep)
823 		return -ENOMEM;
824 
825 	retval = sysfs_create_mount_point(kernel_kobj, "tracing");
826 	if (retval)
827 		return -EINVAL;
828 
829 	retval = register_filesystem(&trace_fs_type);
830 	if (!retval)
831 		tracefs_registered = true;
832 
833 	return retval;
834 }
835 core_initcall(tracefs_init);
836