CTC++ Coverage Report - Execution Profile    #878/1532

Files Summary | Functions Summary | Execution Profile | Index | No Index
First | Previous | Next | Last

File: fs/debugfs/inode.c
Instrumentation mode: function-decision-multicondition
TER: 52 % ( 46/ 89)

Start/	End/
True	False	-	Line	Source
			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
			19	#include <linux/config.h>
			20	#include <linux/module.h>
			21	#include <linux/fs.h>
			22	#include <linux/mount.h>
			23	#include <linux/pagemap.h>
			24	#include <linux/init.h>
			25	#include <linux/namei.h>
			26	#include <linux/debugfs.h>
			27
			28	#define DEBUGFS_MAGIC   0x64626720
			29
			30	/* declared over in file.c */
			31	extern struct file_operations debugfs_file_operations;
			32
			33	static struct vfsmount *debugfs_mount;
			34	static int debugfs_mount_count;
			35
78	0		36	static struct inode *debugfs_get_inode(struct super_block *sb, int mode, dev_t dev)
			37	{
			38	struct inode *inode = new_inode(sb);
			39
78	0	-	40	if (inode) {
			41	inode->i_mode = mode;
			42	inode->i_uid = 0;
			43	inode->i_gid = 0;
			44	inode->i_blksize = PAGE_CACHE_SIZE;
			45	inode->i_blocks = 0;
			46	inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
			47	switch (mode & S_IFMT) {
0		-	48	default:
			49	init_special_inode(inode, mode, dev);
0		-	50	break;
66			51	case S_IFREG:
			52	inode->i_fop = &debugfs_file_operations;
66			53	break;
12			54	case S_IFDIR:
			55	inode->i_op = &simple_dir_inode_operations;
			56	inode->i_fop = &simple_dir_operations;
			57
			58	/* directory inodes start off with i_nlink == 2 (for "." entry) */
			59	inode->i_nlink++;
12			60	break;
			61	}
			62	}
78			63	return inode;
			64	}
			65
			66	/* SMP-safe */
78	0		67	static int debugfs_mknod(struct inode *dir, struct dentry *dentry,
			68	int mode, dev_t dev)
			69	{
			70	struct inode *inode = debugfs_get_inode(dir->i_sb, mode, dev);
			71	int error = -EPERM;
			72
0	78	-	73	if (dentry->d_inode)
0		-	74	return -EEXIST;
			75
78	0	-	76	if (inode) {
			77	d_instantiate(dentry, inode);
			78	dget(dentry);
			79	error = 0;
			80	}
78			81	return error;
			82	}
			83
12	0		84	static int debugfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
			85	{
			86	int res;
			87
			88	mode = (mode & (S_IRWXUGO | S_ISVTX)) | S_IFDIR;
			89	res = debugfs_mknod(dir, dentry, mode, 0);
12	0	-	90	if (!res)
			91	dir->i_nlink++;
12			92	return res;
			93	}
			94
66	0		95	static int debugfs_create(struct inode *dir, struct dentry *dentry, int mode)
			96	{
			97	mode = (mode & S_IALLUGO) | S_IFREG;
66			98	return debugfs_mknod(dir, dentry, mode, 0);
			99	}
			100
0	0	-	101	static inline int debugfs_positive(struct dentry *dentry)
			102	{
0		-	103	return dentry->d_inode && !d_unhashed(dentry);
			104	}
			105
6	0		106	static int debug_fill_super(struct super_block *sb, void *data, int silent)
			107	{
			108	static struct tree_descr debug_files[] = {{""}};
			109
6			110	return simple_fill_super(sb, DEBUGFS_MAGIC, debug_files);
			111	}
			112
6	0		113	static struct super_block *debug_get_sb(struct file_system_type *fs_type,
			114	int flags, const char *dev_name,
			115	void *data)
			116	{
6			117	return get_sb_single(fs_type, flags, data, debug_fill_super);
			118	}
			119
			120	static struct file_system_type debug_fs_type = {
			121	.owner =   THIS_MODULE,
			122	.name =      "debugfs",
			123	.get_sb =   debug_get_sb,
			124	.kill_sb =   kill_litter_super,
			125	};
			126
