[net-next-2.6.git] / fs / debugfs / inode.c

/*
 *  file.c - part of debugfs, a tiny little debug file system
 *
 *  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.
 *
 */

/* uncomment to get debug messages from the debug filesystem, ah the irony. */
/* #define DEBUG */

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/mount.h>
#include <linux/pagemap.h>
#include <linux/init.h>
#include <linux/kobject.h>
#include <linux/namei.h>
#include <linux/debugfs.h>
#include <linux/fsnotify.h>
#include <linux/string.h>

#define DEBUGFS_MAGIC	0x64626720

/* declared over in file.c */
extern struct file_operations debugfs_file_operations;
extern struct inode_operations debugfs_link_operations;

static struct vfsmount *debugfs_mount;
static int debugfs_mount_count;

static struct inode *debugfs_get_inode(struct super_block *sb, int mode, dev_t dev)
{
	struct inode *inode = new_inode(sb);

	if (inode) {
		inode->i_mode = mode;
		inode->i_uid = 0;
		inode->i_gid = 0;
		inode->i_blocks = 0;
		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:
			inode->i_fop = &debugfs_file_operations;
			break;
		case S_IFLNK:
			inode->i_op = &debugfs_link_operations;
			break;
		case S_IFDIR:
			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);
			break;
		}
	}
	return inode; 
}

/* SMP-safe */
static int debugfs_mknod(struct inode *dir, struct dentry *dentry,
			 int mode, dev_t dev)
{
	struct inode *inode;
	int error = -EPERM;

	if (dentry->d_inode)
		return -EEXIST;

	inode = debugfs_get_inode(dir->i_sb, mode, dev);
	if (inode) {
		d_instantiate(dentry, inode);
		dget(dentry);
		error = 0;
	}
	return error;
}

static int debugfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
{
	int res;

	mode = (mode & (S_IRWXUGO | S_ISVTX)) | S_IFDIR;
	res = debugfs_mknod(dir, dentry, mode, 0);
	if (!res) {
		inc_nlink(dir);
		fsnotify_mkdir(dir, dentry);
	}
	return res;
}

static int debugfs_link(struct inode *dir, struct dentry *dentry, int mode)
{
	mode = (mode & S_IALLUGO) | S_IFLNK;
	return debugfs_mknod(dir, dentry, mode, 0);
}

static int debugfs_create(struct inode *dir, struct dentry *dentry, int mode)
{
	int res;

	mode = (mode & S_IALLUGO) | S_IFREG;
	res = debugfs_mknod(dir, dentry, mode, 0);
	if (!res)
		fsnotify_create(dir, dentry);
	return res;
}

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

static int debug_fill_super(struct super_block *sb, void *data, int silent)
{
	static struct tree_descr debug_files[] = {{""}};

	return simple_fill_super(sb, DEBUGFS_MAGIC, debug_files);
}

static int debug_get_sb(struct file_system_type *fs_type,
			int flags, const char *dev_name,
			void *data, struct vfsmount *mnt)
{
	return get_sb_single(fs_type, flags, data, debug_fill_super, mnt);
}

static struct file_system_type debug_fs_type = {
	.owner =	THIS_MODULE,
	.name =		"debugfs",
	.get_sb =	debug_get_sb,
	.kill_sb =	kill_litter_super,
};

static int debugfs_create_by_name(const char *name, mode_t mode,
				  struct dentry *parent,
				  struct dentry **dentry)
{
	int error = 0;

	/* 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.
	 */
	if (!parent) {
		if (debugfs_mount && debugfs_mount->mnt_sb) {
			parent = debugfs_mount->mnt_sb->s_root;
		}
	}
	if (!parent) {
		pr_debug("debugfs: Ah! can not find a parent!\n");
		return -EFAULT;
	}

