inode.c 24.3 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0
Linus Torvalds's avatar
Linus Torvalds committed
2
/*
Harry Wei's avatar
Harry Wei committed
3
 *  inode.c - part of debugfs, a tiny little debug file system
Linus Torvalds's avatar
Linus Torvalds committed
4 5 6 7 8
 *
 *  Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com>
 *  Copyright (C) 2004 IBM Inc.
 *
 *  debugfs is for people to use instead of /proc or /sys.
9
 *  See ./Documentation/core-api/kernel-api.rst for more details.
Linus Torvalds's avatar
Linus Torvalds committed
10 11 12 13 14 15 16
 */

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/mount.h>
#include <linux/pagemap.h>
#include <linux/init.h>
17
#include <linux/kobject.h>
Linus Torvalds's avatar
Linus Torvalds committed
18 19
#include <linux/namei.h>
#include <linux/debugfs.h>
20
#include <linux/fsnotify.h>
21
#include <linux/string.h>
22 23
#include <linux/seq_file.h>
#include <linux/parser.h>
Mimi Zohar's avatar
Mimi Zohar committed
24
#include <linux/magic.h>
25
#include <linux/slab.h>
26 27

#include "internal.h"
Linus Torvalds's avatar
Linus Torvalds committed
28

29
#define DEBUGFS_DEFAULT_MODE	0700
30

Linus Torvalds's avatar
Linus Torvalds committed
31 32
static struct vfsmount *debugfs_mount;
static int debugfs_mount_count;
33
static bool debugfs_registered;
Linus Torvalds's avatar
Linus Torvalds committed
34

35
static struct inode *debugfs_get_inode(struct super_block *sb)
Linus Torvalds's avatar
Linus Torvalds committed
36 37 38
{
	struct inode *inode = new_inode(sb);
	if (inode) {
39
		inode->i_ino = get_next_ino();
40
		inode->i_atime = inode->i_mtime =
41
			inode->i_ctime = current_time(inode);
Linus Torvalds's avatar
Linus Torvalds committed
42
	}
43
	return inode;
Linus Torvalds's avatar
Linus Torvalds committed
44 45
}

46
struct debugfs_mount_opts {
47 48
	kuid_t uid;
	kgid_t gid;
49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
	umode_t mode;
};

enum {
	Opt_uid,
	Opt_gid,
	Opt_mode,
	Opt_err
};

static const match_table_t tokens = {
	{Opt_uid, "uid=%u"},
	{Opt_gid, "gid=%u"},
	{Opt_mode, "mode=%o"},
	{Opt_err, NULL}
};

struct debugfs_fs_info {
	struct debugfs_mount_opts mount_opts;
};

static int debugfs_parse_options(char *data, struct debugfs_mount_opts *opts)
{
	substring_t args[MAX_OPT_ARGS];
	int option;
	int token;
75 76
	kuid_t uid;
	kgid_t gid;
77 78 79 80 81 82 83 84 85 86 87 88 89
	char *p;

	opts->mode = DEBUGFS_DEFAULT_MODE;

	while ((p = strsep(&data, ",")) != NULL) {
		if (!*p)
			continue;

		token = match_token(p, tokens, args);
		switch (token) {
		case Opt_uid:
			if (match_int(&args[0], &option))
				return -EINVAL;
90 91 92 93
			uid = make_kuid(current_user_ns(), option);
			if (!uid_valid(uid))
				return -EINVAL;
			opts->uid = uid;
94 95
			break;
		case Opt_gid:
96
			if (match_int(&args[0], &option))
97
				return -EINVAL;
98 99 100 101
			gid = make_kgid(current_user_ns(), option);
			if (!gid_valid(gid))
				return -EINVAL;
			opts->gid = gid;
102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120
			break;
		case Opt_mode:
			if (match_octal(&args[0], &option))
				return -EINVAL;
			opts->mode = option & S_IALLUGO;
			break;
		/*
		 * We might like to report bad mount options here;
		 * but traditionally debugfs has ignored all mount options
		 */
		}
	}

	return 0;
}

static int debugfs_apply_options(struct super_block *sb)
{
	struct debugfs_fs_info *fsi = sb->s_fs_info;
121
	struct inode *inode = d_inode(sb->s_root);
122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137
	struct debugfs_mount_opts *opts = &fsi->mount_opts;

	inode->i_mode &= ~S_IALLUGO;
	inode->i_mode |= opts->mode;

	inode->i_uid = opts->uid;
	inode->i_gid = opts->gid;

	return 0;
}

