1/*
  2 *  inode.c - part of tracefs, a pseudo file system for activating tracing
  3 *
  4 * Based on debugfs by: Greg Kroah-Hartman <greg@kroah.com>
  5 *
  6 *  Copyright (C) 2014 Red Hat Inc, author: Steven Rostedt <srostedt@redhat.com>
  7 *
  8 *	This program is free software; you can redistribute it and/or
  9 *	modify it under the terms of the GNU General Public License version
 10 *	2 as published by the Free Software Foundation.
 11 *
 12 * tracefs is the file system that is used by the tracing infrastructure.
 13 *
 14 */
 15
 16#include <linux/module.h>
 17#include <linux/fs.h>
 18#include <linux/mount.h>
 19#include <linux/kobject.h>
 20#include <linux/namei.h>
 21#include <linux/tracefs.h>
 22#include <linux/fsnotify.h>
 23#include <linux/seq_file.h>
 24#include <linux/parser.h>
 25#include <linux/magic.h>
 26#include <linux/slab.h>
 27
 28#define TRACEFS_DEFAULT_MODE	0700
 29
 30static struct vfsmount *tracefs_mount;
 31static int tracefs_mount_count;
 32static bool tracefs_registered;
 33
 34static ssize_t default_read_file(struct file *file, char __user *buf,
 35				 size_t count, loff_t *ppos)
 36{
 37	return 0;
 38}
 39
 40static ssize_t default_write_file(struct file *file, const char __user *buf,
 41				   size_t count, loff_t *ppos)
 42{
 43	return count;
 44}
 45
 46static const struct file_operations tracefs_file_operations = {
 47	.read =		default_read_file,
 48	.write =	default_write_file,
 49	.open =		simple_open,
 50	.llseek =	noop_llseek,
 51};
 52
 53static struct tracefs_dir_ops {
 54	int (*mkdir)(const char *name);
 55	int (*rmdir)(const char *name);
 56} tracefs_ops;
 57
 58static char *get_dname(struct dentry *dentry)
 59{
 60	const char *dname;
 61	char *name;
 62	int len = dentry->d_name.len;
 63
 64	dname = dentry->d_name.name;
 65	name = kmalloc(len + 1, GFP_KERNEL);
 66	if (!name)
 67		return NULL;
 68	memcpy(name, dname, len);
 69	name[len] = 0;
 70	return name;
 71}
 72
 73static int tracefs_syscall_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode)
 74{
 75	char *name;
 76	int ret;
 77
 78	name = get_dname(dentry);
 79	if (!name)
 80		return -ENOMEM;
 81
 82	/*
 83	 * The mkdir call can call the generic functions that create
 84	 * the files within the tracefs system. It is up to the individual
 85	 * mkdir routine to handle races.
 86	 */
 87	inode_unlock(inode);
 88	ret = tracefs_ops.mkdir(name);
 89	inode_lock(inode);
 90
 91	kfree(name);
 92
 93	return ret;
 94}
 95
 96static int tracefs_syscall_rmdir(struct inode *inode, struct dentry *dentry)
 97{
 98	char *name;
 99	int ret;
100
101	name = get_dname(dentry);
102	if (!name)
103		return -ENOMEM;
104
105	/*
106	 * The rmdir call can call the generic functions that create
107	 * the files within the tracefs system. It is up to the individual
108	 * rmdir routine to handle races.
109	 * This time we need to unlock not only the parent (inode) but
110	 * also the directory that is being deleted.
111	 */
112	inode_unlock(inode);
113	inode_unlock(dentry->d_inode);
114
115	ret = tracefs_ops.rmdir(name);
116
117	inode_lock_nested(inode, I_MUTEX_PARENT);
118	inode_lock(dentry->d_inode);
119
120	kfree(name);
121
122	return ret;
123}
124
125static const struct inode_operations tracefs_dir_inode_operations = {
126	.lookup		= simple_lookup,
127	.mkdir		= tracefs_syscall_mkdir,
128	.rmdir		= tracefs_syscall_rmdir,
129};
130
131static struct inode *tracefs_get_inode(struct super_block *sb)
132{
133	struct inode *inode = new_inode(sb);
134	if (inode) {
135		inode->i_ino = get_next_ino();
136		inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
137	}
138	return inode;
139}
140
141struct tracefs_mount_opts {
142	kuid_t uid;
143	kgid_t gid;
144	umode_t mode;
145};
146
147enum {
148	Opt_uid,
149	Opt_gid,
150	Opt_mode,
151	Opt_err
152};
153
154static const match_table_t tokens = {
155	{Opt_uid, "uid=%u"},
156	{Opt_gid, "gid=%u"},
157	{Opt_mode, "mode=%o"},
158	{Opt_err, NULL}
159};
160
161struct tracefs_fs_info {
162	struct tracefs_mount_opts mount_opts;
163};
164
165static int tracefs_parse_options(char *data, struct tracefs_mount_opts *opts)
166{
167	substring_t args[MAX_OPT_ARGS];
168	int option;
169	int token;
170	kuid_t uid;
171	kgid_t gid;
172	char *p;
173
174	opts->mode = TRACEFS_DEFAULT_MODE;
175
176	while ((p = strsep(&data, ",")) != NULL) {
177		if (!*p)
178			continue;
179
180		token = match_token(p, tokens, args);
181		switch (token) {
182		case Opt_uid:
183			if (match_int(&args[0], &option))
184				return -EINVAL;
185			uid = make_kuid(current_user_ns(), option);
186			if (!uid_valid(uid))
187				return -EINVAL;
188			opts->uid = uid;
189			break;
190		case Opt_gid:
191			if (match_int(&args[0], &option))
192				return -EINVAL;
193			gid = make_kgid(current_user_ns(), option);
194			if (!gid_valid(gid))
195				return -EINVAL;
196			opts->gid = gid;
197			break;
198		case Opt_mode:
199			if (match_octal(&args[0], &option))
200				return -EINVAL;
201			opts->mode = option & S_IALLUGO;
202			break;
203		/*
204		 * We might like to report bad mount options here;
205		 * but traditionally tracefs has ignored all mount options
206		 */
207		}
208	}
209
210	return 0;
211}
212
213static int tracefs_apply_options(struct super_block *sb)
214{
215	struct tracefs_fs_info *fsi = sb->s_fs_info;
216	struct inode *inode = sb->s_root->d_inode;
217	struct tracefs_mount_opts *opts = &fsi->mount_opts;
218
219	inode->i_mode &= ~S_IALLUGO;
220	inode->i_mode |= opts->mode;
221
222	inode->i_uid = opts->uid;
223	inode->i_gid = opts->gid;
224
225	return 0;
226}
227
228static int tracefs_remount(struct super_block *sb, int *flags, char *data)
229{
230	int err;
231	struct tracefs_fs_info *fsi = sb->s_fs_info;
232
233	sync_filesystem(sb);
234	err = tracefs_parse_options(data, &fsi->mount_opts);
235	if (err)
236		goto fail;
237
238	tracefs_apply_options(sb);
239
240fail:
241	return err;
242}
243
244static int tracefs_show_options(struct seq_file *m, struct dentry *root)
245{
246	struct tracefs_fs_info *fsi = root->d_sb->s_fs_info;
247	struct tracefs_mount_opts *opts = &fsi->mount_opts;
248
249	if (!uid_eq(opts->uid, GLOBAL_ROOT_UID))
250		seq_printf(m, ",uid=%u",
251			   from_kuid_munged(&init_user_ns, opts->uid));
252	if (!gid_eq(opts->gid, GLOBAL_ROOT_GID))
253		seq_printf(m, ",gid=%u",
254			   from_kgid_munged(&init_user_ns, opts->gid));
255	if (opts->mode != TRACEFS_DEFAULT_MODE)
256		seq_printf(m, ",mode=%o", opts->mode);
257
258	return 0;
259}
260
261static const struct super_operations tracefs_super_operations = {
262	.statfs		= simple_statfs,
263	.remount_fs	= tracefs_remount,
264	.show_options	= tracefs_show_options,
265};
266
267static int trace_fill_super(struct super_block *sb, void *data, int silent)
268{
269	static struct tree_descr trace_files[] = {{""}};
270	struct tracefs_fs_info *fsi;
271	int err;
272
273	save_mount_options(sb, data);
274
275	fsi = kzalloc(sizeof(struct tracefs_fs_info), GFP_KERNEL);
276	sb->s_fs_info = fsi;
277	if (!fsi) {
278		err = -ENOMEM;
279		goto fail;
280	}
281
282	err = tracefs_parse_options(data, &fsi->mount_opts);
283	if (err)
284		goto fail;
285
286	err  =  simple_fill_super(sb, TRACEFS_MAGIC, trace_files);
287	if (err)
288		goto fail;
289
290	sb->s_op = &tracefs_super_operations;
291
292	tracefs_apply_options(sb);
293
294	return 0;
295
296fail:
297	kfree(fsi);
298	sb->s_fs_info = NULL;
299	return err;
300}
301
302static struct dentry *trace_mount(struct file_system_type *fs_type,
303			int flags, const char *dev_name,
304			void *data)
305{
306	return mount_single(fs_type, flags, data, trace_fill_super);
307}
308
309static struct file_system_type trace_fs_type = {
310	.owner =	THIS_MODULE,
311	.name =		"tracefs",
312	.mount =	trace_mount,
313	.kill_sb =	kill_litter_super,
314};
315MODULE_ALIAS_FS("tracefs");
316
317static struct dentry *start_creating(const char *name, struct dentry *parent)
318{
319	struct dentry *dentry;
320	int error;
321
322	pr_debug("tracefs: creating file '%s'\n",name);
323
324	error = simple_pin_fs(&trace_fs_type, &tracefs_mount,
325			      &tracefs_mount_count);
326	if (error)
327		return ERR_PTR(error);
328
329	/* If the parent is not specified, we create it in the root.
330	 * We need the root dentry to do this, which is in the super
331	 * block. A pointer to that is in the struct vfsmount that we
332	 * have around.
333	 */
334	if (!parent)
335		parent = tracefs_mount->mnt_root;
336
337	inode_lock(parent->d_inode);
338	dentry = lookup_one_len(name, parent, strlen(name));
339	if (!IS_ERR(dentry) && dentry->d_inode) {
340		dput(dentry);
341		dentry = ERR_PTR(-EEXIST);
342	}
343
344	if (IS_ERR(dentry)) {
345		inode_unlock(parent->d_inode);
346		simple_release_fs(&tracefs_mount, &tracefs_mount_count);
347	}
348
349	return dentry;
350}
351
352static struct dentry *failed_creating(struct dentry *dentry)
353{
354	inode_unlock(dentry->d_parent->d_inode);
355	dput(dentry);
356	simple_release_fs(&tracefs_mount, &tracefs_mount_count);
357	return NULL;
358}
359
360static struct dentry *end_creating(struct dentry *dentry)
361{
362	inode_unlock(dentry->d_parent->d_inode);
363	return dentry;
364}
365
366/**
367 * tracefs_create_file - create a file in the tracefs filesystem
368 * @name: a pointer to a string containing the name of the file to create.
369 * @mode: the permission that the file should have.
370 * @parent: a pointer to the parent dentry for this file.  This should be a
371 *          directory dentry if set.  If this parameter is NULL, then the
372 *          file will be created in the root of the tracefs filesystem.
373 * @data: a pointer to something that the caller will want to get to later
374 *        on.  The inode.i_private pointer will point to this value on
375 *        the open() call.
376 * @fops: a pointer to a struct file_operations that should be used for
377 *        this file.
378 *
379 * This is the basic "create a file" function for tracefs.  It allows for a
380 * wide range of flexibility in creating a file, or a directory (if you want
381 * to create a directory, the tracefs_create_dir() function is
382 * recommended to be used instead.)
383 *
384 * This function will return a pointer to a dentry if it succeeds.  This
385 * pointer must be passed to the tracefs_remove() function when the file is
386 * to be removed (no automatic cleanup happens if your module is unloaded,
387 * you are responsible here.)  If an error occurs, %NULL will be returned.
388 *
389 * If tracefs is not enabled in the kernel, the value -%ENODEV will be
390 * returned.
391 */
392struct dentry *tracefs_create_file(const char *name, umode_t mode,
393				   struct dentry *parent, void *data,
394				   const struct file_operations *fops)
395{
396	struct dentry *dentry;
397	struct inode *inode;
398
399	if (!(mode & S_IFMT))
400		mode |= S_IFREG;
401	BUG_ON(!S_ISREG(mode));
402	dentry = start_creating(name, parent);
403
404	if (IS_ERR(dentry))
405		return NULL;
406
407	inode = tracefs_get_inode(dentry->d_sb);
408	if (unlikely(!inode))
409		return failed_creating(dentry);
410
411	inode->i_mode = mode;
412	inode->i_fop = fops ? fops : &tracefs_file_operations;
413	inode->i_private = data;
414	d_instantiate(dentry, inode);
415	fsnotify_create(dentry->d_parent->d_inode, dentry);
416	return end_creating(dentry);
417}
418
419static struct dentry *__create_dir(const char *name, struct dentry *parent,
420				   const struct inode_operations *ops)
421{
422	struct dentry *dentry = start_creating(name, parent);
423	struct inode *inode;
424
425	if (IS_ERR(dentry))
426		return NULL;
427
428	inode = tracefs_get_inode(dentry->d_sb);
429	if (unlikely(!inode))
430		return failed_creating(dentry);
431
432	inode->i_mode = S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO;
433	inode->i_op = ops;
434	inode->i_fop = &simple_dir_operations;
435
436	/* directory inodes start off with i_nlink == 2 (for "." entry) */
437	inc_nlink(inode);
438	d_instantiate(dentry, inode);
439	inc_nlink(dentry->d_parent->d_inode);
440	fsnotify_mkdir(dentry->d_parent->d_inode, dentry);
441	return end_creating(dentry);
442}
443
444/**
445 * tracefs_create_dir - create a directory in the tracefs filesystem
446 * @name: a pointer to a string containing the name of the directory to
447 *        create.
448 * @parent: a pointer to the parent dentry for this file.  This should be a
449 *          directory dentry if set.  If this parameter is NULL, then the
450 *          directory will be created in the root of the tracefs filesystem.
451 *
452 * This function creates a directory in tracefs with the given name.
453 *
454 * This function will return a pointer to a dentry if it succeeds.  This
455 * pointer must be passed to the tracefs_remove() function when the file is
456 * to be removed. If an error occurs, %NULL will be returned.
457 *
458 * If tracing is not enabled in the kernel, the value -%ENODEV will be
459 * returned.
460 */
461struct dentry *tracefs_create_dir(const char *name, struct dentry *parent)
462{
463	return __create_dir(name, parent, &simple_dir_inode_operations);
464}
465
466/**
467 * tracefs_create_instance_dir - create the tracing instances directory
468 * @name: The name of the instances directory to create
469 * @parent: The parent directory that the instances directory will exist
470 * @mkdir: The function to call when a mkdir is performed.
471 * @rmdir: The function to call when a rmdir is performed.
472 *
473 * Only one instances directory is allowed.
474 *
475 * The instances directory is special as it allows for mkdir and rmdir to
476 * to be done by userspace. When a mkdir or rmdir is performed, the inode
477 * locks are released and the methhods passed in (@mkdir and @rmdir) are
478 * called without locks and with the name of the directory being created
479 * within the instances directory.
480 *
481 * Returns the dentry of the instances directory.
482 */
483struct dentry *tracefs_create_instance_dir(const char *name, struct dentry *parent,
484					  int (*mkdir)(const char *name),
485					  int (*rmdir)(const char *name))
486{
487	struct dentry *dentry;
488
489	/* Only allow one instance of the instances directory. */
490	if (WARN_ON(tracefs_ops.mkdir || tracefs_ops.rmdir))
491		return NULL;
492
493	dentry = __create_dir(name, parent, &tracefs_dir_inode_operations);
494	if (!dentry)
495		return NULL;
496
497	tracefs_ops.mkdir = mkdir;
498	tracefs_ops.rmdir = rmdir;
499
500	return dentry;
501}
502
503static int __tracefs_remove(struct dentry *dentry, struct dentry *parent)
504{
505	int ret = 0;
506
507	if (simple_positive(dentry)) {
508		if (dentry->d_inode) {
509			dget(dentry);
510			switch (dentry->d_inode->i_mode & S_IFMT) {
511			case S_IFDIR:
512				ret = simple_rmdir(parent->d_inode, dentry);
513				break;
514			default:
515				simple_unlink(parent->d_inode, dentry);
516				break;
517			}
518			if (!ret)
519				d_delete(dentry);
520			dput(dentry);
521		}
522	}
523	return ret;
524}
525
526/**
527 * tracefs_remove - removes a file or directory from the tracefs filesystem
528 * @dentry: a pointer to a the dentry of the file or directory to be
529 *          removed.
530 *
531 * This function removes a file or directory in tracefs that was previously
532 * created with a call to another tracefs function (like
533 * tracefs_create_file() or variants thereof.)
534 */
535void tracefs_remove(struct dentry *dentry)
536{
537	struct dentry *parent;
538	int ret;
539
540	if (IS_ERR_OR_NULL(dentry))
541		return;
542
543	parent = dentry->d_parent;
544	inode_lock(parent->d_inode);
545	ret = __tracefs_remove(dentry, parent);
546	inode_unlock(parent->d_inode);
547	if (!ret)
548		simple_release_fs(&tracefs_mount, &tracefs_mount_count);
549}
550
551/**
552 * tracefs_remove_recursive - recursively removes a directory
553 * @dentry: a pointer to a the dentry of the directory to be removed.
554 *
555 * This function recursively removes a directory tree in tracefs that
556 * was previously created with a call to another tracefs function
557 * (like tracefs_create_file() or variants thereof.)
558 */
559void tracefs_remove_recursive(struct dentry *dentry)
560{
561	struct dentry *child, *parent;
562
563	if (IS_ERR_OR_NULL(dentry))
564		return;
565
566	parent = dentry;
567 down:
568	inode_lock(parent->d_inode);
569 loop:
570	/*
571	 * The parent->d_subdirs is protected by the d_lock. Outside that
572	 * lock, the child can be unlinked and set to be freed which can
573	 * use the d_u.d_child as the rcu head and corrupt this list.
574	 */
575	spin_lock(&parent->d_lock);
576	list_for_each_entry(child, &parent->d_subdirs, d_child) {
577		if (!simple_positive(child))
578			continue;
579
580		/* perhaps simple_empty(child) makes more sense */
581		if (!list_empty(&child->d_subdirs)) {
582			spin_unlock(&parent->d_lock);
583			inode_unlock(parent->d_inode);
584			parent = child;
585			goto down;
586		}
587
588		spin_unlock(&parent->d_lock);
589
590		if (!__tracefs_remove(child, parent))
591			simple_release_fs(&tracefs_mount, &tracefs_mount_count);
592
593		/*
594		 * The parent->d_lock protects agaist child from unlinking
595		 * from d_subdirs. When releasing the parent->d_lock we can
596		 * no longer trust that the next pointer is valid.
597		 * Restart the loop. We'll skip this one with the
598		 * simple_positive() check.
599		 */
600		goto loop;
601	}
602	spin_unlock(&parent->d_lock);
603
604	inode_unlock(parent->d_inode);
605	child = parent;
606	parent = parent->d_parent;
607	inode_lock(parent->d_inode);
608
609	if (child != dentry)
610		/* go up */
611		goto loop;
612
613	if (!__tracefs_remove(child, parent))
614		simple_release_fs(&tracefs_mount, &tracefs_mount_count);
615	inode_unlock(parent->d_inode);
616}
617
618/**
619 * tracefs_initialized - Tells whether tracefs has been registered
620 */
621bool tracefs_initialized(void)
622{
623	return tracefs_registered;
624}
625
626static int __init tracefs_init(void)
627{
628	int retval;
629
630	retval = sysfs_create_mount_point(kernel_kobj, "tracing");
631	if (retval)
632		return -EINVAL;
633
634	retval = register_filesystem(&trace_fs_type);
635	if (!retval)
636		tracefs_registered = true;
637
638	return retval;
639}
640core_initcall(tracefs_init);