	*dentry = NULL;
	mutex_lock(&parent->d_inode->i_mutex);
	*dentry = lookup_one_len(name, parent, strlen(name));
	if (!IS_ERR(*dentry)) {
		switch (mode & S_IFMT) {
		case S_IFDIR:
			error = debugfs_mkdir(parent->d_inode, *dentry, mode);
			break;
		case S_IFLNK:
			error = debugfs_link(parent->d_inode, *dentry, mode);
			break;
		default:
			error = debugfs_create(parent->d_inode, *dentry, mode);
			break;
		}
		dput(*dentry);
	} else
		error = PTR_ERR(*dentry);
	mutex_unlock(&parent->d_inode->i_mutex);

	return error;
}

/**
 * debugfs_create_file - 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 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
 *        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.
 *
 * This is the basic "create a file" function for debugfs.  It allows for a
 * wide range of flexibility in createing 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.  It is not wise to check for this value, but rather, check for
 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
 * code.
 */
struct dentry *debugfs_create_file(const char *name, mode_t mode,
				   struct dentry *parent, void *data,
				   const struct file_operations *fops)
{
	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;

	error = debugfs_create_by_name(name, mode, parent, &dentry);
	if (error) {
		dentry = NULL;
		simple_release_fs(&debugfs_mount, &debugfs_mount_count);
		goto exit;
	}

	if (dentry->d_inode) {
		if (data)
			dentry->d_inode->i_private = data;
		if (fops)
			dentry->d_inode->i_fop = fops;
	}
exit:
	return dentry;
}
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,
 * 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.  It is not wise to check for this value, but rather, check for
 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
 * code.
 */
struct dentry *debugfs_create_dir(const char *name, struct dentry *parent)
{
	return debugfs_create_file(name, 
				   S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO,
				   parent, NULL, NULL);
}
EXPORT_SYMBOL_GPL(debugfs_create_dir);

/**
 * 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
 * returned.  It is not wise to check for this value, but rather, check for
 * %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
 * code.
 */
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;

	result = debugfs_create_file(name, S_IFLNK | S_IRWXUGO, parent, link,
				     NULL);
	if (!result)
		kfree(link);
	return result;
}
EXPORT_SYMBOL_GPL(debugfs_create_symlink);

/**
 * 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
 * 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(struct dentry *dentry)
{
	struct dentry *parent;
	int ret = 0;
	
	if (!dentry)
		return;

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

	mutex_lock(&parent->d_inode->i_mutex);
	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);
				if (ret)
					printk(KERN_ERR
						"DebugFS rmdir on %s failed : "
						"directory not empty.\n",
						dentry->d_name.name);
				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);
		}
	}
	mutex_unlock(&parent->d_inode->i_mutex);
	simple_release_fs(&debugfs_mount, &debugfs_mount_count);
}
EXPORT_SYMBOL_GPL(debugfs_remove);

static decl_subsys(debug, NULL, NULL);

static int __init debugfs_init(void)
{
	int retval;

	kset_set_kset_s(&debug_subsys, kernel_subsys);
	retval = subsystem_register(&debug_subsys);
	if (retval)
		return retval;

	retval = register_filesystem(&debug_fs_type);
	if (retval)
		subsystem_unregister(&debug_subsys);
	return retval;
}

static void __exit debugfs_exit(void)
{
	simple_release_fs(&debugfs_mount, &debugfs_mount_count);
	unregister_filesystem(&debug_fs_type);
	subsystem_unregister(&debug_subsys);
}

core_initcall(debugfs_init);
module_exit(debugfs_exit);
MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	1	/*
	2	* file.c - part of debugfs, a tiny little debug file system
	3	*
	4	* Copyright (C) 2004 Greg Kroah-Hartman <greg@kroah.com>
	5	* Copyright (C) 2004 IBM Inc.
	6	*
	7	* This program is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU General Public License version
	9	* 2 as published by the Free Software Foundation.
	10	*
	11	* debugfs is for people to use instead of /proc or /sys.
	12	* See Documentation/DocBook/kernel-api for more details.
	13	*
	14	*/
	15
	16	/* uncomment to get debug messages from the debug filesystem, ah the irony. */
	17	/* #define DEBUG */
	18
