2 * linux/fs/proc/inode.c
4 * Copyright (C) 1991, 1992 Linus Torvalds
7 #include <linux/time.h>
8 #include <linux/proc_fs.h>
9 #include <linux/kernel.h>
11 #include <linux/string.h>
12 #include <linux/stat.h>
13 #include <linux/completion.h>
14 #include <linux/poll.h>
15 #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>
21 #include <asm/system.h>
22 #include <asm/uaccess.h>
26 struct proc_dir_entry
*de_get(struct proc_dir_entry
*de
)
28 atomic_inc(&de
->count
);
33 * Decrements the use count and checks for deferred deletion.
35 void de_put(struct proc_dir_entry
*de
)
38 if (!atomic_read(&de
->count
)) {
39 printk("de_put: entry %s already free!\n", de
->name
);
44 if (atomic_dec_and_test(&de
->count
))
50 * Decrement the use count of the proc_dir_entry.
52 static void proc_delete_inode(struct inode
*inode
)
54 struct proc_dir_entry
*de
;
56 truncate_inode_pages(&inode
->i_data
, 0);
58 /* Stop tracking associated processes */
59 put_pid(PROC_I(inode
)->pid
);
61 /* Let go of any associated proc directory entry */
62 de
= PROC_I(inode
)->pde
;
65 module_put(de
->owner
);
71 struct vfsmount
*proc_mnt
;
73 static struct kmem_cache
* proc_inode_cachep
;
75 static struct inode
*proc_alloc_inode(struct super_block
*sb
)
77 struct proc_inode
*ei
;
80 ei
= (struct proc_inode
*)kmem_cache_alloc(proc_inode_cachep
, GFP_KERNEL
);
85 ei
->op
.proc_get_link
= NULL
;
87 inode
= &ei
->vfs_inode
;
88 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= CURRENT_TIME
;
92 static void proc_destroy_inode(struct inode
*inode
)
94 kmem_cache_free(proc_inode_cachep
, PROC_I(inode
));
97 static void init_once(struct kmem_cache
* cachep
, void *foo
)
99 struct proc_inode
*ei
= (struct proc_inode
*) foo
;
101 inode_init_once(&ei
->vfs_inode
);
104 int __init
proc_init_inodecache(void)
106 proc_inode_cachep
= kmem_cache_create("proc_inode_cache",
107 sizeof(struct proc_inode
),
108 0, (SLAB_RECLAIM_ACCOUNT
|
109 SLAB_MEM_SPREAD
|SLAB_PANIC
),
114 static const struct super_operations proc_sops
= {
115 .alloc_inode
= proc_alloc_inode
,
116 .destroy_inode
= proc_destroy_inode
,
117 .drop_inode
= generic_delete_inode
,
118 .delete_inode
= proc_delete_inode
,
119 .statfs
= simple_statfs
,
122 static void __pde_users_dec(struct proc_dir_entry
*pde
)
125 if (pde
->pde_unload_completion
&& pde
->pde_users
== 0)
126 complete(pde
->pde_unload_completion
);
129 static void pde_users_dec(struct proc_dir_entry
*pde
)
131 spin_lock(&pde
->pde_unload_lock
);
132 __pde_users_dec(pde
);
133 spin_unlock(&pde
->pde_unload_lock
);
136 static loff_t
proc_reg_llseek(struct file
*file
, loff_t offset
, int whence
)
138 struct proc_dir_entry
*pde
= PDE(file
->f_path
.dentry
->d_inode
);
140 loff_t (*llseek
)(struct file
*, loff_t
, int);
142 spin_lock(&pde
->pde_unload_lock
);
144 * remove_proc_entry() is going to delete PDE (as part of module
145 * cleanup sequence). No new callers into module allowed.
147 if (!pde
->proc_fops
) {
148 spin_unlock(&pde
->pde_unload_lock
);
152 * Bump refcount so that remove_proc_entry will wail for ->llseek to
157 * Save function pointer under lock, to protect against ->proc_fops
158 * NULL'ifying right after ->pde_unload_lock is dropped.
160 llseek
= pde
->proc_fops
->llseek
;
161 spin_unlock(&pde
->pde_unload_lock
);
164 llseek
= default_llseek
;
165 rv
= llseek(file
, offset
, whence
);
171 static ssize_t
proc_reg_read(struct file
*file
, char __user
*buf
, size_t count
, loff_t
*ppos
)
173 struct proc_dir_entry
*pde
= PDE(file
->f_path
.dentry
->d_inode
);
175 ssize_t (*read
)(struct file
*, char __user
*, size_t, loff_t
*);
177 spin_lock(&pde
->pde_unload_lock
);
178 if (!pde
->proc_fops
) {
179 spin_unlock(&pde
->pde_unload_lock
);
183 read
= pde
->proc_fops
->read
;
184 spin_unlock(&pde
->pde_unload_lock
);
187 rv
= read(file
, buf
, count
, ppos
);
193 static ssize_t
proc_reg_write(struct file
*file
, const char __user
*buf
, size_t count
, loff_t
*ppos
)
195 struct proc_dir_entry
*pde
= PDE(file
->f_path
.dentry
->d_inode
);
197 ssize_t (*write
)(struct file
*, const char __user
*, size_t, loff_t
*);
199 spin_lock(&pde
->pde_unload_lock
);
200 if (!pde
->proc_fops
) {
201 spin_unlock(&pde
->pde_unload_lock
);
205 write
= pde
->proc_fops
->write
;
206 spin_unlock(&pde
->pde_unload_lock
);
209 rv
= write(file
, buf
, count
, ppos
);
215 static unsigned int proc_reg_poll(struct file
*file
, struct poll_table_struct
*pts
)
217 struct proc_dir_entry
*pde
= PDE(file
->f_path
.dentry
->d_inode
);
218 unsigned int rv
= DEFAULT_POLLMASK
;
219 unsigned int (*poll
)(struct file
*, struct poll_table_struct
*);
221 spin_lock(&pde
->pde_unload_lock
);
222 if (!pde
->proc_fops
) {
223 spin_unlock(&pde
->pde_unload_lock
);
227 poll
= pde
->proc_fops
->poll
;
228 spin_unlock(&pde
->pde_unload_lock
);
231 rv
= poll(file
, pts
);
237 static long proc_reg_unlocked_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
239 struct proc_dir_entry
*pde
= PDE(file
->f_path
.dentry
->d_inode
);
241 long (*unlocked_ioctl
)(struct file
*, unsigned int, unsigned long);
242 int (*ioctl
)(struct inode
*, struct file
*, unsigned int, unsigned long);
244 spin_lock(&pde
->pde_unload_lock
);
245 if (!pde
->proc_fops
) {
246 spin_unlock(&pde
->pde_unload_lock
);
250 unlocked_ioctl
= pde
->proc_fops
->unlocked_ioctl
;
251 ioctl
= pde
->proc_fops
->ioctl
;
252 spin_unlock(&pde
->pde_unload_lock
);
254 if (unlocked_ioctl
) {
255 rv
= unlocked_ioctl(file
, cmd
, arg
);
256 if (rv
== -ENOIOCTLCMD
)
260 rv
= ioctl(file
->f_path
.dentry
->d_inode
, file
, cmd
, arg
);
269 static long proc_reg_compat_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
271 struct proc_dir_entry
*pde
= PDE(file
->f_path
.dentry
->d_inode
);
273 long (*compat_ioctl
)(struct file
*, unsigned int, unsigned long);
275 spin_lock(&pde
->pde_unload_lock
);
276 if (!pde
->proc_fops
) {
277 spin_unlock(&pde
->pde_unload_lock
);
281 compat_ioctl
= pde
->proc_fops
->compat_ioctl
;
282 spin_unlock(&pde
->pde_unload_lock
);
285 rv
= compat_ioctl(file
, cmd
, arg
);
292 static int proc_reg_mmap(struct file
*file
, struct vm_area_struct
*vma
)
294 struct proc_dir_entry
*pde
= PDE(file
->f_path
.dentry
->d_inode
);
296 int (*mmap
)(struct file
*, struct vm_area_struct
*);
298 spin_lock(&pde
->pde_unload_lock
);
299 if (!pde
->proc_fops
) {
300 spin_unlock(&pde
->pde_unload_lock
);
304 mmap
= pde
->proc_fops
->mmap
;
305 spin_unlock(&pde
->pde_unload_lock
);
308 rv
= mmap(file
, vma
);
314 static int proc_reg_open(struct inode
*inode
, struct file
*file
)
316 struct proc_dir_entry
*pde
= PDE(inode
);
318 int (*open
)(struct inode
*, struct file
*);
319 int (*release
)(struct inode
*, struct file
*);
320 struct pde_opener
*pdeo
;
323 * What for, you ask? Well, we can have open, rmmod, remove_proc_entry
324 * sequence. ->release won't be called because ->proc_fops will be
325 * cleared. Depending on complexity of ->release, consequences vary.
327 * We can't wait for mercy when close will be done for real, it's
328 * deadlockable: rmmod foo </proc/foo . So, we're going to do ->release
329 * by hand in remove_proc_entry(). For this, save opener's credentials
332 pdeo
= kmalloc(sizeof(struct pde_opener
), GFP_KERNEL
);
336 spin_lock(&pde
->pde_unload_lock
);
337 if (!pde
->proc_fops
) {
338 spin_unlock(&pde
->pde_unload_lock
);
343 open
= pde
->proc_fops
->open
;
344 release
= pde
->proc_fops
->release
;
345 spin_unlock(&pde
->pde_unload_lock
);
348 rv
= open(inode
, file
);
350 spin_lock(&pde
->pde_unload_lock
);
351 if (rv
== 0 && release
) {
352 /* To know what to release. */
355 /* Strictly for "too late" ->release in proc_reg_release(). */
356 pdeo
->release
= release
;
357 list_add(&pdeo
->lh
, &pde
->pde_openers
);
360 __pde_users_dec(pde
);
361 spin_unlock(&pde
->pde_unload_lock
);
365 static struct pde_opener
*find_pde_opener(struct proc_dir_entry
*pde
,
366 struct inode
*inode
, struct file
*file
)
368 struct pde_opener
*pdeo
;
370 list_for_each_entry(pdeo
, &pde
->pde_openers
, lh
) {
371 if (pdeo
->inode
== inode
&& pdeo
->file
== file
)
377 static int proc_reg_release(struct inode
*inode
, struct file
*file
)
379 struct proc_dir_entry
*pde
= PDE(inode
);
381 int (*release
)(struct inode
*, struct file
*);
382 struct pde_opener
*pdeo
;
384 spin_lock(&pde
->pde_unload_lock
);
385 pdeo
= find_pde_opener(pde
, inode
, file
);
386 if (!pde
->proc_fops
) {
388 * Can't simply exit, __fput() will think that everything is OK,
389 * and move on to freeing struct file. remove_proc_entry() will
390 * find slacker in opener's list and will try to do non-trivial
391 * things with struct file. Therefore, remove opener from list.
393 * But if opener is removed from list, who will ->release it?
397 spin_unlock(&pde
->pde_unload_lock
);
398 rv
= pdeo
->release(inode
, file
);
401 spin_unlock(&pde
->pde_unload_lock
);
405 release
= pde
->proc_fops
->release
;
410 spin_unlock(&pde
->pde_unload_lock
);
413 rv
= release(inode
, file
);
419 static const struct file_operations proc_reg_file_ops
= {
420 .llseek
= proc_reg_llseek
,
421 .read
= proc_reg_read
,
422 .write
= proc_reg_write
,
423 .poll
= proc_reg_poll
,
424 .unlocked_ioctl
= proc_reg_unlocked_ioctl
,
426 .compat_ioctl
= proc_reg_compat_ioctl
,
428 .mmap
= proc_reg_mmap
,
429 .open
= proc_reg_open
,
430 .release
= proc_reg_release
,
434 static const struct file_operations proc_reg_file_ops_no_compat
= {
435 .llseek
= proc_reg_llseek
,
436 .read
= proc_reg_read
,
437 .write
= proc_reg_write
,
438 .poll
= proc_reg_poll
,
439 .unlocked_ioctl
= proc_reg_unlocked_ioctl
,
440 .mmap
= proc_reg_mmap
,
441 .open
= proc_reg_open
,
442 .release
= proc_reg_release
,
446 struct inode
*proc_get_inode(struct super_block
*sb
, unsigned int ino
,
447 struct proc_dir_entry
*de
)
449 struct inode
* inode
;
451 if (!try_module_get(de
->owner
))
454 inode
= iget_locked(sb
, ino
);
457 if (inode
->i_state
& I_NEW
) {
458 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= CURRENT_TIME
;
459 PROC_I(inode
)->fd
= 0;
460 PROC_I(inode
)->pde
= de
;
463 inode
->i_mode
= de
->mode
;
464 inode
->i_uid
= de
->uid
;
465 inode
->i_gid
= de
->gid
;
468 inode
->i_size
= de
->size
;
470 inode
->i_nlink
= de
->nlink
;
472 inode
->i_op
= de
->proc_iops
;
474 if (S_ISREG(inode
->i_mode
)) {
476 if (!de
->proc_fops
->compat_ioctl
)
478 &proc_reg_file_ops_no_compat
;
481 inode
->i_fop
= &proc_reg_file_ops
;
483 inode
->i_fop
= de
->proc_fops
;
486 unlock_new_inode(inode
);
488 module_put(de
->owner
);
492 module_put(de
->owner
);
497 int proc_fill_super(struct super_block
*s
)
499 struct inode
* root_inode
;
501 s
->s_flags
|= MS_NODIRATIME
| MS_NOSUID
| MS_NOEXEC
;
502 s
->s_blocksize
= 1024;
503 s
->s_blocksize_bits
= 10;
504 s
->s_magic
= PROC_SUPER_MAGIC
;
505 s
->s_op
= &proc_sops
;
509 root_inode
= proc_get_inode(s
, PROC_ROOT_INO
, &proc_root
);
512 root_inode
->i_uid
= 0;
513 root_inode
->i_gid
= 0;
514 s
->s_root
= d_alloc_root(root_inode
);
520 printk("proc_read_super: get root inode failed\n");