[linux-2.6-block.git] / fs / proc / inode.c

/*
 *  linux/fs/proc/inode.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 */

#include <linux/time.h>
#include <linux/proc_fs.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/string.h>
#include <linux/stat.h>
#include <linux/completion.h>
#include <linux/file.h>
#include <linux/limits.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/smp_lock.h>

#include <asm/system.h>
#include <asm/uaccess.h>

#include "internal.h"

struct proc_dir_entry *de_get(struct proc_dir_entry *de)
{
	if (de)
		atomic_inc(&de->count);
	return de;
}

/*
 * Decrements the use count and checks for deferred deletion.
 */
void de_put(struct proc_dir_entry *de)
{
	if (de) {	
		lock_kernel();		
		if (!atomic_read(&de->count)) {
			printk("de_put: entry %s already free!\n", de->name);
			unlock_kernel();
			return;
		}

		if (atomic_dec_and_test(&de->count)) {
			if (de->deleted) {
				printk("de_put: deferred delete of %s\n",
					de->name);
				free_proc_entry(de);
			}
		}		
		unlock_kernel();
	}
}

/*
 * Decrement the use count of the proc_dir_entry.
 */
static void proc_delete_inode(struct inode *inode)
{
	struct proc_dir_entry *de;

	truncate_inode_pages(&inode->i_data, 0);

	/* Stop tracking associated processes */
	put_pid(PROC_I(inode)->pid);

	/* Let go of any associated proc directory entry */
	de = PROC_I(inode)->pde;
	if (de) {
		if (de->owner)
			module_put(de->owner);
		de_put(de);
	}
	clear_inode(inode);
}

struct vfsmount *proc_mnt;

static void proc_read_inode(struct inode * inode)
{
	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
}

static struct kmem_cache * proc_inode_cachep;

static struct inode *proc_alloc_inode(struct super_block *sb)
{
	struct proc_inode *ei;
	struct inode *inode;

	ei = (struct proc_inode *)kmem_cache_alloc(proc_inode_cachep, GFP_KERNEL);
	if (!ei)
		return NULL;
	ei->pid = NULL;
	ei->fd = 0;
	ei->op.proc_get_link = NULL;
	ei->pde = NULL;
	inode = &ei->vfs_inode;
	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
	return inode;
}

static void proc_destroy_inode(struct inode *inode)
{
	kmem_cache_free(proc_inode_cachep, PROC_I(inode));
}

static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
{
	struct proc_inode *ei = (struct proc_inode *) foo;

	inode_init_once(&ei->vfs_inode);
}

int __init proc_init_inodecache(void)
{
	proc_inode_cachep = kmem_cache_create("proc_inode_cache",
					     sizeof(struct proc_inode),
					     0, (SLAB_RECLAIM_ACCOUNT|
						SLAB_MEM_SPREAD),
					     init_once);
	if (proc_inode_cachep == NULL)
		return -ENOMEM;
	return 0;
}

static int proc_remount(struct super_block *sb, int *flags, char *data)
{
	*flags |= MS_NODIRATIME;
	return 0;
}

static const struct super_operations proc_sops = {
	.alloc_inode	= proc_alloc_inode,
	.destroy_inode	= proc_destroy_inode,
	.read_inode	= proc_read_inode,
	.drop_inode	= generic_delete_inode,
	.delete_inode	= proc_delete_inode,
	.statfs		= simple_statfs,
	.remount_fs	= proc_remount,
};

static void pde_users_dec(struct proc_dir_entry *pde)
{
	spin_lock(&pde->pde_unload_lock);
	pde->pde_users--;
	if (pde->pde_unload_completion && pde->pde_users == 0)
		complete(pde->pde_unload_completion);
	spin_unlock(&pde->pde_unload_lock);
}

