inode.c 17.5 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
/*
Harry Wei's avatar
Harry Wei committed
2
 *  inode.c - part of debugfs, a tiny little debug file system
Linus Torvalds's avatar
Linus Torvalds committed
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
 *
 *  Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com>
 *  Copyright (C) 2004 IBM Inc.
 *
 *	This program is free software; you can redistribute it and/or
 *	modify it under the terms of the GNU General Public License version
 *	2 as published by the Free Software Foundation.
 *
 *  debugfs is for people to use instead of /proc or /sys.
 *  See Documentation/DocBook/kernel-api for more details.
 *
 */

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

31
#define DEBUGFS_DEFAULT_MODE	0700
32

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

Al Viro's avatar
Al Viro committed
37
static struct inode *debugfs_get_inode(struct super_block *sb, umode_t mode, dev_t dev,
38 39
				       void *data, const struct file_operations *fops)

Linus Torvalds's avatar
Linus Torvalds committed
40 41 42 43
{
	struct inode *inode = new_inode(sb);

	if (inode) {
44
		inode->i_ino = get_next_ino();
Linus Torvalds's avatar
Linus Torvalds committed
45 46 47 48 49 50 51
		inode->i_mode = mode;
		inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
		switch (mode & S_IFMT) {
		default:
			init_special_inode(inode, mode, dev);
			break;
		case S_IFREG:
52 53
			inode->i_fop = fops ? fops : &debugfs_file_operations;
			inode->i_private = data;
Linus Torvalds's avatar
Linus Torvalds committed
54
			break;
55 56
		case S_IFLNK:
			inode->i_op = &debugfs_link_operations;
57
			inode->i_private = data;
58
			break;
Linus Torvalds's avatar
Linus Torvalds committed
59 60
		case S_IFDIR:
			inode->i_op = &simple_dir_inode_operations;
61
			inode->i_fop = &simple_dir_operations;
Linus Torvalds's avatar
Linus Torvalds committed
62

63 64
			/* directory inodes start off with i_nlink == 2
			 * (for "." entry) */
65
			inc_nlink(inode);
Linus Torvalds's avatar
Linus Torvalds committed
66 67 68 69 70 71 72 73
			break;
		}
	}
	return inode; 
}

/* SMP-safe */
static int debugfs_mknod(struct inode *dir, struct dentry *dentry,
Al Viro's avatar
Al Viro committed
74
			 umode_t mode, dev_t dev, void *data,
75
			 const struct file_operations *fops)
Linus Torvalds's avatar
Linus Torvalds committed
76
{
Jens Axboe's avatar
Jens Axboe committed
77
	struct inode *inode;
Linus Torvalds's avatar
Linus Torvalds committed
78 79 80 81 82
	int error = -EPERM;

	if (dentry->d_inode)
		return -EEXIST;

83
	inode = debugfs_get_inode(dir->i_sb, mode, dev, data, fops);
Linus Torvalds's avatar
Linus Torvalds committed
84 85 86 87 88 89 90 91
	if (inode) {
		d_instantiate(dentry, inode);
		dget(dentry);
		error = 0;
	}
	return error;
}

92
static int debugfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
Linus Torvalds's avatar
Linus Torvalds committed
93 94 95 96
{
	int res;

	mode = (mode & (S_IRWXUGO | S_ISVTX)) | S_IFDIR;
97
	res = debugfs_mknod(dir, dentry, mode, 0, NULL, NULL);
98
	if (!res) {
99
		inc_nlink(dir);
100 101
		fsnotify_mkdir(dir, dentry);
	}
Linus Torvalds's avatar
Linus Torvalds committed
102 103 104
	return res;
}

Al Viro's avatar
Al Viro committed
105
static int debugfs_link(struct inode *dir, struct dentry *dentry, umode_t mode,
106
			void *data)
107 108
{
	mode = (mode & S_IALLUGO) | S_IFLNK;
109
	return debugfs_mknod(dir, dentry, mode, 0, data, NULL);
110 111
}

Al Viro's avatar
Al Viro committed
112
static int debugfs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
113
			  void *data, const struct file_operations *fops)
Linus Torvalds's avatar
Linus Torvalds committed
114
{
115 116
	int res;

Linus Torvalds's avatar
Linus Torvalds committed
117
	mode = (mode & S_IALLUGO) | S_IFREG;
118
	res = debugfs_mknod(dir, dentry, mode, 0, data, fops);
119 120 121
	if (!res)
		fsnotify_create(dir, dentry);
	return res;
Linus Torvalds's avatar
Linus Torvalds committed
122 123 124 125 126 127 128
}