1da177e4 LT	19	#include <linux/module.h>
	20	#include <linux/fs.h>
	21	#include <linux/mount.h>
	22	#include <linux/pagemap.h>
	23	#include <linux/init.h>
4d8ebddc	24	#include <linux/kobject.h>
1da177e4 LT	25	#include <linux/namei.h>
1da177e4 LT	26	#include <linux/debugfs.h>
4f36557f	27	#include <linux/fsnotify.h>
66f54963	28	#include <linux/string.h>
1da177e4 LT	29
	30	#define DEBUGFS_MAGIC 0x64626720
	31
	32	/* declared over in file.c */
	33	extern struct file_operations debugfs_file_operations;
66f54963	34	extern struct inode_operations debugfs_link_operations;
1da177e4 LT	35
	36	static struct vfsmount *debugfs_mount;
	37	static int debugfs_mount_count;
	38
	39	static struct inode debugfs_get_inode(struct super_block sb, int mode, dev_t dev)
	40	{
	41	struct inode *inode = new_inode(sb);
	42
	43	if (inode) {
	44	inode->i_mode = mode;
	45	inode->i_uid = 0;
	46	inode->i_gid = 0;
1da177e4 LT	47	inode->i_blocks = 0;
	48	inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
	49	switch (mode & S_IFMT) {
	50	default:
	51	init_special_inode(inode, mode, dev);
	52	break;
	53	case S_IFREG:
	54	inode->i_fop = &debugfs_file_operations;
	55	break;
66f54963 PO	56	case S_IFLNK:
	57	inode->i_op = &debugfs_link_operations;
	58	break;
1da177e4 LT	59	case S_IFDIR:
	60	inode->i_op = &simple_dir_inode_operations;
	61	inode->i_fop = &simple_dir_operations;
	62
bafb232e MD	63	/* directory inodes start off with i_nlink == 2
bafb232e MD	64	* (for "." entry) */
d8c76e6f	65	inc_nlink(inode);
1da177e4 LT	66	break;
	67	}
	68	}
	69	return inode;
	70	}
	71
	72	/* SMP-safe */
	73	static int debugfs_mknod(struct inode dir, struct dentry dentry,
	74	int mode, dev_t dev)
	75	{
71601e2b	76	struct inode *inode;
1da177e4 LT	77	int error = -EPERM;
	78
	79	if (dentry->d_inode)
	80	return -EEXIST;
	81
71601e2b	82	inode = debugfs_get_inode(dir->i_sb, mode, dev);
1da177e4 LT	83	if (inode) {
	84	d_instantiate(dentry, inode);
	85	dget(dentry);
	86	error = 0;
	87	}
	88	return error;
	89	}
	90
	91	static int debugfs_mkdir(struct inode dir, struct dentry dentry, int mode)
	92	{
	93	int res;
	94
	95	mode = (mode & (S_IRWXUGO \| S_ISVTX)) \| S_IFDIR;
	96	res = debugfs_mknod(dir, dentry, mode, 0);
4f36557f	97	if (!res) {
d8c76e6f	98	inc_nlink(dir);
4f36557f MD	99	fsnotify_mkdir(dir, dentry);
4f36557f MD	100	}
1da177e4 LT	101	return res;
	102	}
	103
66f54963 PO	104	static int debugfs_link(struct inode dir, struct dentry dentry, int mode)
	105	{
	106	mode = (mode & S_IALLUGO) \| S_IFLNK;
	107	return debugfs_mknod(dir, dentry, mode, 0);
	108	}
	109
1da177e4 LT	110	static int debugfs_create(struct inode dir, struct dentry dentry, int mode)
1da177e4 LT	111	{
4f36557f MD	112	int res;
4f36557f MD	113
1da177e4	114	mode = (mode & S_IALLUGO) \| S_IFREG;
4f36557f MD	115	res = debugfs_mknod(dir, dentry, mode, 0);
	116	if (!res)
	117	fsnotify_create(dir, dentry);
	118	return res;
1da177e4 LT	119	}
	120
	121	static inline int debugfs_positive(struct dentry *dentry)
	122	{
	123	return dentry->d_inode && !d_unhashed(dentry);
	124	}
	125
	126	static int debug_fill_super(struct super_block sb, void data, int silent)
	127	{
	128	static struct tree_descr debug_files[] = {{""}};
	129
	130	return simple_fill_super(sb, DEBUGFS_MAGIC, debug_files);
	131	}
	132
