blob: 82b3a1b5a70b8c887a2e4b7cf698843097b84c0e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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>
Alexey Dobriyan786d7e12007-07-15 23:39:00 -070013#include <linux/completion.h>
Alexey Dobriyandd23aae2007-09-11 15:23:55 -070014#include <linux/poll.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/file.h>
16#include <linux/limits.h>
17#include <linux/init.h>
18#include <linux/module.h>
19#include <linux/smp_lock.h>
20
21#include <asm/system.h>
22#include <asm/uaccess.h>
23
Adrian Bunkfee781e2006-01-08 01:04:16 -080024#include "internal.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070025
Alexey Dobriyan76956502007-05-08 00:25:45 -070026struct proc_dir_entry *de_get(struct proc_dir_entry *de)
Linus Torvalds1da177e2005-04-16 15:20:36 -070027{
28 if (de)
29 atomic_inc(&de->count);
30 return de;
31}
32
33/*
34 * Decrements the use count and checks for deferred deletion.
35 */
Alexey Dobriyan76956502007-05-08 00:25:45 -070036void de_put(struct proc_dir_entry *de)
Linus Torvalds1da177e2005-04-16 15:20:36 -070037{
38 if (de) {
39 lock_kernel();
40 if (!atomic_read(&de->count)) {
41 printk("de_put: entry %s already free!\n", de->name);
42 unlock_kernel();
43 return;
44 }
45
Alexey Dobriyan5a622f22007-12-04 23:45:28 -080046 if (atomic_dec_and_test(&de->count))
47 free_proc_entry(de);
Linus Torvalds1da177e2005-04-16 15:20:36 -070048 unlock_kernel();
49 }
50}
51
52/*
53 * Decrement the use count of the proc_dir_entry.
54 */
55static void proc_delete_inode(struct inode *inode)
56{
57 struct proc_dir_entry *de;
Linus Torvalds1da177e2005-04-16 15:20:36 -070058
Mark Fashehfef26652005-09-09 13:01:31 -070059 truncate_inode_pages(&inode->i_data, 0);
60
Eric W. Biederman99f89552006-06-26 00:25:55 -070061 /* Stop tracking associated processes */
Eric W. Biederman13b41b02006-06-26 00:25:56 -070062 put_pid(PROC_I(inode)->pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -070063
64 /* Let go of any associated proc directory entry */
65 de = PROC_I(inode)->pde;
66 if (de) {
67 if (de->owner)
68 module_put(de->owner);
69 de_put(de);
70 }
71 clear_inode(inode);
72}
73
74struct vfsmount *proc_mnt;
75
Christoph Lametere18b8902006-12-06 20:33:20 -080076static struct kmem_cache * proc_inode_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
78static struct inode *proc_alloc_inode(struct super_block *sb)
79{
80 struct proc_inode *ei;
81 struct inode *inode;
82
Christoph Lametere94b1762006-12-06 20:33:17 -080083 ei = (struct proc_inode *)kmem_cache_alloc(proc_inode_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070084 if (!ei)
85 return NULL;
Eric W. Biederman13b41b02006-06-26 00:25:56 -070086 ei->pid = NULL;
Eric W. Biedermanaed7a6c2006-06-26 00:25:44 -070087 ei->fd = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 ei->op.proc_get_link = NULL;
89 ei->pde = NULL;
90 inode = &ei->vfs_inode;
91 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
92 return inode;
93}
94
95static void proc_destroy_inode(struct inode *inode)
96{
97 kmem_cache_free(proc_inode_cachep, PROC_I(inode));
98}
99
Christoph Lameter4ba9b9d2007-10-16 23:25:51 -0700100static void init_once(struct kmem_cache * cachep, void *foo)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101{
102 struct proc_inode *ei = (struct proc_inode *) foo;
103
Christoph Lametera35afb82007-05-16 22:10:57 -0700104 inode_init_once(&ei->vfs_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105}
Paul Mundt20c2df82007-07-20 10:11:58 +0900106
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107int __init proc_init_inodecache(void)
108{
109 proc_inode_cachep = kmem_cache_create("proc_inode_cache",
110 sizeof(struct proc_inode),
Paul Jacksonfffb60f2006-03-24 03:16:06 -0800111 0, (SLAB_RECLAIM_ACCOUNT|
Alexey Dobriyan040b5c62007-10-16 23:26:10 -0700112 SLAB_MEM_SPREAD|SLAB_PANIC),
Paul Mundt20c2df82007-07-20 10:11:58 +0900113 init_once);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 return 0;
115}
116
117static int proc_remount(struct super_block *sb, int *flags, char *data)
118{
119 *flags |= MS_NODIRATIME;
120 return 0;
121}
122
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -0800123static const struct super_operations proc_sops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 .alloc_inode = proc_alloc_inode,
125 .destroy_inode = proc_destroy_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 .drop_inode = generic_delete_inode,
127 .delete_inode = proc_delete_inode,
128 .statfs = simple_statfs,
129 .remount_fs = proc_remount,
130};
131
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700132static void pde_users_dec(struct proc_dir_entry *pde)
133{
134 spin_lock(&pde->pde_unload_lock);
135 pde->pde_users--;
136 if (pde->pde_unload_completion && pde->pde_users == 0)
137 complete(pde->pde_unload_completion);
138 spin_unlock(&pde->pde_unload_lock);
139}
140
141static loff_t proc_reg_llseek(struct file *file, loff_t offset, int whence)
142{
143 struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
144 loff_t rv = -EINVAL;
145 loff_t (*llseek)(struct file *, loff_t, int);
146
147 spin_lock(&pde->pde_unload_lock);
148 /*
149 * remove_proc_entry() is going to delete PDE (as part of module
150 * cleanup sequence). No new callers into module allowed.
151 */
152 if (!pde->proc_fops) {
153 spin_unlock(&pde->pde_unload_lock);
154 return rv;
155 }
156 /*
157 * Bump refcount so that remove_proc_entry will wail for ->llseek to
158 * complete.
159 */
160 pde->pde_users++;
161 /*
162 * Save function pointer under lock, to protect against ->proc_fops
163 * NULL'ifying right after ->pde_unload_lock is dropped.
164 */
165 llseek = pde->proc_fops->llseek;
166 spin_unlock(&pde->pde_unload_lock);
167
168 if (!llseek)
169 llseek = default_llseek;
170 rv = llseek(file, offset, whence);
171
172 pde_users_dec(pde);
173 return rv;
174}
175
176static ssize_t proc_reg_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
177{
178 struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
179 ssize_t rv = -EIO;
180 ssize_t (*read)(struct file *, char __user *, size_t, loff_t *);
181
182 spin_lock(&pde->pde_unload_lock);
183 if (!pde->proc_fops) {
184 spin_unlock(&pde->pde_unload_lock);
185 return rv;
186 }
187 pde->pde_users++;
188 read = pde->proc_fops->read;
189 spin_unlock(&pde->pde_unload_lock);
190
191 if (read)
192 rv = read(file, buf, count, ppos);
193
194 pde_users_dec(pde);
195 return rv;
196}
197
198static ssize_t proc_reg_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
199{
200 struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
201 ssize_t rv = -EIO;
202 ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *);
203
204 spin_lock(&pde->pde_unload_lock);
205 if (!pde->proc_fops) {
206 spin_unlock(&pde->pde_unload_lock);
207 return rv;
208 }
209 pde->pde_users++;
210 write = pde->proc_fops->write;
211 spin_unlock(&pde->pde_unload_lock);
212
213 if (write)
214 rv = write(file, buf, count, ppos);
215
216 pde_users_dec(pde);
217 return rv;
218}
219
220static unsigned int proc_reg_poll(struct file *file, struct poll_table_struct *pts)
221{
222 struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
Alexey Dobriyandd23aae2007-09-11 15:23:55 -0700223 unsigned int rv = DEFAULT_POLLMASK;
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700224 unsigned int (*poll)(struct file *, struct poll_table_struct *);
225
226 spin_lock(&pde->pde_unload_lock);
227 if (!pde->proc_fops) {
228 spin_unlock(&pde->pde_unload_lock);
229 return rv;
230 }
231 pde->pde_users++;
232 poll = pde->proc_fops->poll;
233 spin_unlock(&pde->pde_unload_lock);
234
235 if (poll)
236 rv = poll(file, pts);
237
238 pde_users_dec(pde);
239 return rv;
240}
241
242static long proc_reg_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
243{
244 struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
245 long rv = -ENOTTY;
246 long (*unlocked_ioctl)(struct file *, unsigned int, unsigned long);
247 int (*ioctl)(struct inode *, struct file *, unsigned int, unsigned long);
248
249 spin_lock(&pde->pde_unload_lock);
250 if (!pde->proc_fops) {
251 spin_unlock(&pde->pde_unload_lock);
252 return rv;
253 }
254 pde->pde_users++;
255 unlocked_ioctl = pde->proc_fops->unlocked_ioctl;
256 ioctl = pde->proc_fops->ioctl;
257 spin_unlock(&pde->pde_unload_lock);
258
259 if (unlocked_ioctl) {
260 rv = unlocked_ioctl(file, cmd, arg);
261 if (rv == -ENOIOCTLCMD)
262 rv = -EINVAL;
263 } else if (ioctl) {
264 lock_kernel();
265 rv = ioctl(file->f_path.dentry->d_inode, file, cmd, arg);
266 unlock_kernel();
267 }
268
269 pde_users_dec(pde);
270 return rv;
271}
272
273#ifdef CONFIG_COMPAT
274static long proc_reg_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
275{
276 struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
277 long rv = -ENOTTY;
278 long (*compat_ioctl)(struct file *, unsigned int, unsigned long);
279
280 spin_lock(&pde->pde_unload_lock);
281 if (!pde->proc_fops) {
282 spin_unlock(&pde->pde_unload_lock);
283 return rv;
284 }
285 pde->pde_users++;
286 compat_ioctl = pde->proc_fops->compat_ioctl;
287 spin_unlock(&pde->pde_unload_lock);
288
289 if (compat_ioctl)
290 rv = compat_ioctl(file, cmd, arg);
291
292 pde_users_dec(pde);
293 return rv;
294}
295#endif
296
297static int proc_reg_mmap(struct file *file, struct vm_area_struct *vma)
298{
299 struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
300 int rv = -EIO;
301 int (*mmap)(struct file *, struct vm_area_struct *);
302
303 spin_lock(&pde->pde_unload_lock);
304 if (!pde->proc_fops) {
305 spin_unlock(&pde->pde_unload_lock);
306 return rv;
307 }
308 pde->pde_users++;
309 mmap = pde->proc_fops->mmap;
310 spin_unlock(&pde->pde_unload_lock);
311
312 if (mmap)
313 rv = mmap(file, vma);
314
315 pde_users_dec(pde);
316 return rv;
317}
318
319static int proc_reg_open(struct inode *inode, struct file *file)
320{
321 struct proc_dir_entry *pde = PDE(inode);
322 int rv = 0;
323 int (*open)(struct inode *, struct file *);
324
325 spin_lock(&pde->pde_unload_lock);
326 if (!pde->proc_fops) {
327 spin_unlock(&pde->pde_unload_lock);
328 return rv;
329 }
330 pde->pde_users++;
331 open = pde->proc_fops->open;
332 spin_unlock(&pde->pde_unload_lock);
333
334 if (open)
335 rv = open(inode, file);
336
337 pde_users_dec(pde);
338 return rv;
339}
340
341static int proc_reg_release(struct inode *inode, struct file *file)
342{
343 struct proc_dir_entry *pde = PDE(inode);
344 int rv = 0;
345 int (*release)(struct inode *, struct file *);
346
347 spin_lock(&pde->pde_unload_lock);
348 if (!pde->proc_fops) {
349 spin_unlock(&pde->pde_unload_lock);
350 return rv;
351 }
352 pde->pde_users++;
353 release = pde->proc_fops->release;
354 spin_unlock(&pde->pde_unload_lock);
355
356 if (release)
357 rv = release(inode, file);
358
359 pde_users_dec(pde);
360 return rv;
361}
362
363static const struct file_operations proc_reg_file_ops = {
364 .llseek = proc_reg_llseek,
365 .read = proc_reg_read,
366 .write = proc_reg_write,
367 .poll = proc_reg_poll,
368 .unlocked_ioctl = proc_reg_unlocked_ioctl,
369#ifdef CONFIG_COMPAT
370 .compat_ioctl = proc_reg_compat_ioctl,
371#endif
372 .mmap = proc_reg_mmap,
373 .open = proc_reg_open,
374 .release = proc_reg_release,
375};
376
David Miller778f3dd2007-07-27 22:58:37 -0700377#ifdef CONFIG_COMPAT
378static const struct file_operations proc_reg_file_ops_no_compat = {
379 .llseek = proc_reg_llseek,
380 .read = proc_reg_read,
381 .write = proc_reg_write,
382 .poll = proc_reg_poll,
383 .unlocked_ioctl = proc_reg_unlocked_ioctl,
384 .mmap = proc_reg_mmap,
385 .open = proc_reg_open,
386 .release = proc_reg_release,
387};
388#endif
389
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390struct inode *proc_get_inode(struct super_block *sb, unsigned int ino,
391 struct proc_dir_entry *de)
392{
393 struct inode * inode;
394
Kirill Korotaeve9543652005-10-30 15:02:26 -0800395 if (de != NULL && !try_module_get(de->owner))
396 goto out_mod;
397
David Howellsa1d4aeb2008-02-07 00:15:45 -0800398 inode = iget_locked(sb, ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 if (!inode)
Kirill Korotaeve9543652005-10-30 15:02:26 -0800400 goto out_ino;
David Howellsa1d4aeb2008-02-07 00:15:45 -0800401 if (inode->i_state & I_NEW) {
402 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
403 PROC_I(inode)->fd = 0;
404 PROC_I(inode)->pde = de;
405 if (de) {
406 if (de->mode) {
407 inode->i_mode = de->mode;
408 inode->i_uid = de->uid;
409 inode->i_gid = de->gid;
David Miller778f3dd2007-07-27 22:58:37 -0700410 }
David Howellsa1d4aeb2008-02-07 00:15:45 -0800411 if (de->size)
412 inode->i_size = de->size;
413 if (de->nlink)
414 inode->i_nlink = de->nlink;
415 if (de->proc_iops)
416 inode->i_op = de->proc_iops;
417 if (de->proc_fops) {
418 if (S_ISREG(inode->i_mode)) {
419#ifdef CONFIG_COMPAT
420 if (!de->proc_fops->compat_ioctl)
421 inode->i_fop =
422 &proc_reg_file_ops_no_compat;
423 else
424#endif
425 inode->i_fop = &proc_reg_file_ops;
426 } else {
427 inode->i_fop = de->proc_fops;
428 }
429 }
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700430 }
David Howellsa1d4aeb2008-02-07 00:15:45 -0800431 unlock_new_inode(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 return inode;
434
Kirill Korotaeve9543652005-10-30 15:02:26 -0800435out_ino:
436 if (de != NULL)
437 module_put(de->owner);
438out_mod:
Kirill Korotaeve9543652005-10-30 15:02:26 -0800439 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440}
441
Pavel Emelyanov07543f52007-10-18 23:40:08 -0700442int proc_fill_super(struct super_block *s)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443{
444 struct inode * root_inode;
445
Linus Torvalds92d03282006-07-15 12:20:05 -0700446 s->s_flags |= MS_NODIRATIME | MS_NOSUID | MS_NOEXEC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 s->s_blocksize = 1024;
448 s->s_blocksize_bits = 10;
449 s->s_magic = PROC_SUPER_MAGIC;
450 s->s_op = &proc_sops;
451 s->s_time_gran = 1;
452
Alexey Dobriyan76956502007-05-08 00:25:45 -0700453 de_get(&proc_root);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 root_inode = proc_get_inode(s, PROC_ROOT_INO, &proc_root);
455 if (!root_inode)
456 goto out_no_root;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 root_inode->i_uid = 0;
458 root_inode->i_gid = 0;
459 s->s_root = d_alloc_root(root_inode);
460 if (!s->s_root)
461 goto out_no_root;
462 return 0;
463
464out_no_root:
465 printk("proc_read_super: get root inode failed\n");
466 iput(root_inode);
Alexey Dobriyan76956502007-05-08 00:25:45 -0700467 de_put(&proc_root);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 return -ENOMEM;
469}