static inline int debugfs_positive(struct dentry *dentry)
{
	return dentry->d_inode && !d_unhashed(dentry);
}

129
struct debugfs_mount_opts {
130 131
	kuid_t uid;
	kgid_t gid;
132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157
	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;
158 159
	kuid_t uid;
	kgid_t gid;
160 161 162 163 164 165 166 167 168 169 170 171 172
	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;
173 174 175 176
			uid = make_kuid(current_user_ns(), option);
			if (!uid_valid(uid))
				return -EINVAL;
			opts->uid = uid;
177 178
			break;
		case Opt_gid:
179
			if (match_int(&args[0], &option))
180
				return -EINVAL;
181 182 183 184
			gid = make_kgid(current_user_ns(), option);
			if (!gid_valid(gid))
				return -EINVAL;
			opts->gid = gid;
185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220
			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;
	struct inode *inode = sb->s_root->d_inode;
	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;

221
	sync_filesystem(sb);
222 223 224 225 226 227 228 229 230 231 232 233 234 235 236
	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;

237 238 239 240 241 242
	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));
243 244 245 246 247 248 249 250 251 252 253 254
	if (opts->mode != DEBUGFS_DEFAULT_MODE)
		seq_printf(m, ",mode=%o", opts->mode);

	return 0;
}

static const struct super_operations debugfs_super_operations = {
	.statfs		= simple_statfs,
	.remount_fs	= debugfs_remount,
	.show_options	= debugfs_show_options,
};

Linus Torvalds's avatar
Linus Torvalds committed
255 256 257
static int debug_fill_super(struct super_block *sb, void *data, int silent)
{
	static struct tree_descr debug_files[] = {{""}};
258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282
	struct debugfs_fs_info *fsi;
	int err;

	save_mount_options(sb, data);

	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;

	debugfs_apply_options(sb);

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

284 285 286 287
fail:
	kfree(fsi);
	sb->s_fs_info = NULL;
	return err;
Linus Torvalds's avatar
Linus Torvalds committed
288 289
}

Al Viro's avatar
Al Viro committed
290
static struct dentry *debug_mount(struct file_system_type *fs_type,
291
			int flags, const char *dev_name,
Al Viro's avatar
Al Viro committed
292
			void *data)
Linus Torvalds's avatar
Linus Torvalds committed
293
{
Al Viro's avatar
Al Viro committed
294
	return mount_single(fs_type, flags, data, debug_fill_super);
Linus Torvalds's avatar
Linus Torvalds committed
295 296 297 298 299
}

static struct file_system_type debug_fs_type = {
	.owner =	THIS_MODULE,
	.name =		"debugfs",
Al Viro's avatar
Al Viro committed
300
	.mount =	debug_mount,
Linus Torvalds's avatar
Linus Torvalds committed
301 302
	.kill_sb =	kill_litter_super,
};
303
MODULE_ALIAS_FS("debugfs");
Linus Torvalds's avatar
Linus Torvalds committed
304

305 306 307
static struct dentry *__create_file(const char *name, umode_t mode,
				    struct dentry *parent, void *data,
				    const struct file_operations *fops)