static loff_t proc_reg_llseek(struct file *file, loff_t offset, int whence)
{
	struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
	loff_t rv = -EINVAL;
	loff_t (*llseek)(struct file *, loff_t, int);

	spin_lock(&pde->pde_unload_lock);
	/*
	 * remove_proc_entry() is going to delete PDE (as part of module
	 * cleanup sequence). No new callers into module allowed.
	 */
	if (!pde->proc_fops) {
		spin_unlock(&pde->pde_unload_lock);
		return rv;
	}
	/*
	 * Bump refcount so that remove_proc_entry will wail for ->llseek to
	 * complete.
	 */
	pde->pde_users++;
	/*
	 * Save function pointer under lock, to protect against ->proc_fops
	 * NULL'ifying right after ->pde_unload_lock is dropped.
	 */
	llseek = pde->proc_fops->llseek;
	spin_unlock(&pde->pde_unload_lock);

	if (!llseek)
		llseek = default_llseek;
	rv = llseek(file, offset, whence);

	pde_users_dec(pde);
	return rv;
}

static ssize_t proc_reg_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
	struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
	ssize_t rv = -EIO;
	ssize_t (*read)(struct file *, char __user *, size_t, loff_t *);

	spin_lock(&pde->pde_unload_lock);
	if (!pde->proc_fops) {
		spin_unlock(&pde->pde_unload_lock);
		return rv;
	}
	pde->pde_users++;
	read = pde->proc_fops->read;
	spin_unlock(&pde->pde_unload_lock);

	if (read)
		rv = read(file, buf, count, ppos);

	pde_users_dec(pde);
	return rv;
}

static ssize_t proc_reg_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
	struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
	ssize_t rv = -EIO;
	ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *);

	spin_lock(&pde->pde_unload_lock);
	if (!pde->proc_fops) {
		spin_unlock(&pde->pde_unload_lock);
		return rv;
	}
	pde->pde_users++;
	write = pde->proc_fops->write;
	spin_unlock(&pde->pde_unload_lock);

	if (write)
		rv = write(file, buf, count, ppos);

	pde_users_dec(pde);
	return rv;
}

static unsigned int proc_reg_poll(struct file *file, struct poll_table_struct *pts)
{
	struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
	unsigned int rv = 0;
	unsigned int (*poll)(struct file *, struct poll_table_struct *);

	spin_lock(&pde->pde_unload_lock);
	if (!pde->proc_fops) {
		spin_unlock(&pde->pde_unload_lock);
		return rv;
	}
	pde->pde_users++;
	poll = pde->proc_fops->poll;
	spin_unlock(&pde->pde_unload_lock);

	if (poll)
		rv = poll(file, pts);

	pde_users_dec(pde);
	return rv;
}

static long proc_reg_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
	long rv = -ENOTTY;
	long (*unlocked_ioctl)(struct file *, unsigned int, unsigned long);
	int (*ioctl)(struct inode *, struct file *, unsigned int, unsigned long);

	spin_lock(&pde->pde_unload_lock);
	if (!pde->proc_fops) {
		spin_unlock(&pde->pde_unload_lock);
		return rv;
	}
	pde->pde_users++;
	unlocked_ioctl = pde->proc_fops->unlocked_ioctl;
	ioctl = pde->proc_fops->ioctl;
	spin_unlock(&pde->pde_unload_lock);

	if (unlocked_ioctl) {
		rv = unlocked_ioctl(file, cmd, arg);
		if (rv == -ENOIOCTLCMD)
			rv = -EINVAL;
	} else if (ioctl) {
		lock_kernel();
		rv = ioctl(file->f_path.dentry->d_inode, file, cmd, arg);
		unlock_kernel();
	}

	pde_users_dec(pde);
	return rv;
}

#ifdef CONFIG_COMPAT
static long proc_reg_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
	long rv = -ENOTTY;
	long (*compat_ioctl)(struct file *, unsigned int, unsigned long);

	spin_lock(&pde->pde_unload_lock);
	if (!pde->proc_fops) {
		spin_unlock(&pde->pde_unload_lock);
		return rv;
	}
	pde->pde_users++;
	compat_ioctl = pde->proc_fops->compat_ioctl;
	spin_unlock(&pde->pde_unload_lock);

	if (compat_ioctl)
		rv = compat_ioctl(file, cmd, arg);

	pde_users_dec(pde);
	return rv;
}
#endif