static int debugfs_remount(struct super_block *sb, int *flags, char *data)
{
	int err;
	struct debugfs_fs_info *fsi = sb->s_fs_info;

138
	sync_filesystem(sb);
139 140 141 142 143 144 145 146 147 148 149 150 151 152 153
	err = debugfs_parse_options(data, &fsi->mount_opts);
	if (err)
		goto fail;

	debugfs_apply_options(sb);

fail:
	return err;
}

static int debugfs_show_options(struct seq_file *m, struct dentry *root)
{
	struct debugfs_fs_info *fsi = root->d_sb->s_fs_info;
	struct debugfs_mount_opts *opts = &fsi->mount_opts;

154 155 156 157 158 159
	if (!uid_eq(opts->uid, GLOBAL_ROOT_UID))
		seq_printf(m, ",uid=%u",
			   from_kuid_munged(&init_user_ns, opts->uid));
	if (!gid_eq(opts->gid, GLOBAL_ROOT_GID))
		seq_printf(m, ",gid=%u",
			   from_kgid_munged(&init_user_ns, opts->gid));
160 161 162 163 164 165
	if (opts->mode != DEBUGFS_DEFAULT_MODE)
		seq_printf(m, ",mode=%o", opts->mode);

	return 0;
}

166 167 168 169 170
static void debugfs_evict_inode(struct inode *inode)
{
	truncate_inode_pages_final(&inode->i_data);
	clear_inode(inode);
	if (S_ISLNK(inode->i_mode))
171
		kfree(inode->i_link);
172 173
}

174 175 176 177
static const struct super_operations debugfs_super_operations = {
	.statfs		= simple_statfs,
	.remount_fs	= debugfs_remount,
	.show_options	= debugfs_show_options,
178
	.evict_inode	= debugfs_evict_inode,
179 180
};

181 182
static void debugfs_release_dentry(struct dentry *dentry)
{
183 184 185 186
	void *fsd = dentry->d_fsdata;

	if (!((unsigned long)fsd & DEBUGFS_FSDATA_IS_REAL_FOPS_BIT))
		kfree(dentry->d_fsdata);
187 188
}

189 190
static struct vfsmount *debugfs_automount(struct path *path)
{
191 192 193
	debugfs_automount_t f;
	f = (debugfs_automount_t)path->dentry->d_fsdata;
	return f(path->dentry, d_inode(path->dentry)->i_private);
194 195 196 197
}

static const struct dentry_operations debugfs_dops = {
	.d_delete = always_delete_dentry,
198
	.d_release = debugfs_release_dentry,
199 200 201
	.d_automount = debugfs_automount,
};

Linus Torvalds's avatar
Linus Torvalds committed
202 203
static int debug_fill_super(struct super_block *sb, void *data, int silent)
{
204
	static const struct tree_descr debug_files[] = {{""}};
205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223
	struct debugfs_fs_info *fsi;
	int err;

	fsi = kzalloc(sizeof(struct debugfs_fs_info), GFP_KERNEL);
	sb->s_fs_info = fsi;
	if (!fsi) {
		err = -ENOMEM;
		goto fail;
	}

	err = debugfs_parse_options(data, &fsi->mount_opts);
	if (err)
		goto fail;

	err  =  simple_fill_super(sb, DEBUGFS_MAGIC, debug_files);
	if (err)
		goto fail;

	sb->s_op = &debugfs_super_operations;
224
	sb->s_d_op = &debugfs_dops;
225 226 227 228

	debugfs_apply_options(sb);

	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
229

230 231 232 233
fail:
	kfree(fsi);
	sb->s_fs_info = NULL;
	return err;
Linus Torvalds's avatar
Linus Torvalds committed
234 235
}

Al Viro's avatar
Al Viro committed
236
static struct dentry *debug_mount(struct file_system_type *fs_type,
237
			int flags, const char *dev_name,
Al Viro's avatar
Al Viro committed
238
			void *data)
Linus Torvalds's avatar
Linus Torvalds committed
239
{
Al Viro's avatar
Al Viro committed
240
	return mount_single(fs_type, flags, data, debug_fill_super);
Linus Torvalds's avatar
Linus Torvalds committed
241 242 243 244 245
}