Linus Torvalds's avatar
Linus Torvalds committed
308
{
309 310 311 312 313 314 315 316 317
	struct dentry *dentry = NULL;
	int error;

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

	error = simple_pin_fs(&debug_fs_type, &debugfs_mount,
			      &debugfs_mount_count);
	if (error)
		goto exit;
Linus Torvalds's avatar
Linus Torvalds committed
318 319 320 321 322 323

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

327
	mutex_lock(&parent->d_inode->i_mutex);
328 329
	dentry = lookup_one_len(name, parent, strlen(name));
	if (!IS_ERR(dentry)) {
330 331
		switch (mode & S_IFMT) {
		case S_IFDIR:
332 333
			error = debugfs_mkdir(parent->d_inode, dentry, mode);
					      
334 335
			break;
		case S_IFLNK:
336
			error = debugfs_link(parent->d_inode, dentry, mode,
337
					     data);
338 339
			break;
		default:
340
			error = debugfs_create(parent->d_inode, dentry, mode,
341
					       data, fops);
342 343
			break;
		}
344
		dput(dentry);
Linus Torvalds's avatar
Linus Torvalds committed
345
	} else
346
		error = PTR_ERR(dentry);
347
	mutex_unlock(&parent->d_inode->i_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
348

349 350 351 352 353 354 355 356
	if (error) {
		dentry = NULL;
		simple_release_fs(&debugfs_mount, &debugfs_mount_count);
	}
exit:
	return dentry;
}

Linus Torvalds's avatar
Linus Torvalds committed
357 358 359
/**
 * debugfs_create_file - create a file in the debugfs filesystem
 * @name: a pointer to a string containing the name of the file to create.
360
 * @mode: the permission that the file should have.
Linus Torvalds's avatar
Linus Torvalds committed
361 362 363 364
 * @parent: a pointer to the parent dentry for this file.  This should be a
 *          directory dentry if set.  If this paramater 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
365
 *        on.  The inode.i_private pointer will point to this value on
Linus Torvalds's avatar
Linus Torvalds committed
366 367 368 369 370
 *        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
371 372
 * 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
373 374 375 376 377
 * 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,
378
 * you are responsible here.)  If an error occurs, %NULL will be returned.
Linus Torvalds's avatar
Linus Torvalds committed
379
 *
380
 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
381
 * returned.
Linus Torvalds's avatar
Linus Torvalds committed
382
 */
Al Viro's avatar
Al Viro committed
383
struct dentry *debugfs_create_file(const char *name, umode_t mode,
Linus Torvalds's avatar
Linus Torvalds committed
384
				   struct dentry *parent, void *data,
385
				   const struct file_operations *fops)
Linus Torvalds's avatar
Linus Torvalds committed
386
{
387 388 389 390 391 392
	switch (mode & S_IFMT) {
	case S_IFREG:
	case 0:
		break;
	default:
		BUG();
Linus Torvalds's avatar
Linus Torvalds committed
393
	}
394 395

	return __create_file(name, mode, parent, data, fops);
Linus Torvalds's avatar
Linus Torvalds committed
396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411
}
EXPORT_SYMBOL_GPL(debugfs_create_file);

/**
 * 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
 *          directory dentry if set.  If this paramater is NULL, then the
 *          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,
412
 * you are responsible here.)  If an error occurs, %NULL will be returned.
Linus Torvalds's avatar
Linus Torvalds committed
413
 *
414
 * If debugfs is not enabled in the kernel, the value -%ENODEV will be
415
 * returned.
Linus Torvalds's avatar
Linus Torvalds committed
416 417 418
 */
struct dentry *debugfs_create_dir(const char *name, struct dentry *parent)
{
419
	return __create_file(name, S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO,
Linus Torvalds's avatar
Linus Torvalds committed
420 421 422 423
				   parent, NULL, NULL);
}
EXPORT_SYMBOL_GPL(debugfs_create_dir);

424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444
/**
 * 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
 *          should be a directory dentry if set.  If this paramater is NULL,
 *          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
445
 * returned.
446 447 448 449 450 451 452 453 454 455 456
 */
struct dentry *debugfs_create_symlink(const char *name, struct dentry *parent,
				      const char *target)
{
	struct dentry *result;
	char *link;

	link = kstrdup(target, GFP_KERNEL);
	if (!link)
		return NULL;

457
	result = __create_file(name, S_IFLNK | S_IRWXUGO, parent, link, NULL);
458 459 460 461 462 463
	if (!result)
		kfree(link);
	return result;
}
EXPORT_SYMBOL_GPL(debugfs_create_symlink);

464
static int __debugfs_remove(struct dentry *dentry, struct dentry *parent)
465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486
{
	int ret = 0;

	if (debugfs_positive(dentry)) {
		if (dentry->d_inode) {
			dget(dentry);
			switch (dentry->d_inode->i_mode & S_IFMT) {
			case S_IFDIR:
				ret = simple_rmdir(parent->d_inode, dentry);
				break;
			case S_IFLNK:
				kfree(dentry->d_inode->i_private);
				/* fall through */
			default:
				simple_unlink(parent->d_inode, dentry);
				break;
			}
			if (!ret)
				d_delete(dentry);
			dput(dentry);
		}
	}
487
	return ret;
488 489
}

Linus Torvalds's avatar
Linus Torvalds committed
490 491 492 493 494 495 496
/**
 * 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
 *          removed.
 *
 * 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
497
 * debugfs_create_file() or variants thereof.)
Linus Torvalds's avatar
Linus Torvalds committed
498 499 500 501 502 503 504 505
 *
 * 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;
506 507
	int ret;

508
	if (IS_ERR_OR_NULL(dentry))
Linus Torvalds's avatar
Linus Torvalds committed
509 510 511 512 513 514
		return;

	parent = dentry->d_parent;
	if (!parent || !parent->d_inode)
		return;

515
	mutex_lock(&parent->d_inode->i_mutex);
516
	ret = __debugfs_remove(dentry, parent);
517
	mutex_unlock(&parent->d_inode->i_mutex);
518 519
	if (!ret)
		simple_release_fs(&debugfs_mount, &debugfs_mount_count);
520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536
}
EXPORT_SYMBOL_GPL(debugfs_remove);

/**
 * debugfs_remove_recursive - recursively removes a directory
 * @dentry: a pointer to a the dentry of the directory to be removed.
 *
 * 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)
{
537
	struct dentry *child, *next, *parent;
538

539
	if (IS_ERR_OR_NULL(dentry))
540 541 542 543 544 545 546
		return;

	parent = dentry->d_parent;
	if (!parent || !parent->d_inode)
		return;

	parent = dentry;
547
 down:
548
	mutex_lock(&parent->d_inode->i_mutex);
549 550 551
	list_for_each_entry_safe(child, next, &parent->d_subdirs, d_u.d_child) {
		if (!debugfs_positive(child))
			continue;
552

553
		/* perhaps simple_empty(child) makes more sense */
554 555 556
		if (!list_empty(&child->d_subdirs)) {
			mutex_unlock(&parent->d_inode->i_mutex);
			parent = child;
557
			goto down;
Linus Torvalds's avatar
Linus Torvalds committed
558
		}
559 560 561
 up:
		if (!__debugfs_remove(child, parent))
			simple_release_fs(&debugfs_mount, &debugfs_mount_count);
Linus Torvalds's avatar
Linus Torvalds committed
562
	}