static int proc_reg_mmap(struct file *file, struct vm_area_struct *vma)
{
	struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
	int rv = -EIO;
	int (*mmap)(struct file *, struct vm_area_struct *);

	spin_lock(&pde->pde_unload_lock);
	if (!pde->proc_fops) {
		spin_unlock(&pde->pde_unload_lock);
		return rv;
	}
	pde->pde_users++;
	mmap = pde->proc_fops->mmap;
	spin_unlock(&pde->pde_unload_lock);

	if (mmap)
		rv = mmap(file, vma);

	pde_users_dec(pde);
	return rv;
}

static int proc_reg_open(struct inode *inode, struct file *file)
{
	struct proc_dir_entry *pde = PDE(inode);
	int rv = 0;
	int (*open)(struct inode *, struct file *);

	spin_lock(&pde->pde_unload_lock);
	if (!pde->proc_fops) {
		spin_unlock(&pde->pde_unload_lock);
		return rv;
	}
	pde->pde_users++;
	open = pde->proc_fops->open;
	spin_unlock(&pde->pde_unload_lock);

	if (open)
		rv = open(inode, file);

	pde_users_dec(pde);
	return rv;
}

static int proc_reg_release(struct inode *inode, struct file *file)
{
	struct proc_dir_entry *pde = PDE(inode);
	int rv = 0;
	int (*release)(struct inode *, struct file *);

	spin_lock(&pde->pde_unload_lock);
	if (!pde->proc_fops) {
		spin_unlock(&pde->pde_unload_lock);
		return rv;
	}
	pde->pde_users++;
	release = pde->proc_fops->release;
	spin_unlock(&pde->pde_unload_lock);

	if (release)
		rv = release(inode, file);

	pde_users_dec(pde);
	return rv;
}

static const struct file_operations proc_reg_file_ops = {
	.llseek		= proc_reg_llseek,
	.read		= proc_reg_read,
	.write		= proc_reg_write,
	.poll		= proc_reg_poll,
	.unlocked_ioctl	= proc_reg_unlocked_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl	= proc_reg_compat_ioctl,
#endif
	.mmap		= proc_reg_mmap,
	.open		= proc_reg_open,
	.release	= proc_reg_release,
};

struct inode *proc_get_inode(struct super_block *sb, unsigned int ino,
				struct proc_dir_entry *de)
{
	struct inode * inode;

	if (de != NULL && !try_module_get(de->owner))
		goto out_mod;

	inode = iget(sb, ino);
	if (!inode)
		goto out_ino;

	PROC_I(inode)->fd = 0;
	PROC_I(inode)->pde = de;
	if (de) {
		if (de->mode) {
			inode->i_mode = de->mode;
			inode->i_uid = de->uid;
			inode->i_gid = de->gid;
		}
		if (de->size)
			inode->i_size = de->size;
		if (de->nlink)
			inode->i_nlink = de->nlink;
		if (de->proc_iops)
			inode->i_op = de->proc_iops;
		if (de->proc_fops) {
			if (S_ISREG(inode->i_mode))
				inode->i_fop = &proc_reg_file_ops;
			else
				inode->i_fop = de->proc_fops;
		}
	}

	return inode;

out_ino:
	if (de != NULL)
		module_put(de->owner);
out_mod:
	return NULL;
}			

int proc_fill_super(struct super_block *s, void *data, int silent)
{
	struct inode * root_inode;

	s->s_flags |= MS_NODIRATIME | MS_NOSUID | MS_NOEXEC;
	s->s_blocksize = 1024;
	s->s_blocksize_bits = 10;
	s->s_magic = PROC_SUPER_MAGIC;
	s->s_op = &proc_sops;
	s->s_time_gran = 1;
	
	de_get(&proc_root);
	root_inode = proc_get_inode(s, PROC_ROOT_INO, &proc_root);
	if (!root_inode)
		goto out_no_root;
	root_inode->i_uid = 0;
	root_inode->i_gid = 0;
	s->s_root = d_alloc_root(root_inode);
	if (!s->s_root)
		goto out_no_root;
	return 0;

out_no_root:
	printk("proc_read_super: get root inode failed\n");
	iput(root_inode);
	de_put(&proc_root);
	return -ENOMEM;
}
MODULE_LICENSE("GPL");
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/fs/proc/inode.c
	3	*
	4	* Copyright (C) 1991, 1992 Linus Torvalds
	5	*/
	6
	7	#include <linux/time.h>
	8	#include <linux/proc_fs.h>
	9	#include <linux/kernel.h>
	10	#include <linux/mm.h>
	11	#include <linux/string.h>
	12	#include <linux/stat.h>