78	0		127	static int debugfs_create_by_name(const char *name, mode_t mode,
			128	struct dentry *parent,
			129	struct dentry **dentry)
			130	{
			131	int error = 0;
			132
			133	/* If the parent is not specified, we create it in the root.
			134	* We need the root dentry to do this, which is in the super
			135	* block. A pointer to that is in the struct vfsmount that we
			136	* have around.
			137	*/
12	66		138	if (!parent ) {
12	0	-	139	if (debugfs_mount && debugfs_mount->mnt_sb) {
12			139	T && T
	0	-	139	T && F
	0	-	139	F && _
			140	parent = debugfs_mount->mnt_sb->s_root;
			141	}
			142	}
0	78	-	143	if (!parent) {
			144	pr_debug("debugfs: Ah! can not find a parent!\n");
0	0	-	144	do-while (0)
0		-	145	return -EFAULT;
			146	}
			147
			148	*dentry = NULL;
			149	mutex_lock(&parent->d_inode->i_mutex);
			150	*dentry = lookup_one_len(name, parent, strlen(name));
78	0	-	151	if (!IS_ERR(dentry)) {
12	66		152	if ((mode & S_IFMT) == S_IFDIR)
			153	error = debugfs_mkdir(parent->d_inode, *dentry, mode);
			154	else
			155	error = debugfs_create(parent->d_inode, *dentry, mode);
			156	} else
			157	error = PTR_ERR(dentry);
			158	mutex_unlock(&parent->d_inode->i_mutex);
			159
78			160	return error;
			161	}
			162
			163	/**
			164	* debugfs_create_file - create a file in the debugfs filesystem
			165	*
			166	* @name: a pointer to a string containing the name of the file to create.
			167	* @mode: the permission that the file should have
			168	* @parent: a pointer to the parent dentry for this file.  This should be a
			169	*          directory dentry if set.  If this paramater is NULL, then the
			170	*          file will be created in the root of the debugfs filesystem.
			171	* @data: a pointer to something that the caller will want to get to later
			172	*        on.  The inode.u.generic_ip pointer will point to this value on
			173	*        the open() call.
			174	* @fops: a pointer to a struct file_operations that should be used for
			175	*        this file.
			176	*
			177	* This is the basic "create a file" function for debugfs.  It allows for a
			178	* wide range of flexibility in createing a file, or a directory (if you
			179	* want to create a directory, the debugfs_create_dir() function is
			180	* recommended to be used instead.)
			181	*
			182	* This function will return a pointer to a dentry if it succeeds.  This
			183	* pointer must be passed to the debugfs_remove() function when the file is
			184	* to be removed (no automatic cleanup happens if your module is unloaded,
			185	* you are responsible here.)  If an error occurs, NULL will be returned.
			186	*
			187	* If debugfs is not enabled in the kernel, the value -ENODEV will be
			188	* returned.  It is not wise to check for this value, but rather, check for
			189	* NULL or !NULL instead as to eliminate the need for #ifdef in the calling
			190	* code.
			191	*/
78	0		192	struct dentry *debugfs_create_file(const char *name, mode_t mode,
			193	struct dentry *parent, void *data,
			194	struct file_operations *fops)
			195	{
			196	struct dentry *dentry = NULL;
			197	int error;
			198
			199	pr_debug("debugfs: creating file '%s'\n",name);
0	78	-	199	do-while (0)
			200
			201	error = simple_pin_fs("debugfs", &debugfs_mount, &debugfs_mount_count);
0	78	-	202	if (error)
0		-	203	goto exit;
			204
			205	error = debugfs_create_by_name(name, mode, parent, &dentry);
0	78	-	206	if (error) {
			207	dentry = NULL;
0		-	208	goto exit;
			209	}
			210
78	0	-	211	if (dentry->d_inode) {
66	12		212	if (data)
			213	dentry->d_inode->u.generic_ip = data;
66	12		214	if (fops)
			215	dentry->d_inode->i_fop = fops;
			216	}
			217	exit:
78			218	return dentry;
			219	}
			220	EXPORT_SYMBOL_GPL(debugfs_create_file);
			221
			222	/**
			223	* debugfs_create_dir - create a directory in the debugfs filesystem
			224	*
			225	* @name: a pointer to a string containing the name of the directory to
			226	*        create.
			227	* @parent: a pointer to the parent dentry for this file.  This should be a
			228	*          directory dentry if set.  If this paramater is NULL, then the
			229	*          directory will be created in the root of the debugfs filesystem.
			230	*
			231	* This function creates a directory in debugfs with the given name.
			232	*
			233	* This function will return a pointer to a dentry if it succeeds.  This
			234	* pointer must be passed to the debugfs_remove() function when the file is
			235	* to be removed (no automatic cleanup happens if your module is unloaded,
			236	* you are responsible here.)  If an error occurs, NULL will be returned.
			237	*
			238	* If debugfs is not enabled in the kernel, the value -ENODEV will be
			239	* returned.  It is not wise to check for this value, but rather, check for
			240	* NULL or !NULL instead as to eliminate the need for #ifdef in the calling
			241	* code.
			242	*/