454e2398 DH	133	static int debug_get_sb(struct file_system_type *fs_type,
	134	int flags, const char *dev_name,
	135	void data, struct vfsmount mnt)
1da177e4	136	{
454e2398	137	return get_sb_single(fs_type, flags, data, debug_fill_super, mnt);
1da177e4 LT	138	}
	139
	140	static struct file_system_type debug_fs_type = {
	141	.owner = THIS_MODULE,
	142	.name = "debugfs",
	143	.get_sb = debug_get_sb,
	144	.kill_sb = kill_litter_super,
	145	};
	146
	147	static int debugfs_create_by_name(const char *name, mode_t mode,
	148	struct dentry *parent,
	149	struct dentry **dentry)
	150	{
	151	int error = 0;
	152
	153	/* If the parent is not specified, we create it in the root.
	154	* We need the root dentry to do this, which is in the super
	155	* block. A pointer to that is in the struct vfsmount that we
	156	* have around.
	157	*/
bafb232e	158	if (!parent) {
1da177e4 LT	159	if (debugfs_mount && debugfs_mount->mnt_sb) {
	160	parent = debugfs_mount->mnt_sb->s_root;
	161	}
	162	}
	163	if (!parent) {
	164	pr_debug("debugfs: Ah! can not find a parent!\n");
	165	return -EFAULT;
	166	}
	167
	168	*dentry = NULL;
1b1dcc1b	169	mutex_lock(&parent->d_inode->i_mutex);
5f45f1a7	170	*dentry = lookup_one_len(name, parent, strlen(name));
7bb0386f	171	if (!IS_ERR(*dentry)) {
66f54963 PO	172	switch (mode & S_IFMT) {
66f54963 PO	173	case S_IFDIR:
1da177e4	174	error = debugfs_mkdir(parent->d_inode, *dentry, mode);
66f54963 PO	175	break;
	176	case S_IFLNK:
	177	error = debugfs_link(parent->d_inode, *dentry, mode);
	178	break;
	179	default:
1da177e4	180	error = debugfs_create(parent->d_inode, *dentry, mode);
66f54963 PO	181	break;
66f54963 PO	182	}
65c33336	183	dput(*dentry);
1da177e4	184	} else
7bb0386f	185	error = PTR_ERR(*dentry);
1b1dcc1b	186	mutex_unlock(&parent->d_inode->i_mutex);
1da177e4 LT	187
	188	return error;
	189	}
	190
	191	/**
	192	* debugfs_create_file - create a file in the debugfs filesystem
1da177e4 LT	193	* @name: a pointer to a string containing the name of the file to create.
	194	* @mode: the permission that the file should have
	195	* @parent: a pointer to the parent dentry for this file. This should be a
	196	* directory dentry if set. If this paramater is NULL, then the
	197	* file will be created in the root of the debugfs filesystem.
	198	* @data: a pointer to something that the caller will want to get to later
8e18e294	199	* on. The inode.i_private pointer will point to this value on
1da177e4 LT	200	* the open() call.
	201	* @fops: a pointer to a struct file_operations that should be used for
	202	* this file.
	203	*
	204	* This is the basic "create a file" function for debugfs. It allows for a
	205	* wide range of flexibility in createing a file, or a directory (if you
	206	* want to create a directory, the debugfs_create_dir() function is
	207	* recommended to be used instead.)
	208	*
	209	* This function will return a pointer to a dentry if it succeeds. This
	210	* pointer must be passed to the debugfs_remove() function when the file is
	211	* to be removed (no automatic cleanup happens if your module is unloaded,
6468b3af	212	* you are responsible here.) If an error occurs, %NULL will be returned.
1da177e4	213	*
6468b3af	214	* If debugfs is not enabled in the kernel, the value -%ENODEV will be
1da177e4	215	* returned. It is not wise to check for this value, but rather, check for
6468b3af	216	* %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
1da177e4 LT	217	* code.
	218	*/
	219	struct dentry debugfs_create_file(const char name, mode_t mode,
	220	struct dentry parent, void data,
99ac48f5	221	const struct file_operations *fops)
1da177e4 LT	222	{
	223	struct dentry *dentry = NULL;
	224	int error;
	225
	226	pr_debug("debugfs: creating file '%s'\n",name);
	227
63223a06 MD	228	error = simple_pin_fs(&debug_fs_type, &debugfs_mount,
63223a06 MD	229	&debugfs_mount_count);
1da177e4 LT	230	if (error)
	231	goto exit;
	232
	233	error = debugfs_create_by_name(name, mode, parent, &dentry);
	234	if (error) {
	235	dentry = NULL;
63223a06	236	simple_release_fs(&debugfs_mount, &debugfs_mount_count);
1da177e4 LT	237	goto exit;
	238	}
	239
	240	if (dentry->d_inode) {
	241	if (data)
8e18e294	242	dentry->d_inode->i_private = data;
1da177e4 LT	243	if (fops)
	244	dentry->d_inode->i_fop = fops;
	245	}
	246	exit:
	247	return dentry;
	248	}
	249	EXPORT_SYMBOL_GPL(debugfs_create_file);
	250
	251	/**
	252	* debugfs_create_dir - create a directory in the debugfs filesystem
1da177e4 LT	253	* @name: a pointer to a string containing the name of the directory to
	254	* create.
	255	* @parent: a pointer to the parent dentry for this file. This should be a
	256	* directory dentry if set. If this paramater is NULL, then the
	257	* directory will be created in the root of the debugfs filesystem.
	258	*
	259	* This function creates a directory in debugfs with the given name.
	260	*
	261	* This function will return a pointer to a dentry if it succeeds. This
	262	* pointer must be passed to the debugfs_remove() function when the file is
	263	* to be removed (no automatic cleanup happens if your module is unloaded,
6468b3af	264	* you are responsible here.) If an error occurs, %NULL will be returned.
1da177e4	265	*
6468b3af	266	* If debugfs is not enabled in the kernel, the value -%ENODEV will be
1da177e4	267	* returned. It is not wise to check for this value, but rather, check for
6468b3af	268	* %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
1da177e4 LT	269	* code.
	270	*/
	271	struct dentry debugfs_create_dir(const char name, struct dentry *parent)
	272	{
	273	return debugfs_create_file(name,
	274	S_IFDIR \| S_IRWXU \| S_IRUGO \| S_IXUGO,
	275	parent, NULL, NULL);
	276	}
	277	EXPORT_SYMBOL_GPL(debugfs_create_dir);
	278