786d7e16	13	#include <linux/completion.h>
1da177e4 LT	14	#include <linux/file.h>
	15	#include <linux/limits.h>
	16	#include <linux/init.h>
	17	#include <linux/module.h>
	18	#include <linux/smp_lock.h>
	19
	20	#include <asm/system.h>
	21	#include <asm/uaccess.h>
	22
fee781e6	23	#include "internal.h"
1da177e4	24
7695650a	25	struct proc_dir_entry de_get(struct proc_dir_entry de)
1da177e4 LT	26	{
	27	if (de)
	28	atomic_inc(&de->count);
	29	return de;
	30	}
	31
	32	/*
	33	* Decrements the use count and checks for deferred deletion.
	34	*/
7695650a	35	void de_put(struct proc_dir_entry *de)
1da177e4 LT	36	{
	37	if (de) {
	38	lock_kernel();
	39	if (!atomic_read(&de->count)) {
	40	printk("de_put: entry %s already free!\n", de->name);
	41	unlock_kernel();
	42	return;
	43	}
	44
	45	if (atomic_dec_and_test(&de->count)) {
	46	if (de->deleted) {
	47	printk("de_put: deferred delete of %s\n",
	48	de->name);
	49	free_proc_entry(de);
	50	}
	51	}
	52	unlock_kernel();
	53	}
	54	}
	55
	56	/*
	57	* Decrement the use count of the proc_dir_entry.
	58	*/
	59	static void proc_delete_inode(struct inode *inode)
	60	{
	61	struct proc_dir_entry *de;
1da177e4	62
fef26658 MF	63	truncate_inode_pages(&inode->i_data, 0);
fef26658 MF	64
99f89551	65	/* Stop tracking associated processes */
13b41b09	66	put_pid(PROC_I(inode)->pid);
1da177e4 LT	67
	68	/* Let go of any associated proc directory entry */
	69	de = PROC_I(inode)->pde;
	70	if (de) {
	71	if (de->owner)
	72	module_put(de->owner);
	73	de_put(de);
	74	}
	75	clear_inode(inode);
	76	}
	77
	78	struct vfsmount *proc_mnt;
	79
	80	static void proc_read_inode(struct inode * inode)
	81	{
	82	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
	83	}
	84
e18b890b	85	static struct kmem_cache * proc_inode_cachep;
1da177e4 LT	86
	87	static struct inode proc_alloc_inode(struct super_block sb)
	88	{
	89	struct proc_inode *ei;
	90	struct inode *inode;
	91
e94b1766	92	ei = (struct proc_inode *)kmem_cache_alloc(proc_inode_cachep, GFP_KERNEL);
1da177e4 LT	93	if (!ei)
1da177e4 LT	94	return NULL;
13b41b09	95	ei->pid = NULL;
aed7a6c4	96	ei->fd = 0;
1da177e4 LT	97	ei->op.proc_get_link = NULL;
	98	ei->pde = NULL;
	99	inode = &ei->vfs_inode;
	100	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
	101	return inode;
	102	}
	103
	104	static void proc_destroy_inode(struct inode *inode)
	105	{
	106	kmem_cache_free(proc_inode_cachep, PROC_I(inode));
	107	}
	108