static struct file_system_type debug_fs_type = {
	.owner =	THIS_MODULE,
	.name =		"debugfs",
Al Viro's avatar
Al Viro committed
246
	.mount =	debug_mount,
Linus Torvalds's avatar
Linus Torvalds committed
247 248
	.kill_sb =	kill_litter_super,
};
249
MODULE_ALIAS_FS("debugfs");
Linus Torvalds's avatar
Linus Torvalds committed
250

251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272
/**
 * debugfs_lookup() - look up an existing debugfs file
 * @name: a pointer to a string containing the name of the file to look up.
 * @parent: a pointer to the parent dentry of the file.
 *
 * This function will return a pointer to a dentry if it succeeds.  If the file
 * doesn't exist or an error occurs, %NULL will be returned.  The returned
 * dentry must be passed to dput() when it is no longer needed.
 *
 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
 * returned.
 */
struct dentry *debugfs_lookup(const char *name, struct dentry *parent)
{
	struct dentry *dentry;

	if (IS_ERR(parent))
		return NULL;

	if (!parent)
		parent = debugfs_mount->mnt_root;

273
	dentry = lookup_one_len_unlocked(name, parent, strlen(name));
274 275 276 277 278 279 280 281 282 283
	if (IS_ERR(dentry))
		return NULL;
	if (!d_really_is_positive(dentry)) {
		dput(dentry);
		return NULL;
	}
	return dentry;
}
EXPORT_SYMBOL_GPL(debugfs_lookup);

284
static struct dentry *start_creating(const char *name, struct dentry *parent)
Linus Torvalds's avatar
Linus Torvalds committed
285
{
286
	struct dentry *dentry;
287 288 289 290
	int error;

	pr_debug("debugfs: creating file '%s'\n",name);

291 292 293
	if (IS_ERR(parent))
		return parent;

294 295 296
	error = simple_pin_fs(&debug_fs_type, &debugfs_mount,
			      &debugfs_mount_count);
	if (error)
297
		return ERR_PTR(error);
Linus Torvalds's avatar
Linus Torvalds committed
298 299

	/* If the parent is not specified, we create it in the root.
300
	 * We need the root dentry to do this, which is in the super
Linus Torvalds's avatar
Linus Torvalds committed
301 302 303
	 * block. A pointer to that is in the struct vfsmount that we
	 * have around.
	 */
304
	if (!parent)
305
		parent = debugfs_mount->mnt_root;
Linus Torvalds's avatar
Linus Torvalds committed
306

Al Viro's avatar
Al Viro committed
307
	inode_lock(d_inode(parent));
308
	dentry = lookup_one_len(name, parent, strlen(name));
309
	if (!IS_ERR(dentry) && d_really_is_positive(dentry)) {
310
		dput(dentry);
311 312
		dentry = ERR_PTR(-EEXIST);
	}
313 314

	if (IS_ERR(dentry)) {
Al Viro's avatar
Al Viro committed
315
		inode_unlock(d_inode(parent));
316 317 318
		simple_release_fs(&debugfs_mount, &debugfs_mount_count);
	}

319 320 321
	return dentry;
}

322
static struct dentry *failed_creating(struct dentry *dentry)
323
{
Al Viro's avatar
Al Viro committed
324
	inode_unlock(d_inode(dentry->d_parent));
325
	dput(dentry);
326 327 328
	simple_release_fs(&debugfs_mount, &debugfs_mount_count);
	return NULL;
}
Linus Torvalds's avatar
Linus Torvalds committed
329

330 331
static struct dentry *end_creating(struct dentry *dentry)
{
Al Viro's avatar
Al Viro committed
332
	inode_unlock(d_inode(dentry->d_parent));
333 334 335
	return dentry;
}

336 337 338 339 340 341 342 343 344 345 346 347 348
static struct dentry *__debugfs_create_file(const char *name, umode_t mode,
				struct dentry *parent, void *data,
				const struct file_operations *proxy_fops,
				const struct file_operations *real_fops)
{
	struct dentry *dentry;
	struct inode *inode;

	if (!(mode & S_IFMT))
		mode |= S_IFREG;
	BUG_ON(!S_ISREG(mode));
	dentry = start_creating(name, parent);

349
	if (IS_ERR(dentry))
350 351 352
		return NULL;

	inode = debugfs_get_inode(dentry->d_sb);
353
	if (unlikely(!inode))
354 355 356 357 358 359
		return failed_creating(dentry);

	inode->i_mode = mode;
	inode->i_private = data;

	inode->i_fop = proxy_fops;
360 361
	dentry->d_fsdata = (void *)((unsigned long)real_fops |
				DEBUGFS_FSDATA_IS_REAL_FOPS_BIT);
362 363 364 365 366 367

	d_instantiate(dentry, inode);
	fsnotify_create(d_inode(dentry->d_parent), dentry);
	return end_creating(dentry);
}

