blob: d78ade305541d84a0a7b7682f203cd649c1e5a6a [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>
Al Viro90434762008-07-15 08:54:06 -040020#include <linux/sysctl.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021
22#include <asm/system.h>
23#include <asm/uaccess.h>
24
Adrian Bunkfee781e2006-01-08 01:04:16 -080025#include "internal.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070026
Alexey Dobriyan76956502007-05-08 00:25:45 -070027struct proc_dir_entry *de_get(struct proc_dir_entry *de)
Linus Torvalds1da177e2005-04-16 15:20:36 -070028{
Alexey Dobriyan5e971dc2008-04-29 01:01:41 -070029 atomic_inc(&de->count);
Linus Torvalds1da177e2005-04-16 15:20:36 -070030 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{
Alexey Dobriyan5e971dc2008-04-29 01:01:41 -070038 if (!atomic_read(&de->count)) {
39 printk("de_put: entry %s already free!\n", de->name);
Alexey Dobriyan5e971dc2008-04-29 01:01:41 -070040 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -070041 }
Alexey Dobriyan5e971dc2008-04-29 01:01:41 -070042
43 if (atomic_dec_and_test(&de->count))
44 free_proc_entry(de);
Linus Torvalds1da177e2005-04-16 15:20:36 -070045}
46
47/*
48 * Decrement the use count of the proc_dir_entry.
49 */
50static void proc_delete_inode(struct inode *inode)
51{
52 struct proc_dir_entry *de;
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
Mark Fashehfef26652005-09-09 13:01:31 -070054 truncate_inode_pages(&inode->i_data, 0);
55
Eric W. Biederman99f89552006-06-26 00:25:55 -070056 /* Stop tracking associated processes */
Eric W. Biederman13b41b02006-06-26 00:25:56 -070057 put_pid(PROC_I(inode)->pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -070058
59 /* Let go of any associated proc directory entry */
60 de = PROC_I(inode)->pde;
Alexey Dobriyan99b76232009-03-25 22:48:06 +030061 if (de)
Linus Torvalds1da177e2005-04-16 15:20:36 -070062 de_put(de);
Al Viro90434762008-07-15 08:54:06 -040063 if (PROC_I(inode)->sysctl)
64 sysctl_head_put(PROC_I(inode)->sysctl);
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 clear_inode(inode);
66}
67
68struct vfsmount *proc_mnt;
69
Christoph Lametere18b8902006-12-06 20:33:20 -080070static struct kmem_cache * proc_inode_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -070071
72static struct inode *proc_alloc_inode(struct super_block *sb)
73{
74 struct proc_inode *ei;
75 struct inode *inode;
76
Christoph Lametere94b1762006-12-06 20:33:17 -080077 ei = (struct proc_inode *)kmem_cache_alloc(proc_inode_cachep, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070078 if (!ei)
79 return NULL;
Eric W. Biederman13b41b02006-06-26 00:25:56 -070080 ei->pid = NULL;
Eric W. Biedermanaed7a6c2006-06-26 00:25:44 -070081 ei->fd = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070082 ei->op.proc_get_link = NULL;
83 ei->pde = NULL;
Al Viro90434762008-07-15 08:54:06 -040084 ei->sysctl = NULL;
85 ei->sysctl_entry = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 inode = &ei->vfs_inode;
87 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
88 return inode;
89}
90
91static void proc_destroy_inode(struct inode *inode)
92{
93 kmem_cache_free(proc_inode_cachep, PROC_I(inode));
94}
95
Alexey Dobriyan51cc5062008-07-25 19:45:34 -070096static void init_once(void *foo)
Linus Torvalds1da177e2005-04-16 15:20:36 -070097{
98 struct proc_inode *ei = (struct proc_inode *) foo;
99
Christoph Lametera35afb82007-05-16 22:10:57 -0700100 inode_init_once(&ei->vfs_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101}
Paul Mundt20c2df82007-07-20 10:11:58 +0900102
Alexey Dobriyan5bcd7ff2008-10-17 03:43:55 +0400103void __init proc_init_inodecache(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104{
105 proc_inode_cachep = kmem_cache_create("proc_inode_cache",
106 sizeof(struct proc_inode),
Paul Jacksonfffb60f2006-03-24 03:16:06 -0800107 0, (SLAB_RECLAIM_ACCOUNT|
Alexey Dobriyan040b5c62007-10-16 23:26:10 -0700108 SLAB_MEM_SPREAD|SLAB_PANIC),
Paul Mundt20c2df82007-07-20 10:11:58 +0900109 init_once);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110}
111
Josef 'Jeff' Sipekee9b6d62007-02-12 00:55:41 -0800112static const struct super_operations proc_sops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 .alloc_inode = proc_alloc_inode,
114 .destroy_inode = proc_destroy_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 .drop_inode = generic_delete_inode,
116 .delete_inode = proc_delete_inode,
117 .statfs = simple_statfs,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118};
119
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700120static void __pde_users_dec(struct proc_dir_entry *pde)
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700121{
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700122 pde->pde_users--;
123 if (pde->pde_unload_completion && pde->pde_users == 0)
124 complete(pde->pde_unload_completion);
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700125}
126
Alexey Dobriyan3dec7f52009-02-20 17:04:33 +0300127void pde_users_dec(struct proc_dir_entry *pde)
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700128{
129 spin_lock(&pde->pde_unload_lock);
130 __pde_users_dec(pde);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700131 spin_unlock(&pde->pde_unload_lock);
132}
133
134static loff_t proc_reg_llseek(struct file *file, loff_t offset, int whence)
135{
136 struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
137 loff_t rv = -EINVAL;
138 loff_t (*llseek)(struct file *, loff_t, int);
139
140 spin_lock(&pde->pde_unload_lock);
141 /*
142 * remove_proc_entry() is going to delete PDE (as part of module
143 * cleanup sequence). No new callers into module allowed.
144 */
145 if (!pde->proc_fops) {
146 spin_unlock(&pde->pde_unload_lock);
147 return rv;
148 }
149 /*
150 * Bump refcount so that remove_proc_entry will wail for ->llseek to
151 * complete.
152 */
153 pde->pde_users++;
154 /*
155 * Save function pointer under lock, to protect against ->proc_fops
156 * NULL'ifying right after ->pde_unload_lock is dropped.
157 */
158 llseek = pde->proc_fops->llseek;
159 spin_unlock(&pde->pde_unload_lock);
160
161 if (!llseek)
162 llseek = default_llseek;
163 rv = llseek(file, offset, whence);
164
165 pde_users_dec(pde);
166 return rv;
167}
168
169static ssize_t proc_reg_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
170{
171 struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
172 ssize_t rv = -EIO;
173 ssize_t (*read)(struct file *, char __user *, size_t, loff_t *);
174
175 spin_lock(&pde->pde_unload_lock);
176 if (!pde->proc_fops) {
177 spin_unlock(&pde->pde_unload_lock);
178 return rv;
179 }
180 pde->pde_users++;
181 read = pde->proc_fops->read;
182 spin_unlock(&pde->pde_unload_lock);
183
184 if (read)
185 rv = read(file, buf, count, ppos);
186
187 pde_users_dec(pde);
188 return rv;
189}
190
191static ssize_t proc_reg_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
192{
193 struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
194 ssize_t rv = -EIO;
195 ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *);
196
197 spin_lock(&pde->pde_unload_lock);
198 if (!pde->proc_fops) {
199 spin_unlock(&pde->pde_unload_lock);
200 return rv;
201 }
202 pde->pde_users++;
203 write = pde->proc_fops->write;
204 spin_unlock(&pde->pde_unload_lock);
205
206 if (write)
207 rv = write(file, buf, count, ppos);
208
209 pde_users_dec(pde);
210 return rv;
211}
212
213static unsigned int proc_reg_poll(struct file *file, struct poll_table_struct *pts)
214{
215 struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
Alexey Dobriyandd23aae2007-09-11 15:23:55 -0700216 unsigned int rv = DEFAULT_POLLMASK;
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700217 unsigned int (*poll)(struct file *, struct poll_table_struct *);
218
219 spin_lock(&pde->pde_unload_lock);
220 if (!pde->proc_fops) {
221 spin_unlock(&pde->pde_unload_lock);
222 return rv;
223 }
224 pde->pde_users++;
225 poll = pde->proc_fops->poll;
226 spin_unlock(&pde->pde_unload_lock);
227
228 if (poll)
229 rv = poll(file, pts);
230
231 pde_users_dec(pde);
232 return rv;
233}
234
235static long proc_reg_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
236{
237 struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
238 long rv = -ENOTTY;
239 long (*unlocked_ioctl)(struct file *, unsigned int, unsigned long);
240 int (*ioctl)(struct inode *, struct file *, unsigned int, unsigned long);
241
242 spin_lock(&pde->pde_unload_lock);
243 if (!pde->proc_fops) {
244 spin_unlock(&pde->pde_unload_lock);
245 return rv;
246 }
247 pde->pde_users++;
248 unlocked_ioctl = pde->proc_fops->unlocked_ioctl;
249 ioctl = pde->proc_fops->ioctl;
250 spin_unlock(&pde->pde_unload_lock);
251
252 if (unlocked_ioctl) {
253 rv = unlocked_ioctl(file, cmd, arg);
254 if (rv == -ENOIOCTLCMD)
255 rv = -EINVAL;
256 } else if (ioctl) {
257 lock_kernel();
258 rv = ioctl(file->f_path.dentry->d_inode, file, cmd, arg);
259 unlock_kernel();
260 }
261
262 pde_users_dec(pde);
263 return rv;
264}
265
266#ifdef CONFIG_COMPAT
267static long proc_reg_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
268{
269 struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
270 long rv = -ENOTTY;
271 long (*compat_ioctl)(struct file *, unsigned int, unsigned long);
272
273 spin_lock(&pde->pde_unload_lock);
274 if (!pde->proc_fops) {
275 spin_unlock(&pde->pde_unload_lock);
276 return rv;
277 }
278 pde->pde_users++;
279 compat_ioctl = pde->proc_fops->compat_ioctl;
280 spin_unlock(&pde->pde_unload_lock);
281
282 if (compat_ioctl)
283 rv = compat_ioctl(file, cmd, arg);
284
285 pde_users_dec(pde);
286 return rv;
287}
288#endif
289
290static int proc_reg_mmap(struct file *file, struct vm_area_struct *vma)
291{
292 struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
293 int rv = -EIO;
294 int (*mmap)(struct file *, struct vm_area_struct *);
295
296 spin_lock(&pde->pde_unload_lock);
297 if (!pde->proc_fops) {
298 spin_unlock(&pde->pde_unload_lock);
299 return rv;
300 }
301 pde->pde_users++;
302 mmap = pde->proc_fops->mmap;
303 spin_unlock(&pde->pde_unload_lock);
304
305 if (mmap)
306 rv = mmap(file, vma);
307
308 pde_users_dec(pde);
309 return rv;
310}
311
312static int proc_reg_open(struct inode *inode, struct file *file)
313{
314 struct proc_dir_entry *pde = PDE(inode);
315 int rv = 0;
316 int (*open)(struct inode *, struct file *);
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700317 int (*release)(struct inode *, struct file *);
318 struct pde_opener *pdeo;
319
320 /*
321 * What for, you ask? Well, we can have open, rmmod, remove_proc_entry
322 * sequence. ->release won't be called because ->proc_fops will be
323 * cleared. Depending on complexity of ->release, consequences vary.
324 *
325 * We can't wait for mercy when close will be done for real, it's
326 * deadlockable: rmmod foo </proc/foo . So, we're going to do ->release
327 * by hand in remove_proc_entry(). For this, save opener's credentials
328 * for later.
329 */
330 pdeo = kmalloc(sizeof(struct pde_opener), GFP_KERNEL);
331 if (!pdeo)
332 return -ENOMEM;
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700333
334 spin_lock(&pde->pde_unload_lock);
335 if (!pde->proc_fops) {
336 spin_unlock(&pde->pde_unload_lock);
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700337 kfree(pdeo);
Alexey Dobriyan300b9942008-10-03 00:18:52 +0400338 return -EINVAL;
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700339 }
340 pde->pde_users++;
341 open = pde->proc_fops->open;
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700342 release = pde->proc_fops->release;
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700343 spin_unlock(&pde->pde_unload_lock);
344
345 if (open)
346 rv = open(inode, file);
347
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700348 spin_lock(&pde->pde_unload_lock);
349 if (rv == 0 && release) {
350 /* To know what to release. */
351 pdeo->inode = inode;
352 pdeo->file = file;
353 /* Strictly for "too late" ->release in proc_reg_release(). */
354 pdeo->release = release;
355 list_add(&pdeo->lh, &pde->pde_openers);
356 } else
357 kfree(pdeo);
358 __pde_users_dec(pde);
359 spin_unlock(&pde->pde_unload_lock);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700360 return rv;
361}
362
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700363static struct pde_opener *find_pde_opener(struct proc_dir_entry *pde,
364 struct inode *inode, struct file *file)
365{
366 struct pde_opener *pdeo;
367
368 list_for_each_entry(pdeo, &pde->pde_openers, lh) {
369 if (pdeo->inode == inode && pdeo->file == file)
370 return pdeo;
371 }
372 return NULL;
373}
374
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700375static int proc_reg_release(struct inode *inode, struct file *file)
376{
377 struct proc_dir_entry *pde = PDE(inode);
378 int rv = 0;
379 int (*release)(struct inode *, struct file *);
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700380 struct pde_opener *pdeo;
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700381
382 spin_lock(&pde->pde_unload_lock);
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700383 pdeo = find_pde_opener(pde, inode, file);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700384 if (!pde->proc_fops) {
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700385 /*
386 * Can't simply exit, __fput() will think that everything is OK,
387 * and move on to freeing struct file. remove_proc_entry() will
388 * find slacker in opener's list and will try to do non-trivial
389 * things with struct file. Therefore, remove opener from list.
390 *
391 * But if opener is removed from list, who will ->release it?
392 */
393 if (pdeo) {
394 list_del(&pdeo->lh);
395 spin_unlock(&pde->pde_unload_lock);
396 rv = pdeo->release(inode, file);
397 kfree(pdeo);
398 } else
399 spin_unlock(&pde->pde_unload_lock);
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700400 return rv;
401 }
402 pde->pde_users++;
403 release = pde->proc_fops->release;
Alexey Dobriyan881adb82008-07-25 01:48:29 -0700404 if (pdeo) {
405 list_del(&pdeo->lh);
406 kfree(pdeo);
407 }
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700408 spin_unlock(&pde->pde_unload_lock);
409
410 if (release)
411 rv = release(inode, file);
412
413 pde_users_dec(pde);
414 return rv;
415}
416
417static const struct file_operations proc_reg_file_ops = {
418 .llseek = proc_reg_llseek,
419 .read = proc_reg_read,
420 .write = proc_reg_write,
421 .poll = proc_reg_poll,
422 .unlocked_ioctl = proc_reg_unlocked_ioctl,
423#ifdef CONFIG_COMPAT
424 .compat_ioctl = proc_reg_compat_ioctl,
425#endif
426 .mmap = proc_reg_mmap,
427 .open = proc_reg_open,
428 .release = proc_reg_release,
429};
430
David Miller778f3dd2007-07-27 22:58:37 -0700431#ifdef CONFIG_COMPAT
432static const struct file_operations proc_reg_file_ops_no_compat = {
433 .llseek = proc_reg_llseek,
434 .read = proc_reg_read,
435 .write = proc_reg_write,
436 .poll = proc_reg_poll,
437 .unlocked_ioctl = proc_reg_unlocked_ioctl,
438 .mmap = proc_reg_mmap,
439 .open = proc_reg_open,
440 .release = proc_reg_release,
441};
442#endif
443
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444struct inode *proc_get_inode(struct super_block *sb, unsigned int ino,
445 struct proc_dir_entry *de)
446{
447 struct inode * inode;
448
David Howellsa1d4aeb2008-02-07 00:15:45 -0800449 inode = iget_locked(sb, ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 if (!inode)
Alexey Dobriyan99b76232009-03-25 22:48:06 +0300451 return NULL;
David Howellsa1d4aeb2008-02-07 00:15:45 -0800452 if (inode->i_state & I_NEW) {
453 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
454 PROC_I(inode)->fd = 0;
455 PROC_I(inode)->pde = de;
Alexey Dobriyan5e971dc2008-04-29 01:01:41 -0700456
457 if (de->mode) {
458 inode->i_mode = de->mode;
459 inode->i_uid = de->uid;
460 inode->i_gid = de->gid;
461 }
462 if (de->size)
463 inode->i_size = de->size;
464 if (de->nlink)
465 inode->i_nlink = de->nlink;
466 if (de->proc_iops)
467 inode->i_op = de->proc_iops;
468 if (de->proc_fops) {
469 if (S_ISREG(inode->i_mode)) {
David Howellsa1d4aeb2008-02-07 00:15:45 -0800470#ifdef CONFIG_COMPAT
Alexey Dobriyan5e971dc2008-04-29 01:01:41 -0700471 if (!de->proc_fops->compat_ioctl)
472 inode->i_fop =
473 &proc_reg_file_ops_no_compat;
474 else
David Howellsa1d4aeb2008-02-07 00:15:45 -0800475#endif
Alexey Dobriyan5e971dc2008-04-29 01:01:41 -0700476 inode->i_fop = &proc_reg_file_ops;
477 } else {
478 inode->i_fop = de->proc_fops;
David Howellsa1d4aeb2008-02-07 00:15:45 -0800479 }
Alexey Dobriyan786d7e12007-07-15 23:39:00 -0700480 }
David Howellsa1d4aeb2008-02-07 00:15:45 -0800481 unlock_new_inode(inode);
Alexey Dobriyan99b76232009-03-25 22:48:06 +0300482 } else
Krzysztof Sachanowiczcac71122009-02-23 22:21:55 +0100483 de_put(de);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 return inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485}
486
Pavel Emelyanov07543f52007-10-18 23:40:08 -0700487int proc_fill_super(struct super_block *s)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488{
489 struct inode * root_inode;
490
Linus Torvalds92d03282006-07-15 12:20:05 -0700491 s->s_flags |= MS_NODIRATIME | MS_NOSUID | MS_NOEXEC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 s->s_blocksize = 1024;
493 s->s_blocksize_bits = 10;
494 s->s_magic = PROC_SUPER_MAGIC;
495 s->s_op = &proc_sops;
496 s->s_time_gran = 1;
497
Alexey Dobriyan76956502007-05-08 00:25:45 -0700498 de_get(&proc_root);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 root_inode = proc_get_inode(s, PROC_ROOT_INO, &proc_root);
500 if (!root_inode)
501 goto out_no_root;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 root_inode->i_uid = 0;
503 root_inode->i_gid = 0;
504 s->s_root = d_alloc_root(root_inode);
505 if (!s->s_root)
506 goto out_no_root;
507 return 0;
508
509out_no_root:
510 printk("proc_read_super: get root inode failed\n");
511 iput(root_inode);
Alexey Dobriyan76956502007-05-08 00:25:45 -0700512 de_put(&proc_root);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 return -ENOMEM;
514}