e18b890b	109	static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
1da177e4 LT	110	{
	111	struct proc_inode ei = (struct proc_inode ) foo;
	112
a35afb83	113	inode_init_once(&ei->vfs_inode);
1da177e4	114	}
20c2df83	115
1da177e4 LT	116	int __init proc_init_inodecache(void)
	117	{
	118	proc_inode_cachep = kmem_cache_create("proc_inode_cache",
	119	sizeof(struct proc_inode),
fffb60f9 PJ	120	0, (SLAB_RECLAIM_ACCOUNT\|
fffb60f9 PJ	121	SLAB_MEM_SPREAD),
20c2df83	122	init_once);
1da177e4 LT	123	if (proc_inode_cachep == NULL)
	124	return -ENOMEM;
	125	return 0;
	126	}
	127
	128	static int proc_remount(struct super_block sb, int flags, char *data)
	129	{
	130	*flags \|= MS_NODIRATIME;
	131	return 0;
	132	}
	133
ee9b6d61	134	static const struct super_operations proc_sops = {
1da177e4 LT	135	.alloc_inode = proc_alloc_inode,
	136	.destroy_inode = proc_destroy_inode,
	137	.read_inode = proc_read_inode,
	138	.drop_inode = generic_delete_inode,
	139	.delete_inode = proc_delete_inode,
	140	.statfs = simple_statfs,
	141	.remount_fs = proc_remount,
	142	};
	143