Linus Torvalds's avatar
Linus Torvalds committed
368 369 370
/**
 * debugfs_create_file - create a file in the debugfs filesystem
 * @name: a pointer to a string containing the name of the file to create.
371
 * @mode: the permission that the file should have.
Linus Torvalds's avatar
Linus Torvalds committed
372
 * @parent: a pointer to the parent dentry for this file.  This should be a
373
 *          directory dentry if set.  If this parameter is NULL, then the
Linus Torvalds's avatar
Linus Torvalds committed
374 375
 *          file will be created in the root of the debugfs filesystem.
 * @data: a pointer to something that the caller will want to get to later
376
 *        on.  The inode.i_private pointer will point to this value on
Linus Torvalds's avatar
Linus Torvalds committed
377 378 379 380 381
 *        the open() call.
 * @fops: a pointer to a struct file_operations that should be used for
 *        this file.
 *
 * This is the basic "create a file" function for debugfs.  It allows for a
382 383
 * wide range of flexibility in creating a file, or a directory (if you want
 * to create a directory, the debugfs_create_dir() function is
Linus Torvalds's avatar
Linus Torvalds committed
384 385 386 387 388
 * recommended to be used instead.)
 *
 * This function will return a pointer to a dentry if it succeeds.  This
 * pointer must be passed to the debugfs_remove() function when the file is
 * to be removed (no automatic cleanup happens if your module is unloaded,
389
 * you are responsible here.)  If an error occurs, %NULL will be returned.
Linus Torvalds's avatar
Linus Torvalds committed
390
 *
391
 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
392
 * returned.
Linus Torvalds's avatar
Linus Torvalds committed
393
 */
Al Viro's avatar
Al Viro committed
394
struct dentry *debugfs_create_file(const char *name, umode_t mode,
Linus Torvalds's avatar
Linus Torvalds committed
395
				   struct dentry *parent, void *data,
396
				   const struct file_operations *fops)
Linus Torvalds's avatar
Linus Torvalds committed
397
{
Al Viro's avatar
Al Viro committed
398

399 400 401 402 403 404
	return __debugfs_create_file(name, mode, parent, data,
				fops ? &debugfs_full_proxy_file_operations :
					&debugfs_noop_file_operations,
				fops);
}
EXPORT_SYMBOL_GPL(debugfs_create_file);
405

406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432
/**
 * debugfs_create_file_unsafe - create a file in the debugfs filesystem
 * @name: a pointer to a string containing the name of the file to create.
 * @mode: the permission that the file should have.
 * @parent: a pointer to the parent dentry for this file.  This should be a
 *          directory dentry if set.  If this parameter is NULL, then the
 *          file will be created in the root of the debugfs filesystem.
 * @data: a pointer to something that the caller will want to get to later
 *        on.  The inode.i_private pointer will point to this value on
 *        the open() call.
 * @fops: a pointer to a struct file_operations that should be used for
 *        this file.
 *
 * debugfs_create_file_unsafe() is completely analogous to
 * debugfs_create_file(), the only difference being that the fops
 * handed it will not get protected against file removals by the
 * debugfs core.
 *
 * It is your responsibility to protect your struct file_operation
 * methods against file removals by means of debugfs_use_file_start()
 * and debugfs_use_file_finish(). ->open() is still protected by
 * debugfs though.
 *
 * Any struct file_operations defined by means of
 * DEFINE_DEBUGFS_ATTRIBUTE() is protected against file removals and
 * thus, may be used here.
 */
433 434 435 436
struct dentry *debugfs_create_file_unsafe(const char *name, umode_t mode,
				   struct dentry *parent, void *data,
				   const struct file_operations *fops)
{
437

438 439 440 441
	return __debugfs_create_file(name, mode, parent, data,
				fops ? &debugfs_open_proxy_file_operations :
					&debugfs_noop_file_operations,
				fops);
Linus Torvalds's avatar
Linus Torvalds committed
442
}
443
EXPORT_SYMBOL_GPL(debugfs_create_file_unsafe);
Linus Torvalds's avatar
Linus Torvalds committed
444