563

564 565 566
	mutex_unlock(&parent->d_inode->i_mutex);
	child = parent;
	parent = parent->d_parent;
567
	mutex_lock(&parent->d_inode->i_mutex);
568 569

	if (child != dentry) {
570
		next = list_next_entry(child, d_u.d_child);
571 572 573 574 575
		goto up;
	}

	if (!__debugfs_remove(child, parent))
		simple_release_fs(&debugfs_mount, &debugfs_mount_count);
576
	mutex_unlock(&parent->d_inode->i_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
577
}
578
EXPORT_SYMBOL_GPL(debugfs_remove_recursive);
Linus Torvalds's avatar
Linus Torvalds committed
579

580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628
/**
 * 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;
	const char *old_name;

	trap = lock_rename(new_dir, old_dir);
	/* Source or destination directories don't exist? */
	if (!old_dir->d_inode || !new_dir->d_inode)
		goto exit;
	/* Source does not exist, cyclic rename, or mountpoint? */
	if (!old_dentry->d_inode || old_dentry == trap ||
	    d_mountpoint(old_dentry))
		goto exit;
	dentry = lookup_one_len(new_name, new_dir, strlen(new_name));
	/* Lookup failed, cyclic rename or target exists? */
	if (IS_ERR(dentry) || dentry == trap || dentry->d_inode)
		goto exit;

	old_name = fsnotify_oldname_init(old_dentry->d_name.name);

	error = simple_rename(old_dir->d_inode, old_dentry, new_dir->d_inode,
		dentry);
	if (error) {
		fsnotify_oldname_free(old_name);
		goto exit;
	}
	d_move(old_dentry, dentry);
	fsnotify_move(old_dir->d_inode, new_dir->d_inode, old_name,
629
		S_ISDIR(old_dentry->d_inode->i_mode),
630
		NULL, old_dentry);
631 632 633 634 635 636 637 638 639 640 641 642
	fsnotify_oldname_free(old_name);
	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);

643 644 645 646 647 648 649 650 651 652
/**
 * debugfs_initialized - Tells whether debugfs has been registered
 */
bool debugfs_initialized(void)
{
	return debugfs_registered;
}
EXPORT_SYMBOL_GPL(debugfs_initialized);


653
static struct kobject *debug_kobj;
Linus Torvalds's avatar
Linus Torvalds committed
654 655 656 657 658

static int __init debugfs_init(void)
{
	int retval;

659
	debug_kobj = kobject_create_and_add("debug", kernel_kobj);
660 661
	if (!debug_kobj)
		return -EINVAL;
Linus Torvalds's avatar
Linus Torvalds committed
662 663 664

	retval = register_filesystem(&debug_fs_type);
	if (retval)
665
		kobject_put(debug_kobj);
666 667 668
	else
		debugfs_registered = true;

Linus Torvalds's avatar
Linus Torvalds committed
669 670 671 672
	return retval;
}
core_initcall(debugfs_init);