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/sysctl.h>
20 #include <linux/slab.h>
22 #include <asm/system.h>
23 #include <asm/uaccess.h>
27 static void proc_evict_inode(struct inode
*inode
)
29 struct proc_dir_entry
*de
;
30 struct ctl_table_header
*head
;
31 const struct proc_ns_operations
*ns_ops
;
33 truncate_inode_pages(&inode
->i_data
, 0);
36 /* Stop tracking associated processes */
37 put_pid(PROC_I(inode
)->pid
);
39 /* Let go of any associated proc directory entry */
40 de
= PROC_I(inode
)->pde
;
43 head
= PROC_I(inode
)->sysctl
;
45 rcu_assign_pointer(PROC_I(inode
)->sysctl
, NULL
);
46 sysctl_head_put(head
);
48 /* Release any associated namespace */
49 ns_ops
= PROC_I(inode
)->ns_ops
;
50 if (ns_ops
&& ns_ops
->put
)
51 ns_ops
->put(PROC_I(inode
)->ns
);
54 static struct kmem_cache
* proc_inode_cachep
;
56 static struct inode
*proc_alloc_inode(struct super_block
*sb
)
58 struct proc_inode
*ei
;
61 ei
= (struct proc_inode
*)kmem_cache_alloc(proc_inode_cachep
, GFP_KERNEL
);
66 ei
->op
.proc_get_link
= NULL
;
69 ei
->sysctl_entry
= NULL
;
72 inode
= &ei
->vfs_inode
;
73 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= CURRENT_TIME
;
77 static void proc_i_callback(struct rcu_head
*head
)
79 struct inode
*inode
= container_of(head
, struct inode
, i_rcu
);
80 kmem_cache_free(proc_inode_cachep
, PROC_I(inode
));
83 static void proc_destroy_inode(struct inode
*inode
)
85 call_rcu(&inode
->i_rcu
, proc_i_callback
);
88 static void init_once(void *foo
)
90 struct proc_inode
*ei
= (struct proc_inode
*) foo
;
92 inode_init_once(&ei
->vfs_inode
);
95 void __init
proc_init_inodecache(void)
97 proc_inode_cachep
= kmem_cache_create("proc_inode_cache",
98 sizeof(struct proc_inode
),
99 0, (SLAB_RECLAIM_ACCOUNT
|
100 SLAB_MEM_SPREAD
|SLAB_PANIC
),
104 static const struct super_operations proc_sops
= {
105 .alloc_inode
= proc_alloc_inode
,
106 .destroy_inode
= proc_destroy_inode
,
107 .drop_inode
= generic_delete_inode
,
108 .evict_inode
= proc_evict_inode
,
109 .statfs
= simple_statfs
,
112 static void __pde_users_dec(struct proc_dir_entry
*pde
)
115 if (pde
->pde_unload_completion
&& pde
->pde_users
== 0)
116 complete(pde
->pde_unload_completion
);
119 void pde_users_dec(struct proc_dir_entry
*pde
)
121 spin_lock(&pde
->pde_unload_lock
);
122 __pde_users_dec(pde
);
123 spin_unlock(&pde
->pde_unload_lock
);
126 static loff_t
proc_reg_llseek(struct file
*file
, loff_t offset
, int whence
)
128 struct proc_dir_entry
*pde
= PDE(file
->f_path
.dentry
->d_inode
);
130 loff_t (*llseek
)(struct file
*, loff_t
, int);
132 spin_lock(&pde
->pde_unload_lock
);
134 * remove_proc_entry() is going to delete PDE (as part of module
135 * cleanup sequence). No new callers into module allowed.
137 if (!pde
->proc_fops
) {
138 spin_unlock(&pde
->pde_unload_lock
);
142 * Bump refcount so that remove_proc_entry will wail for ->llseek to
147 * Save function pointer under lock, to protect against ->proc_fops
148 * NULL'ifying right after ->pde_unload_lock is dropped.
150 llseek
= pde
->proc_fops
->llseek
;
151 spin_unlock(&pde
->pde_unload_lock
);
154 llseek
= default_llseek
;
155 rv
= llseek(file
, offset
, whence
);
161 static ssize_t
proc_reg_read(struct file
*file
, char __user
*buf
, size_t count
, loff_t
*ppos
)
163 struct proc_dir_entry
*pde
= PDE(file
->f_path
.dentry
->d_inode
);
165 ssize_t (*read
)(struct file
*, char __user
*, size_t, loff_t
*);
167 spin_lock(&pde
->pde_unload_lock
);
168 if (!pde
->proc_fops
) {
169 spin_unlock(&pde
->pde_unload_lock
);
173 read
= pde
->proc_fops
->read
;
174 spin_unlock(&pde
->pde_unload_lock
);
177 rv
= read(file
, buf
, count
, ppos
);
183 static ssize_t
proc_reg_write(struct file
*file
, const char __user
*buf
, size_t count
, loff_t
*ppos
)
185 struct proc_dir_entry
*pde
= PDE(file
->f_path
.dentry
->d_inode
);
187 ssize_t (*write
)(struct file
*, const char __user
*, size_t, loff_t
*);
189 spin_lock(&pde
->pde_unload_lock
);
190 if (!pde
->proc_fops
) {
191 spin_unlock(&pde
->pde_unload_lock
);
195 write
= pde
->proc_fops
->write
;
196 spin_unlock(&pde
->pde_unload_lock
);
199 rv
= write(file
, buf
, count
, ppos
);
205 static unsigned int proc_reg_poll(struct file
*file
, struct poll_table_struct
*pts
)
207 struct proc_dir_entry
*pde
= PDE(file
->f_path
.dentry
->d_inode
);
208 unsigned int rv
= DEFAULT_POLLMASK
;
209 unsigned int (*poll
)(struct file
*, struct poll_table_struct
*);
211 spin_lock(&pde
->pde_unload_lock
);
212 if (!pde
->proc_fops
) {
213 spin_unlock(&pde
->pde_unload_lock
);
217 poll
= pde
->proc_fops
->poll
;
218 spin_unlock(&pde
->pde_unload_lock
);
221 rv
= poll(file
, pts
);
227 static long proc_reg_unlocked_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
229 struct proc_dir_entry
*pde
= PDE(file
->f_path
.dentry
->d_inode
);
231 long (*ioctl
)(struct file
*, unsigned int, unsigned long);
233 spin_lock(&pde
->pde_unload_lock
);
234 if (!pde
->proc_fops
) {
235 spin_unlock(&pde
->pde_unload_lock
);
239 ioctl
= pde
->proc_fops
->unlocked_ioctl
;
240 spin_unlock(&pde
->pde_unload_lock
);
243 rv
= ioctl(file
, cmd
, arg
);
250 static long proc_reg_compat_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
252 struct proc_dir_entry
*pde
= PDE(file
->f_path
.dentry
->d_inode
);
254 long (*compat_ioctl
)(struct file
*, unsigned int, unsigned long);
256 spin_lock(&pde
->pde_unload_lock
);
257 if (!pde
->proc_fops
) {
258 spin_unlock(&pde
->pde_unload_lock
);
262 compat_ioctl
= pde
->proc_fops
->compat_ioctl
;
263 spin_unlock(&pde
->pde_unload_lock
);
266 rv
= compat_ioctl(file
, cmd
, arg
);
273 static int proc_reg_mmap(struct file
*file
, struct vm_area_struct
*vma
)
275 struct proc_dir_entry
*pde
= PDE(file
->f_path
.dentry
->d_inode
);
277 int (*mmap
)(struct file
*, struct vm_area_struct
*);
279 spin_lock(&pde
->pde_unload_lock
);
280 if (!pde
->proc_fops
) {
281 spin_unlock(&pde
->pde_unload_lock
);
285 mmap
= pde
->proc_fops
->mmap
;
286 spin_unlock(&pde
->pde_unload_lock
);
289 rv
= mmap(file
, vma
);
295 static int proc_reg_open(struct inode
*inode
, struct file
*file
)
297 struct proc_dir_entry
*pde
= PDE(inode
);
299 int (*open
)(struct inode
*, struct file
*);
300 int (*release
)(struct inode
*, struct file
*);
301 struct pde_opener
*pdeo
;
304 * What for, you ask? Well, we can have open, rmmod, remove_proc_entry
305 * sequence. ->release won't be called because ->proc_fops will be
306 * cleared. Depending on complexity of ->release, consequences vary.
308 * We can't wait for mercy when close will be done for real, it's
309 * deadlockable: rmmod foo </proc/foo . So, we're going to do ->release
310 * by hand in remove_proc_entry(). For this, save opener's credentials
313 pdeo
= kmalloc(sizeof(struct pde_opener
), GFP_KERNEL
);
317 spin_lock(&pde
->pde_unload_lock
);
318 if (!pde
->proc_fops
) {
319 spin_unlock(&pde
->pde_unload_lock
);
324 open
= pde
->proc_fops
->open
;
325 release
= pde
->proc_fops
->release
;
326 spin_unlock(&pde
->pde_unload_lock
);
329 rv
= open(inode
, file
);
331 spin_lock(&pde
->pde_unload_lock
);
332 if (rv
== 0 && release
) {
333 /* To know what to release. */
336 /* Strictly for "too late" ->release in proc_reg_release(). */
337 pdeo
->release
= release
;
338 list_add(&pdeo
->lh
, &pde
->pde_openers
);
341 __pde_users_dec(pde
);
342 spin_unlock(&pde
->pde_unload_lock
);
346 static struct pde_opener
*find_pde_opener(struct proc_dir_entry
*pde
,
347 struct inode
*inode
, struct file
*file
)
349 struct pde_opener
*pdeo
;
351 list_for_each_entry(pdeo
, &pde
->pde_openers
, lh
) {
352 if (pdeo
->inode
== inode
&& pdeo
->file
== file
)
358 static int proc_reg_release(struct inode
*inode
, struct file
*file
)
360 struct proc_dir_entry
*pde
= PDE(inode
);
362 int (*release
)(struct inode
*, struct file
*);
363 struct pde_opener
*pdeo
;
365 spin_lock(&pde
->pde_unload_lock
);
366 pdeo
= find_pde_opener(pde
, inode
, file
);
367 if (!pde
->proc_fops
) {
369 * Can't simply exit, __fput() will think that everything is OK,
370 * and move on to freeing struct file. remove_proc_entry() will
371 * find slacker in opener's list and will try to do non-trivial
372 * things with struct file. Therefore, remove opener from list.
374 * But if opener is removed from list, who will ->release it?
378 spin_unlock(&pde
->pde_unload_lock
);
379 rv
= pdeo
->release(inode
, file
);
382 spin_unlock(&pde
->pde_unload_lock
);
386 release
= pde
->proc_fops
->release
;
391 spin_unlock(&pde
->pde_unload_lock
);
394 rv
= release(inode
, file
);
400 static const struct file_operations proc_reg_file_ops
= {
401 .llseek
= proc_reg_llseek
,
402 .read
= proc_reg_read
,
403 .write
= proc_reg_write
,
404 .poll
= proc_reg_poll
,
405 .unlocked_ioctl
= proc_reg_unlocked_ioctl
,
407 .compat_ioctl
= proc_reg_compat_ioctl
,
409 .mmap
= proc_reg_mmap
,
410 .open
= proc_reg_open
,
411 .release
= proc_reg_release
,
415 static const struct file_operations proc_reg_file_ops_no_compat
= {
416 .llseek
= proc_reg_llseek
,
417 .read
= proc_reg_read
,
418 .write
= proc_reg_write
,
419 .poll
= proc_reg_poll
,
420 .unlocked_ioctl
= proc_reg_unlocked_ioctl
,
421 .mmap
= proc_reg_mmap
,
422 .open
= proc_reg_open
,
423 .release
= proc_reg_release
,
427 struct inode
*proc_get_inode(struct super_block
*sb
, struct proc_dir_entry
*de
)
429 struct inode
* inode
;
431 inode
= iget_locked(sb
, de
->low_ino
);
434 if (inode
->i_state
& I_NEW
) {
435 inode
->i_mtime
= inode
->i_atime
= inode
->i_ctime
= CURRENT_TIME
;
436 PROC_I(inode
)->fd
= 0;
437 PROC_I(inode
)->pde
= de
;
440 inode
->i_mode
= de
->mode
;
441 inode
->i_uid
= de
->uid
;
442 inode
->i_gid
= de
->gid
;
445 inode
->i_size
= de
->size
;
447 set_nlink(inode
, de
->nlink
);
449 inode
->i_op
= de
->proc_iops
;
451 if (S_ISREG(inode
->i_mode
)) {
453 if (!de
->proc_fops
->compat_ioctl
)
455 &proc_reg_file_ops_no_compat
;
458 inode
->i_fop
= &proc_reg_file_ops
;
460 inode
->i_fop
= de
->proc_fops
;
463 unlock_new_inode(inode
);
469 int proc_fill_super(struct super_block
*s
)
471 struct inode
* root_inode
;
473 s
->s_flags
|= MS_NODIRATIME
| MS_NOSUID
| MS_NOEXEC
;
474 s
->s_blocksize
= 1024;
475 s
->s_blocksize_bits
= 10;
476 s
->s_magic
= PROC_SUPER_MAGIC
;
477 s
->s_op
= &proc_sops
;
481 root_inode
= proc_get_inode(s
, &proc_root
);
484 root_inode
->i_uid
= 0;
485 root_inode
->i_gid
= 0;
486 s
->s_root
= d_alloc_root(root_inode
);
492 printk("proc_read_super: get root inode failed\n");