786d7e16 AD	144	static void pde_users_dec(struct proc_dir_entry *pde)
	145	{
	146	spin_lock(&pde->pde_unload_lock);
	147	pde->pde_users--;
	148	if (pde->pde_unload_completion && pde->pde_users == 0)
	149	complete(pde->pde_unload_completion);
	150	spin_unlock(&pde->pde_unload_lock);
	151	}
	152
	153	static loff_t proc_reg_llseek(struct file *file, loff_t offset, int whence)
	154	{
	155	struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
	156	loff_t rv = -EINVAL;
	157	loff_t (llseek)(struct file , loff_t, int);
	158
	159	spin_lock(&pde->pde_unload_lock);
	160	/*
	161	* remove_proc_entry() is going to delete PDE (as part of module
	162	* cleanup sequence). No new callers into module allowed.
	163	*/
	164	if (!pde->proc_fops) {
	165	spin_unlock(&pde->pde_unload_lock);
	166	return rv;
	167	}
	168	/*
	169	* Bump refcount so that remove_proc_entry will wail for ->llseek to
	170	* complete.
	171	*/
	172	pde->pde_users++;
	173	/*
	174	* Save function pointer under lock, to protect against ->proc_fops
	175	* NULL'ifying right after ->pde_unload_lock is dropped.
	176	*/
	177	llseek = pde->proc_fops->llseek;
	178	spin_unlock(&pde->pde_unload_lock);
	179
	180	if (!llseek)
	181	llseek = default_llseek;
	182	rv = llseek(file, offset, whence);
	183
	184	pde_users_dec(pde);
	185	return rv;
	186	}
	187
	188	static ssize_t proc_reg_read(struct file file, char __user buf, size_t count, loff_t *ppos)
	189	{
	190	struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
	191	ssize_t rv = -EIO;
	192	ssize_t (read)(struct file , char __user , size_t, loff_t );
	193
	194	spin_lock(&pde->pde_unload_lock);
	195	if (!pde->proc_fops) {
	196	spin_unlock(&pde->pde_unload_lock);
	197	return rv;
	198	}
	199	pde->pde_users++;
	200	read = pde->proc_fops->read;
	201	spin_unlock(&pde->pde_unload_lock);
	202
	203	if (read)
	204	rv = read(file, buf, count, ppos);
	205
	206	pde_users_dec(pde);
	207	return rv;
208	}
209
210	static ssize_t proc_reg_write(struct file file, const char __user buf, size_t count, loff_t *ppos)
211	{
212	struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
213	ssize_t rv = -EIO;
214	ssize_t (write)(struct file , const char __user , size_t, loff_t );
215
216	spin_lock(&pde->pde_unload_lock);
217	if (!pde->proc_fops) {
218	spin_unlock(&pde->pde_unload_lock);
219	return rv;
220	}
221	pde->pde_users++;
222	write = pde->proc_fops->write;
223	spin_unlock(&pde->pde_unload_lock);
224
225	if (write)
226	rv = write(file, buf, count, ppos);
227
228	pde_users_dec(pde);
229	return rv;
230	}
231
232	static unsigned int proc_reg_poll(struct file file, struct poll_table_struct pts)
233	{
234	struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
235	unsigned int rv = 0;
236	unsigned int (poll)(struct file , struct poll_table_struct *);
237
238	spin_lock(&pde->pde_unload_lock);
239	if (!pde->proc_fops) {
240	spin_unlock(&pde->pde_unload_lock);
241	return rv;
242	}
243	pde->pde_users++;
244	poll = pde->proc_fops->poll;
245	spin_unlock(&pde->pde_unload_lock);
246
247	if (poll)
248	rv = poll(file, pts);
249
250	pde_users_dec(pde);
251	return rv;
252	}
253
254	static long proc_reg_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
255	{
256	struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
257	long rv = -ENOTTY;
258	long (unlocked_ioctl)(struct file , unsigned int, unsigned long);
259	int (ioctl)(struct inode , struct file *, unsigned int, unsigned long);
260
261	spin_lock(&pde->pde_unload_lock);
262	if (!pde->proc_fops) {
263	spin_unlock(&pde->pde_unload_lock);
264	return rv;
265	}
266	pde->pde_users++;
267	unlocked_ioctl = pde->proc_fops->unlocked_ioctl;
268	ioctl = pde->proc_fops->ioctl;
269	spin_unlock(&pde->pde_unload_lock);
270
271	if (unlocked_ioctl) {
272	rv = unlocked_ioctl(file, cmd, arg);
273	if (rv == -ENOIOCTLCMD)
274	rv = -EINVAL;
275	} else if (ioctl) {
276	lock_kernel();
277	rv = ioctl(file->f_path.dentry->d_inode, file, cmd, arg);
278	unlock_kernel();
279	}
280
281	pde_users_dec(pde);
282	return rv;
283	}
284
285	#ifdef CONFIG_COMPAT
286	static long proc_reg_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
287	{
288	struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
289	long rv = -ENOTTY;
290	long (compat_ioctl)(struct file , unsigned int, unsigned long);
291
292	spin_lock(&pde->pde_unload_lock);
293	if (!pde->proc_fops) {
294	spin_unlock(&pde->pde_unload_lock);
295	return rv;
296	}
297	pde->pde_users++;
298	compat_ioctl = pde->proc_fops->compat_ioctl;
299	spin_unlock(&pde->pde_unload_lock);
300
301	if (compat_ioctl)
302	rv = compat_ioctl(file, cmd, arg);
303
304	pde_users_dec(pde);
305	return rv;
306	}
307	#endif
308
309	static int proc_reg_mmap(struct file file, struct vm_area_struct vma)
310	{
311	struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
312	int rv = -EIO;
313	int (mmap)(struct file , struct vm_area_struct *);
314
315	spin_lock(&pde->pde_unload_lock);
316	if (!pde->proc_fops) {
317	spin_unlock(&pde->pde_unload_lock);
318	return rv;
319	}
320	pde->pde_users++;
321	mmap = pde->proc_fops->mmap;
322	spin_unlock(&pde->pde_unload_lock);
323
324	if (mmap)
325	rv = mmap(file, vma);
326
327	pde_users_dec(pde);
328	return rv;
329	}
330
331	static int proc_reg_open(struct inode inode, struct file file)
332	{
333	struct proc_dir_entry *pde = PDE(inode);
334	int rv = 0;
335	int (open)(struct inode , struct file *);
336
337	spin_lock(&pde->pde_unload_lock);
338	if (!pde->proc_fops) {
339	spin_unlock(&pde->pde_unload_lock);
340	return rv;
341	}
342	pde->pde_users++;
343	open = pde->proc_fops->open;
344	spin_unlock(&pde->pde_unload_lock);
345
346	if (open)
347	rv = open(inode, file);
348
349	pde_users_dec(pde);
350	return rv;
351	}
352
353	static int proc_reg_release(struct inode inode, struct file file)
354	{
355	struct proc_dir_entry *pde = PDE(inode);
356	int rv = 0;
357	int (release)(struct inode , struct file *);
358
359	spin_lock(&pde->pde_unload_lock);
360	if (!pde->proc_fops) {
361	spin_unlock(&pde->pde_unload_lock);
362	return rv;
363	}
364	pde->pde_users++;
365	release = pde->proc_fops->release;
366	spin_unlock(&pde->pde_unload_lock);
367
368	if (release)
369	rv = release(inode, file);
370
371	pde_users_dec(pde);
372	return rv;
373	}
374
375	static const struct file_operations proc_reg_file_ops = {
376	.llseek = proc_reg_llseek,
377	.read = proc_reg_read,
378	.write = proc_reg_write,
379	.poll = proc_reg_poll,
380	.unlocked_ioctl = proc_reg_unlocked_ioctl,
381	#ifdef CONFIG_COMPAT
382	.compat_ioctl = proc_reg_compat_ioctl,
383	#endif
384	.mmap = proc_reg_mmap,
385	.open = proc_reg_open,
386	.release = proc_reg_release,
387	};
388
1da177e4 LT	389	struct inode proc_get_inode(struct super_block sb, unsigned int ino,
	390	struct proc_dir_entry *de)
	391	{
	392	struct inode * inode;
	393
e9543659 KK	394	if (de != NULL && !try_module_get(de->owner))
	395	goto out_mod;
	396
1da177e4 LT	397	inode = iget(sb, ino);
1da177e4 LT	398	if (!inode)
e9543659 KK	399	goto out_ino;
e9543659 KK	400
77b14db5	401	PROC_I(inode)->fd = 0;
1da177e4 LT	402	PROC_I(inode)->pde = de;
	403	if (de) {
	404	if (de->mode) {
	405	inode->i_mode = de->mode;
	406	inode->i_uid = de->uid;
	407	inode->i_gid = de->gid;
	408	}
	409	if (de->size)
	410	inode->i_size = de->size;
	411	if (de->nlink)
	412	inode->i_nlink = de->nlink;
1da177e4 LT	413	if (de->proc_iops)
1da177e4 LT	414	inode->i_op = de->proc_iops;
786d7e16 AD	415	if (de->proc_fops) {
	416	if (S_ISREG(inode->i_mode))
	417	inode->i_fop = &proc_reg_file_ops;
	418	else
	419	inode->i_fop = de->proc_fops;
	420	}
1da177e4 LT	421	}
1da177e4 LT	422
1da177e4 LT	423	return inode;
1da177e4 LT	424
e9543659 KK	425	out_ino:
	426	if (de != NULL)
	427	module_put(de->owner);
	428	out_mod:
e9543659	429	return NULL;
1da177e4 LT	430	}
	431
	432	int proc_fill_super(struct super_block s, void data, int silent)
	433	{
	434	struct inode * root_inode;
	435
92d03285	436	s->s_flags \|= MS_NODIRATIME \| MS_NOSUID \| MS_NOEXEC;
1da177e4 LT	437	s->s_blocksize = 1024;
	438	s->s_blocksize_bits = 10;
	439	s->s_magic = PROC_SUPER_MAGIC;
	440	s->s_op = &proc_sops;
	441	s->s_time_gran = 1;
	442
7695650a	443	de_get(&proc_root);
1da177e4 LT	444	root_inode = proc_get_inode(s, PROC_ROOT_INO, &proc_root);
	445	if (!root_inode)
	446	goto out_no_root;
1da177e4 LT	447	root_inode->i_uid = 0;
	448	root_inode->i_gid = 0;
	449	s->s_root = d_alloc_root(root_inode);
	450	if (!s->s_root)
	451	goto out_no_root;
	452	return 0;
	453
	454	out_no_root:
	455	printk("proc_read_super: get root inode failed\n");
	456	iput(root_inode);
7695650a	457	de_put(&proc_root);
1da177e4 LT	458	return -ENOMEM;
	459	}
	460	MODULE_LICENSE("GPL");