445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479
/**
 * debugfs_create_file_size - create a file in the debugfs filesystem
 * @name: a pointer to a string containing the name of the file to create.
 * @mode: the permission that the file should have.
 * @parent: a pointer to the parent dentry for this file.  This should be a
 *          directory dentry if set.  If this parameter is NULL, then the
 *          file will be created in the root of the debugfs filesystem.
 * @data: a pointer to something that the caller will want to get to later
 *        on.  The inode.i_private pointer will point to this value on
 *        the open() call.
 * @fops: a pointer to a struct file_operations that should be used for
 *        this file.
 * @file_size: initial file size
 *
 * This is the basic "create a file" function for debugfs.  It allows for a
 * wide range of flexibility in creating a file, or a directory (if you want
 * to create a directory, the debugfs_create_dir() function is
 * recommended to be used instead.)
 *
 * This function will return a pointer to a dentry if it succeeds.  This
 * pointer must be passed to the debugfs_remove() function when the file is
 * to be removed (no automatic cleanup happens if your module is unloaded,
 * you are responsible here.)  If an error occurs, %NULL will be returned.
 *
 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
 * returned.
 */
struct dentry *debugfs_create_file_size(const char *name, umode_t mode,
					struct dentry *parent, void *data,
					const struct file_operations *fops,
					loff_t file_size)
{
	struct dentry *de = debugfs_create_file(name, mode, parent, data, fops);

	if (de)
480
		d_inode(de)->i_size = file_size;
481 482 483 484
	return de;
}
EXPORT_SYMBOL_GPL(debugfs_create_file_size);

Linus Torvalds's avatar
Linus Torvalds committed
485 486 487 488 489
/**
 * debugfs_create_dir - create a directory in the debugfs filesystem
 * @name: a pointer to a string containing the name of the directory to
 *        create.
 * @parent: a pointer to the parent dentry for this file.  This should be a
490
 *          directory dentry if set.  If this parameter is NULL, then the
Linus Torvalds's avatar
Linus Torvalds committed
491 492 493 494 495 496 497
 *          directory will be created in the root of the debugfs filesystem.
 *
 * This function creates a directory in debugfs with the given name.
 *
 * This function will return a pointer to a dentry if it succeeds.  This
 * pointer must be passed to the debugfs_remove() function when the file is
 * to be removed (no automatic cleanup happens if your module is unloaded,
498
 * you are responsible here.)  If an error occurs, %NULL will be returned.
Linus Torvalds's avatar
Linus Torvalds committed
499
 *
500
 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
501
 * returned.
Linus Torvalds's avatar
Linus Torvalds committed
502 503 504
 */
struct dentry *debugfs_create_dir(const char *name, struct dentry *parent)
{
Al Viro's avatar
Al Viro committed
505
	struct dentry *dentry = start_creating(name, parent);
Al Viro's avatar
Al Viro committed
506
	struct inode *inode;
Al Viro's avatar
Al Viro committed
507 508 509 510

	if (IS_ERR(dentry))
		return NULL;

511
	inode = debugfs_get_inode(dentry->d_sb);
Al Viro's avatar
Al Viro committed
512
	if (unlikely(!inode))
513
		return failed_creating(dentry);
Al Viro's avatar
Al Viro committed
514

515
	inode->i_mode = S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO;
516 517 518 519 520
	inode->i_op = &simple_dir_inode_operations;
	inode->i_fop = &simple_dir_operations;

	/* directory inodes start off with i_nlink == 2 (for "." entry) */
	inc_nlink(inode);
Al Viro's avatar
Al Viro committed
521
	d_instantiate(dentry, inode);
522 523
	inc_nlink(d_inode(dentry->d_parent));
	fsnotify_mkdir(d_inode(dentry->d_parent), dentry);
524
	return end_creating(dentry);
Linus Torvalds's avatar
Linus Torvalds committed
525 526 527
}
EXPORT_SYMBOL_GPL(debugfs_create_dir);

528 529 530 531 532 533 534 535 536 537 538 539 540
/**
 * debugfs_create_automount - create automount point in the debugfs filesystem
 * @name: a pointer to a string containing the name of the file to create.
 * @parent: a pointer to the parent dentry for this file.  This should be a
 *          directory dentry if set.  If this parameter is NULL, then the
 *          file will be created in the root of the debugfs filesystem.
 * @f: function to be called when pathname resolution steps on that one.
 * @data: opaque argument to pass to f().
 *
 * @f should return what ->d_automount() would.
 */