66f54963 PO	279	/**
	280	* debugfs_create_symlink- create a symbolic link in the debugfs filesystem
	281	* @name: a pointer to a string containing the name of the symbolic link to
	282	* create.
	283	* @parent: a pointer to the parent dentry for this symbolic link. This
	284	* should be a directory dentry if set. If this paramater is NULL,
	285	* then the symbolic link will be created in the root of the debugfs
	286	* filesystem.
	287	* @target: a pointer to a string containing the path to the target of the
	288	* symbolic link.
	289	*
	290	* This function creates a symbolic link with the given name in debugfs that
	291	* links to the given target path.
	292	*
	293	* This function will return a pointer to a dentry if it succeeds. This
	294	* pointer must be passed to the debugfs_remove() function when the symbolic
	295	* link is to be removed (no automatic cleanup happens if your module is
	296	* unloaded, you are responsible here.) If an error occurs, %NULL will be
	297	* returned.
	298	*
	299	* If debugfs is not enabled in the kernel, the value -%ENODEV will be
	300	* returned. It is not wise to check for this value, but rather, check for
	301	* %NULL or !%NULL instead as to eliminate the need for #ifdef in the calling
	302	* code.
	303	*/
	304	struct dentry debugfs_create_symlink(const char name, struct dentry *parent,
	305	const char *target)
	306	{
	307	struct dentry *result;
	308	char *link;
	309
	310	link = kstrdup(target, GFP_KERNEL);
	311	if (!link)
	312	return NULL;
	313
	314	result = debugfs_create_file(name, S_IFLNK \| S_IRWXUGO, parent, link,
	315	NULL);
	316	if (!result)
	317	kfree(link);
	318	return result;
	319	}
	320	EXPORT_SYMBOL_GPL(debugfs_create_symlink);
	321