12	0		243	struct dentry *debugfs_create_dir(const char *name, struct dentry *parent)
			244	{
			245	return debugfs_create_file(name,
			246	S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO,
12			247	parent, NULL, NULL);
			248	}
			249	EXPORT_SYMBOL_GPL(debugfs_create_dir);
			250
			251	/**
			252	* debugfs_remove - removes a file or directory from the debugfs filesystem
			253	*
			254	* @dentry: a pointer to a the dentry of the file or directory to be
			255	*          removed.
			256	*
			257	* This function removes a file or directory in debugfs that was previously
			258	* created with a call to another debugfs function (like
			259	* debufs_create_file() or variants thereof.)
			260	*
			261	* This function is required to be called in order for the file to be
			262	* removed, no automatic cleanup of files will happen when a module is
			263	* removed, you are responsible here.
			264	*/
0	0	-	265	void debugfs_remove(struct dentry *dentry)
			266	{
			267	struct dentry *parent;
			268
0	0	-	269	if (!dentry)
0		-	270	return;
			271
			272	parent = dentry->d_parent;
0	0	-	273	if (!parent || !parent->d_inode)
0		-	273	T || _
0		-	273	F || T
	0	-	273	F || F
0		-	274	return;
			275
			276	mutex_lock(&parent->d_inode->i_mutex);
0	0	-	277	if (debugfs_positive(dentry)) {
0	0	-	278	if (dentry->d_inode) {
0	0	-	279	if (S_ISDIR(dentry->d_inode->i_mode))
			280	simple_rmdir(parent->d_inode, dentry);
			281	else
			282	simple_unlink(parent->d_inode, dentry);
			283	dput(dentry);
			284	}
			285	}
			286	mutex_unlock(&parent->d_inode->i_mutex);
			287	simple_release_fs(&debugfs_mount, &debugfs_mount_count);
			288	}
			289	EXPORT_SYMBOL_GPL(debugfs_remove);
			290
			291	static decl_subsys(debug, NULL, NULL);
			292
6	0		293	static int __init debugfs_init(void)
			294	{
			295	int retval;
			296
			297	kset_set_kset_s(&debug_subsys, kernel_subsys);
			298	retval = subsystem_register(&debug_subsys);
0	6	-	299	if (retval)
0		-	300	return retval;
			301
			302	retval = register_filesystem(&debug_fs_type);
0	6	-	303	if (retval)
			304	subsystem_unregister(&debug_subsys);
6			305	return retval;
			306	}
			307
0	0	-	308	static void __exit debugfs_exit(void)
			309	{
			310	simple_release_fs(&debugfs_mount, &debugfs_mount_count);
			311	unregister_filesystem(&debug_fs_type);
			312	subsystem_unregister(&debug_subsys);
			313	}
			314
			315	core_initcall(debugfs_init);
			316	module_exit(debugfs_exit);
			317	MODULE_LICENSE("GPL");
			318
***TER 52% (46/89) of SOURCE FILE inode.c

Files Summary | Functions Summary | Execution Profile | Index | No Index
First | Previous | Next | Last | Top