struct dentry *debugfs_create_automount(const char *name,
					struct dentry *parent,
541
					debugfs_automount_t f,
542 543 544 545 546 547 548 549 550 551 552 553
					void *data)
{
	struct dentry *dentry = start_creating(name, parent);
	struct inode *inode;

	if (IS_ERR(dentry))
		return NULL;

	inode = debugfs_get_inode(dentry->d_sb);
	if (unlikely(!inode))
		return failed_creating(dentry);

554
	make_empty_dir_inode(inode);
555 556 557
	inode->i_flags |= S_AUTOMOUNT;
	inode->i_private = data;
	dentry->d_fsdata = (void *)f;
558 559
	/* directory inodes start off with i_nlink == 2 (for "." entry) */
	inc_nlink(inode);
560
	d_instantiate(dentry, inode);
561 562
	inc_nlink(d_inode(dentry->d_parent));
	fsnotify_mkdir(d_inode(dentry->d_parent), dentry);
563 564 565 566
	return end_creating(dentry);
}
EXPORT_SYMBOL(debugfs_create_automount);

567 568 569 570 571
/**
 * debugfs_create_symlink- create a symbolic link in the debugfs filesystem
 * @name: a pointer to a string containing the name of the symbolic link to
 *        create.
 * @parent: a pointer to the parent dentry for this symbolic link.  This
572
 *          should be a directory dentry if set.  If this parameter is NULL,
573 574 575 576 577 578 579 580 581 582 583 584 585 586 587
 *          then the symbolic link will be created in the root of the debugfs
 *          filesystem.
 * @target: a pointer to a string containing the path to the target of the
 *          symbolic link.
 *
 * This function creates a symbolic link with the given name in debugfs that
 * links to the given target path.
 *
 * This function will return a pointer to a dentry if it succeeds.  This
 * pointer must be passed to the debugfs_remove() function when the symbolic
 * link is to be removed (no automatic cleanup happens if your module is
 * unloaded, you are responsible here.)  If an error occurs, %NULL will be
 * returned.
 *
 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
588
 * returned.
589 590 591 592
 */
struct dentry *debugfs_create_symlink(const char *name, struct dentry *parent,
				      const char *target)
{
Al Viro's avatar
Al Viro committed
593
	struct dentry *dentry;
Al Viro's avatar
Al Viro committed
594 595
	struct inode *inode;
	char *link = kstrdup(target, GFP_KERNEL);
596 597 598
	if (!link)
		return NULL;

Al Viro's avatar
Al Viro committed
599 600
	dentry = start_creating(name, parent);
	if (IS_ERR(dentry)) {
601
		kfree(link);
Al Viro's avatar
Al Viro committed
602 603 604
		return NULL;
	}

605
	inode = debugfs_get_inode(dentry->d_sb);
Al Viro's avatar
Al Viro committed
606
	if (unlikely(!inode)) {
Al Viro's avatar
Al Viro committed
607
		kfree(link);
608
		return failed_creating(dentry);
Al Viro's avatar
Al Viro committed
609
	}
610
	inode->i_mode = S_IFLNK | S_IRWXUGO;
611 612
	inode->i_op = &simple_symlink_inode_operations;
	inode->i_link = link;
Al Viro's avatar
Al Viro committed
613
	d_instantiate(dentry, inode);
614
	return end_creating(dentry);
615 616 617
}
EXPORT_SYMBOL_GPL(debugfs_create_symlink);

618 619 620 621 622 623
static void __debugfs_remove_file(struct dentry *dentry, struct dentry *parent)
{
	struct debugfs_fsdata *fsd;

	simple_unlink(d_inode(parent), dentry);
	d_delete(dentry);
624 625 626 627 628 629 630 631 632 633 634

	/*
	 * Paired with the closing smp_mb() implied by a successful
	 * cmpxchg() in debugfs_file_get(): either
	 * debugfs_file_get() must see a dead dentry or we must see a
	 * debugfs_fsdata instance at ->d_fsdata here (or both).
	 */
	smp_mb();
	fsd = READ_ONCE(dentry->d_fsdata);
	if ((unsigned long)fsd & DEBUGFS_FSDATA_IS_REAL_FOPS_BIT)
		return;
635 636 637 638
	if (!refcount_dec_and_test(&fsd->active_users))
		wait_for_completion(&fsd->active_users_drained);
}