1da177e4 LT	322	/**
1da177e4 LT	323	* debugfs_remove - removes a file or directory from the debugfs filesystem
1da177e4 LT	324	* @dentry: a pointer to a the dentry of the file or directory to be
	325	* removed.
	326	*
	327	* This function removes a file or directory in debugfs that was previously
	328	* created with a call to another debugfs function (like
5a65980e	329	* debugfs_create_file() or variants thereof.)
1da177e4 LT	330	*
	331	* This function is required to be called in order for the file to be
	332	* removed, no automatic cleanup of files will happen when a module is
	333	* removed, you are responsible here.
	334	*/
	335	void debugfs_remove(struct dentry *dentry)
	336	{
	337	struct dentry *parent;
65c33336	338	int ret = 0;
1da177e4 LT	339
	340	if (!dentry)
	341	return;
	342
	343	parent = dentry->d_parent;
	344	if (!parent \|\| !parent->d_inode)
	345	return;
	346
1b1dcc1b	347	mutex_lock(&parent->d_inode->i_mutex);
1da177e4 LT	348	if (debugfs_positive(dentry)) {
1da177e4 LT	349	if (dentry->d_inode) {
29a7f3ad	350	dget(dentry);
66f54963 PO	351	switch (dentry->d_inode->i_mode & S_IFMT) {
66f54963 PO	352	case S_IFDIR:
65c33336 MD	353	ret = simple_rmdir(parent->d_inode, dentry);
	354	if (ret)
	355	printk(KERN_ERR
	356	"DebugFS rmdir on %s failed : "
	357	"directory not empty.\n",
	358	dentry->d_name.name);
66f54963 PO	359	break;
	360	case S_IFLNK:
	361	kfree(dentry->d_inode->i_private);
	362	/* fall through */
	363	default:
1da177e4	364	simple_unlink(parent->d_inode, dentry);
66f54963 PO	365	break;
66f54963 PO	366	}
29a7f3ad MD	367	if (!ret)
	368	d_delete(dentry);
	369	dput(dentry);
1da177e4 LT	370	}
1da177e4 LT	371	}
1b1dcc1b	372	mutex_unlock(&parent->d_inode->i_mutex);
1da177e4 LT	373	simple_release_fs(&debugfs_mount, &debugfs_mount_count);
	374	}
	375	EXPORT_SYMBOL_GPL(debugfs_remove);
	376
	377	static decl_subsys(debug, NULL, NULL);
	378
	379	static int __init debugfs_init(void)
	380	{
	381	int retval;
	382
	383	kset_set_kset_s(&debug_subsys, kernel_subsys);
	384	retval = subsystem_register(&debug_subsys);
	385	if (retval)
	386	return retval;
	387
	388	retval = register_filesystem(&debug_fs_type);
	389	if (retval)
	390	subsystem_unregister(&debug_subsys);
	391	return retval;
	392	}
	393
	394	static void __exit debugfs_exit(void)
	395	{
	396	simple_release_fs(&debugfs_mount, &debugfs_mount_count);
	397	unregister_filesystem(&debug_fs_type);
	398	subsystem_unregister(&debug_subsys);
	399	}
	400
	401	core_initcall(debugfs_init);
	402	module_exit(debugfs_exit);
	403	MODULE_LICENSE("GPL");
	404