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>
13#include <linux/file.h>
14#include <linux/limits.h>
15#include <linux/init.h>
16#include <linux/module.h>
17#include <linux/smp_lock.h>
18
19#include <asm/system.h>
20#include <asm/uaccess.h>
21
22#include "internal.h"
23
24struct proc_dir_entry *de_get(struct proc_dir_entry *de)
25{
26	if (de)
27		atomic_inc(&de->count);
28	return de;
29}
30
31/*
32 * Decrements the use count and checks for deferred deletion.
33 */
34void de_put(struct proc_dir_entry *de)
35{
36	if (de) {
37		lock_kernel();
38		if (!atomic_read(&de->count)) {
39			printk("de_put: entry %s already free!\n", de->name);
40			unlock_kernel();
41			return;
42		}
43
44		if (atomic_dec_and_test(&de->count)) {
45			if (de->deleted) {
46				printk("de_put: deferred delete of %s\n",
47					de->name);
48				free_proc_entry(de);
49			}
50		}
51		unlock_kernel();
52	}
53}
54
55/*
56 * Decrement the use count of the proc_dir_entry.
57 */
58static void proc_delete_inode(struct inode *inode)
59{
60	struct proc_dir_entry *de;
61
62	truncate_inode_pages(&inode->i_data, 0);
63
64	/* Stop tracking associated processes */
65	put_pid(PROC_I(inode)->pid);
66
67	/* Let go of any associated proc directory entry */
68	de = PROC_I(inode)->pde;
69	if (de) {
70		if (de->owner)
71			module_put(de->owner);
72		de_put(de);
73	}
74	clear_inode(inode);
75}
76
77struct vfsmount *proc_mnt;
78
79static void proc_read_inode(struct inode * inode)
80{
81	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
82}
83
84static struct kmem_cache * proc_inode_cachep;
85
86static struct inode *proc_alloc_inode(struct super_block *sb)
87{
88	struct proc_inode *ei;
89	struct inode *inode;
90
91	ei = (struct proc_inode *)kmem_cache_alloc(proc_inode_cachep, GFP_KERNEL);
92	if (!ei)
93		return NULL;
94	ei->pid = NULL;
95	ei->fd = 0;
96	ei->op.proc_get_link = NULL;
97	ei->pde = NULL;
98	inode = &ei->vfs_inode;
99	inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
100	return inode;
101}
102
103static void proc_destroy_inode(struct inode *inode)
104{
105	kmem_cache_free(proc_inode_cachep, PROC_I(inode));
106}
107
108static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
109{
110	struct proc_inode *ei = (struct proc_inode *) foo;
111
112	inode_init_once(&ei->vfs_inode);
113}
114
115int __init proc_init_inodecache(void)
116{
117	proc_inode_cachep = kmem_cache_create("proc_inode_cache",
118					     sizeof(struct proc_inode),
119					     0, (SLAB_RECLAIM_ACCOUNT|
120						SLAB_MEM_SPREAD),
121					     init_once, NULL);
122	if (proc_inode_cachep == NULL)
123		return -ENOMEM;
124	return 0;
125}
126
127static int proc_remount(struct super_block *sb, int *flags, char *data)
128{
129	*flags |= MS_NODIRATIME;
130	return 0;
131}
132
133static const struct super_operations proc_sops = {
134	.alloc_inode	= proc_alloc_inode,
135	.destroy_inode	= proc_destroy_inode,
136	.read_inode	= proc_read_inode,
137	.drop_inode	= generic_delete_inode,
138	.delete_inode	= proc_delete_inode,
139	.statfs		= simple_statfs,
140	.remount_fs	= proc_remount,
141};
142
143struct inode *proc_get_inode(struct super_block *sb, unsigned int ino,
144				struct proc_dir_entry *de)
145{
146	struct inode * inode;
147
148	if (de != NULL && !try_module_get(de->owner))
149		goto out_mod;
150
151	inode = iget(sb, ino);
152	if (!inode)
153		goto out_ino;
154
155	PROC_I(inode)->fd = 0;
156	PROC_I(inode)->pde = de;
157	if (de) {
158		if (de->mode) {
159			inode->i_mode = de->mode;
160			inode->i_uid = de->uid;
161			inode->i_gid = de->gid;
162		}
163		if (de->size)
164			inode->i_size = de->size;
165		if (de->nlink)
166			inode->i_nlink = de->nlink;
167		if (de->proc_iops)
168			inode->i_op = de->proc_iops;
169		if (de->proc_fops)
170			inode->i_fop = de->proc_fops;
171	}
172
173	return inode;
174
175out_ino:
176	if (de != NULL)
177		module_put(de->owner);
178out_mod:
179	return NULL;
180}
181
182int proc_fill_super(struct super_block *s, void *data, int silent)
183{
184	struct inode * root_inode;
185
186	s->s_flags |= MS_NODIRATIME | MS_NOSUID | MS_NOEXEC;
187	s->s_blocksize = 1024;
188	s->s_blocksize_bits = 10;
189	s->s_magic = PROC_SUPER_MAGIC;
190	s->s_op = &proc_sops;
191	s->s_time_gran = 1;
192
193	de_get(&proc_root);
194	root_inode = proc_get_inode(s, PROC_ROOT_INO, &proc_root);
195	if (!root_inode)
196		goto out_no_root;
197	root_inode->i_uid = 0;
198	root_inode->i_gid = 0;
199	s->s_root = d_alloc_root(root_inode);
200	if (!s->s_root)
201		goto out_no_root;
202	return 0;
203
204out_no_root:
205	printk("proc_read_super: get root inode failed\n");
206	iput(root_inode);
207	de_put(&proc_root);
208	return -ENOMEM;
209}
210MODULE_LICENSE("GPL");
211