639
static int __debugfs_remove(struct dentry *dentry, struct dentry *parent)
640 641 642
{
	int ret = 0;

Al Viro's avatar
Al Viro committed
643
	if (simple_positive(dentry)) {
644
		dget(dentry);
645 646 647 648 649 650 651 652 653 654
		if (!d_is_reg(dentry)) {
			if (d_is_dir(dentry))
				ret = simple_rmdir(d_inode(parent), dentry);
			else
				simple_unlink(d_inode(parent), dentry);
			if (!ret)
				d_delete(dentry);
		} else {
			__debugfs_remove_file(dentry, parent);
		}
655
		dput(dentry);
656
	}
657
	return ret;
658 659
}

Linus Torvalds's avatar
Linus Torvalds committed
660 661 662
/**
 * debugfs_remove - removes a file or directory from the debugfs filesystem
 * @dentry: a pointer to a the dentry of the file or directory to be
663 664
 *          removed.  If this parameter is NULL or an error value, nothing
 *          will be done.
Linus Torvalds's avatar
Linus Torvalds committed
665 666 667
 *
 * This function removes a file or directory in debugfs that was previously
 * created with a call to another debugfs function (like
Komal Shah's avatar
Komal Shah committed
668
 * debugfs_create_file() or variants thereof.)
Linus Torvalds's avatar
Linus Torvalds committed
669 670 671 672 673 674 675 676
 *
 * This function is required to be called in order for the file to be
 * removed, no automatic cleanup of files will happen when a module is
 * removed, you are responsible here.
 */
void debugfs_remove(struct dentry *dentry)
{
	struct dentry *parent;
677 678
	int ret;

679
	if (IS_ERR_OR_NULL(dentry))
Linus Torvalds's avatar
Linus Torvalds committed
680 681 682
		return;

	parent = dentry->d_parent;
Al Viro's avatar
Al Viro committed
683
	inode_lock(d_inode(parent));
684
	ret = __debugfs_remove(dentry, parent);
Al Viro's avatar
Al Viro committed
685
	inode_unlock(d_inode(parent));
686 687
	if (!ret)
		simple_release_fs(&debugfs_mount, &debugfs_mount_count);
688 689 690 691 692
}
EXPORT_SYMBOL_GPL(debugfs_remove);

/**
 * debugfs_remove_recursive - recursively removes a directory
693 694
 * @dentry: a pointer to a the dentry of the directory to be removed.  If this
 *          parameter is NULL or an error value, nothing will be done.
695 696 697 698 699 700 701 702 703 704 705
 *
 * This function recursively removes a directory tree in debugfs that
 * was previously created with a call to another debugfs function
 * (like debugfs_create_file() or variants thereof.)
 *
 * This function is required to be called in order for the file to be
 * removed, no automatic cleanup of files will happen when a module is
 * removed, you are responsible here.
 */
void debugfs_remove_recursive(struct dentry *dentry)
{
706
	struct dentry *child, *parent;
707

708
	if (IS_ERR_OR_NULL(dentry))
709 710 711
		return;

	parent = dentry;
712
 down:
Al Viro's avatar
Al Viro committed
713
	inode_lock(d_inode(parent));
714 715 716 717 718 719 720
 loop:
	/*
	 * The parent->d_subdirs is protected by the d_lock. Outside that
	 * lock, the child can be unlinked and set to be freed which can
	 * use the d_u.d_child as the rcu head and corrupt this list.
	 */
	spin_lock(&parent->d_lock);
721
	list_for_each_entry(child, &parent->d_subdirs, d_child) {
Al Viro's avatar
Al Viro committed
722
		if (!simple_positive(child))
723
			continue;
724

725
		/* perhaps simple_empty(child) makes more sense */
726
		if (!list_empty(&child->d_subdirs)) {
727
			spin_unlock(&parent->d_lock);
Al Viro's avatar
Al Viro committed
728
			inode_unlock(d_inode(parent));
729
			parent = child;
730
			goto down;
Linus Torvalds's avatar
Linus Torvalds committed
731
		}
732 733 734

		spin_unlock(&parent->d_lock);

735 736
		if (!__debugfs_remove(child, parent))
			simple_release_fs(&debugfs_mount, &debugfs_mount_count);
737 738 739 740 741 742

		/*
		 * The parent->d_lock protects agaist child from unlinking
		 * from d_subdirs. When releasing the parent->d_lock we can
		 * no longer trust that the next pointer is valid.
		 * Restart the loop. We'll skip this one with the
Al Viro's avatar
Al Viro committed
743
		 * simple_positive() check.
744 745
		 */
		goto loop;
Linus Torvalds's avatar
Linus Torvalds committed
746
	}
747
	spin_unlock(&parent->d_lock);
748

Al Viro's avatar
Al Viro committed
749
	inode_unlock(d_inode(parent));
750 751
	child = parent;
	parent = parent->d_parent;
Al Viro's avatar
Al Viro committed
752
	inode_lock(d_inode(parent));
753

754 755 756
	if (child != dentry)
		/* go up */
		goto loop;
757 758 759

	if (!__debugfs_remove(child, parent))
		simple_release_fs(&debugfs_mount, &debugfs_mount_count);
Al Viro's avatar
Al Viro committed
760
	inode_unlock(d_inode(parent));
Linus Torvalds's avatar
Linus Torvalds committed
761
}
762
EXPORT_SYMBOL_GPL(debugfs_remove_recursive);
Linus Torvalds's avatar
Linus Torvalds committed
763

764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787
/**
 * debugfs_rename - rename a file/directory in the debugfs filesystem
 * @old_dir: a pointer to the parent dentry for the renamed object. This
 *          should be a directory dentry.
 * @old_dentry: dentry of an object to be renamed.
 * @new_dir: a pointer to the parent dentry where the object should be
 *          moved. This should be a directory dentry.
 * @new_name: a pointer to a string containing the target name.
 *
 * This function renames a file/directory in debugfs.  The target must not
 * exist for rename to succeed.
 *
 * This function will return a pointer to old_dentry (which is updated to
 * reflect renaming) if it succeeds. If an error occurs, %NULL will be
 * returned.
 *
 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
 * returned.
 */
struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry,
		struct dentry *new_dir, const char *new_name)
{
	int error;
	struct dentry *dentry = NULL, *trap;
Al Viro's avatar
Al Viro committed
788
	struct name_snapshot old_name;
789 790 791

	trap = lock_rename(new_dir, old_dir);
	/* Source or destination directories don't exist? */
792
	if (d_really_is_negative(old_dir) || d_really_is_negative(new_dir))
793 794
		goto exit;
	/* Source does not exist, cyclic rename, or mountpoint? */
795
	if (d_really_is_negative(old_dentry) || old_dentry == trap ||
796 797 798 799
	    d_mountpoint(old_dentry))
		goto exit;
	dentry = lookup_one_len(new_name, new_dir, strlen(new_name));
	/* Lookup failed, cyclic rename or target exists? */
800
	if (IS_ERR(dentry) || dentry == trap || d_really_is_positive(dentry))
801 802
		goto exit;

Al Viro's avatar
Al Viro committed
803
	take_dentry_name_snapshot(&old_name, old_dentry);
804

805
	error = simple_rename(d_inode(old_dir), old_dentry, d_inode(new_dir),
806
			      dentry, 0);
807
	if (error) {
Al Viro's avatar
Al Viro committed
808
		release_dentry_name_snapshot(&old_name);
809 810 811
		goto exit;
	}
	d_move(old_dentry, dentry);
Al Viro's avatar
Al Viro committed
812
	fsnotify_move(d_inode(old_dir), d_inode(new_dir), old_name.name,
813
		d_is_dir(old_dentry),
814
		NULL, old_dentry);
Al Viro's avatar
Al Viro committed
815
	release_dentry_name_snapshot(&old_name);
816 817 818 819 820 821 822 823 824 825 826
	unlock_rename(new_dir, old_dir);
	dput(dentry);
	return old_dentry;
exit:
	if (dentry && !IS_ERR(dentry))
		dput(dentry);
	unlock_rename(new_dir, old_dir);
	return NULL;
}
EXPORT_SYMBOL_GPL(debugfs_rename);

827 828 829 830 831 832 833 834 835
/**
 * debugfs_initialized - Tells whether debugfs has been registered
 */
bool debugfs_initialized(void)
{
	return debugfs_registered;
}
EXPORT_SYMBOL_GPL(debugfs_initialized);

Linus Torvalds's avatar
Linus Torvalds committed
836 837 838 839
static int __init debugfs_init(void)
{
	int retval;

840 841 842
	retval = sysfs_create_mount_point(kernel_kobj, "debug");
	if (retval)
		return retval;
Linus Torvalds's avatar
Linus Torvalds committed
843 844 845

	retval = register_filesystem(&debug_fs_type);
	if (retval)
846
		sysfs_remove_mount_point(kernel_kobj, "debug");
847 848 849
	else
		debugfs_registered = true;

Linus Torvalds's avatar
Linus Torvalds committed
850 851 852 853
	return retval;
}
core_initcall(debugfs_init);