2 * proc/fs/generic.c --- generic routines for the proc-fs
4 * This file contains generic proc-fs routines for handling
5 * directories and files.
7 * Copyright (C) 1991, 1992 Linus Torvalds.
8 * Copyright (C) 1997 Theodore Ts'o
11 #include <linux/errno.h>
12 #include <linux/time.h>
13 #include <linux/proc_fs.h>
14 #include <linux/stat.h>
16 #include <linux/module.h>
17 #include <linux/slab.h>
18 #include <linux/printk.h>
19 #include <linux/mount.h>
20 #include <linux/init.h>
21 #include <linux/idr.h>
22 #include <linux/bitops.h>
23 #include <linux/spinlock.h>
24 #include <linux/completion.h>
25 #include <asm/uaccess.h>
29 DEFINE_SPINLOCK(proc_subdir_lock
);
31 static int proc_match(unsigned int len
, const char *name
, struct proc_dir_entry
*de
)
33 if (de
->namelen
!= len
)
35 return !memcmp(name
, de
->name
, len
);
38 static int proc_notify_change(struct dentry
*dentry
, struct iattr
*iattr
)
40 struct inode
*inode
= dentry
->d_inode
;
41 struct proc_dir_entry
*de
= PDE(inode
);
44 error
= inode_change_ok(inode
, iattr
);
48 setattr_copy(inode
, iattr
);
49 mark_inode_dirty(inode
);
51 de
->uid
= inode
->i_uid
;
52 de
->gid
= inode
->i_gid
;
53 de
->mode
= inode
->i_mode
;
57 static int proc_getattr(struct vfsmount
*mnt
, struct dentry
*dentry
,
60 struct inode
*inode
= dentry
->d_inode
;
61 struct proc_dir_entry
*de
= PROC_I(inode
)->pde
;
63 set_nlink(inode
, de
->nlink
);
65 generic_fillattr(inode
, stat
);
69 static const struct inode_operations proc_file_inode_operations
= {
70 .setattr
= proc_notify_change
,
74 * This function parses a name such as "tty/driver/serial", and
75 * returns the struct proc_dir_entry for "/proc/tty/driver", and
76 * returns "serial" in residual.
78 static int __xlate_proc_name(const char *name
, struct proc_dir_entry
**ret
,
79 const char **residual
)
81 const char *cp
= name
, *next
;
82 struct proc_dir_entry
*de
;
90 next
= strchr(cp
, '/');
95 for (de
= de
->subdir
; de
; de
= de
->next
) {
96 if (proc_match(len
, cp
, de
))
100 WARN(1, "name '%s'\n", name
);
110 static int xlate_proc_name(const char *name
, struct proc_dir_entry
**ret
,
111 const char **residual
)
115 spin_lock(&proc_subdir_lock
);
116 rv
= __xlate_proc_name(name
, ret
, residual
);
117 spin_unlock(&proc_subdir_lock
);
121 static DEFINE_IDA(proc_inum_ida
);
122 static DEFINE_SPINLOCK(proc_inum_lock
); /* protects the above */
124 #define PROC_DYNAMIC_FIRST 0xF0000000U
127 * Return an inode number between PROC_DYNAMIC_FIRST and
128 * 0xffffffff, or zero on failure.
130 int proc_alloc_inum(unsigned int *inum
)
136 if (!ida_pre_get(&proc_inum_ida
, GFP_KERNEL
))
139 spin_lock_irq(&proc_inum_lock
);
140 error
= ida_get_new(&proc_inum_ida
, &i
);
141 spin_unlock_irq(&proc_inum_lock
);
142 if (error
== -EAGAIN
)
147 if (i
> UINT_MAX
- PROC_DYNAMIC_FIRST
) {
148 spin_lock_irq(&proc_inum_lock
);
149 ida_remove(&proc_inum_ida
, i
);
150 spin_unlock_irq(&proc_inum_lock
);
153 *inum
= PROC_DYNAMIC_FIRST
+ i
;
157 void proc_free_inum(unsigned int inum
)
160 spin_lock_irqsave(&proc_inum_lock
, flags
);
161 ida_remove(&proc_inum_ida
, inum
- PROC_DYNAMIC_FIRST
);
162 spin_unlock_irqrestore(&proc_inum_lock
, flags
);
166 * As some entries in /proc are volatile, we want to
167 * get rid of unused dentries. This could be made
168 * smarter: we could keep a "volatile" flag in the
169 * inode to indicate which ones to keep.
171 static int proc_delete_dentry(const struct dentry
* dentry
)
176 static const struct dentry_operations proc_dentry_operations
=
178 .d_delete
= proc_delete_dentry
,
182 * Don't create negative dentries here, return -ENOENT by hand
185 struct dentry
*proc_lookup_de(struct proc_dir_entry
*de
, struct inode
*dir
,
186 struct dentry
*dentry
)
190 spin_lock(&proc_subdir_lock
);
191 for (de
= de
->subdir
; de
; de
= de
->next
) {
192 if (de
->namelen
!= dentry
->d_name
.len
)
194 if (!memcmp(dentry
->d_name
.name
, de
->name
, de
->namelen
)) {
196 spin_unlock(&proc_subdir_lock
);
197 inode
= proc_get_inode(dir
->i_sb
, de
);
199 return ERR_PTR(-ENOMEM
);
200 d_set_d_op(dentry
, &proc_dentry_operations
);
201 d_add(dentry
, inode
);
205 spin_unlock(&proc_subdir_lock
);
206 return ERR_PTR(-ENOENT
);
209 struct dentry
*proc_lookup(struct inode
*dir
, struct dentry
*dentry
,
212 return proc_lookup_de(PDE(dir
), dir
, dentry
);
216 * This returns non-zero if at EOF, so that the /proc
217 * root directory can use this and check if it should
218 * continue with the <pid> entries..
220 * Note that the VFS-layer doesn't care about the return
221 * value of the readdir() call, as long as it's non-negative
224 int proc_readdir_de(struct proc_dir_entry
*de
, struct file
*filp
, void *dirent
,
229 struct inode
*inode
= file_inode(filp
);
236 if (filldir(dirent
, ".", 1, i
, ino
, DT_DIR
) < 0)
242 if (filldir(dirent
, "..", 2, i
,
243 parent_ino(filp
->f_path
.dentry
),
250 spin_lock(&proc_subdir_lock
);
256 spin_unlock(&proc_subdir_lock
);
266 struct proc_dir_entry
*next
;
268 /* filldir passes info to user space */
270 spin_unlock(&proc_subdir_lock
);
271 if (filldir(dirent
, de
->name
, de
->namelen
, filp
->f_pos
,
272 de
->low_ino
, de
->mode
>> 12) < 0) {
276 spin_lock(&proc_subdir_lock
);
282 spin_unlock(&proc_subdir_lock
);
289 int proc_readdir(struct file
*filp
, void *dirent
, filldir_t filldir
)
291 struct inode
*inode
= file_inode(filp
);
293 return proc_readdir_de(PDE(inode
), filp
, dirent
, filldir
);
297 * These are the generic /proc directory operations. They
298 * use the in-memory "struct proc_dir_entry" tree to parse
299 * the /proc directory.
301 static const struct file_operations proc_dir_operations
= {
302 .llseek
= generic_file_llseek
,
303 .read
= generic_read_dir
,
304 .readdir
= proc_readdir
,
308 * proc directories can do almost nothing..
310 static const struct inode_operations proc_dir_inode_operations
= {
311 .lookup
= proc_lookup
,
312 .getattr
= proc_getattr
,
313 .setattr
= proc_notify_change
,
316 static int proc_register(struct proc_dir_entry
* dir
, struct proc_dir_entry
* dp
)
318 struct proc_dir_entry
*tmp
;
321 ret
= proc_alloc_inum(&dp
->low_ino
);
325 if (S_ISDIR(dp
->mode
)) {
326 dp
->proc_fops
= &proc_dir_operations
;
327 dp
->proc_iops
= &proc_dir_inode_operations
;
329 } else if (S_ISLNK(dp
->mode
)) {
330 dp
->proc_iops
= &proc_link_inode_operations
;
331 } else if (S_ISREG(dp
->mode
)) {
332 BUG_ON(dp
->proc_fops
== NULL
);
333 dp
->proc_iops
= &proc_file_inode_operations
;
339 spin_lock(&proc_subdir_lock
);
341 for (tmp
= dir
->subdir
; tmp
; tmp
= tmp
->next
)
342 if (strcmp(tmp
->name
, dp
->name
) == 0) {
343 WARN(1, "proc_dir_entry '%s/%s' already registered\n",
344 dir
->name
, dp
->name
);
348 dp
->next
= dir
->subdir
;
351 spin_unlock(&proc_subdir_lock
);
356 static struct proc_dir_entry
*__proc_create(struct proc_dir_entry
**parent
,
361 struct proc_dir_entry
*ent
= NULL
;
362 const char *fn
= name
;
365 /* make sure name is valid */
366 if (!name
|| !strlen(name
))
369 if (xlate_proc_name(name
, parent
, &fn
) != 0)
372 /* At this point there must not be any '/' characters beyond *fn */
378 ent
= kzalloc(sizeof(struct proc_dir_entry
) + len
+ 1, GFP_KERNEL
);
382 memcpy(ent
->name
, fn
, len
+ 1);
386 atomic_set(&ent
->count
, 1);
387 spin_lock_init(&ent
->pde_unload_lock
);
388 INIT_LIST_HEAD(&ent
->pde_openers
);
393 struct proc_dir_entry
*proc_symlink(const char *name
,
394 struct proc_dir_entry
*parent
, const char *dest
)
396 struct proc_dir_entry
*ent
;
398 ent
= __proc_create(&parent
, name
,
399 (S_IFLNK
| S_IRUGO
| S_IWUGO
| S_IXUGO
),1);
402 ent
->data
= kmalloc((ent
->size
=strlen(dest
))+1, GFP_KERNEL
);
404 strcpy((char*)ent
->data
,dest
);
405 if (proc_register(parent
, ent
) < 0) {
417 EXPORT_SYMBOL(proc_symlink
);
419 struct proc_dir_entry
*proc_mkdir_data(const char *name
, umode_t mode
,
420 struct proc_dir_entry
*parent
, void *data
)
422 struct proc_dir_entry
*ent
;
425 mode
= S_IRUGO
| S_IXUGO
;
427 ent
= __proc_create(&parent
, name
, S_IFDIR
| mode
, 2);
430 if (proc_register(parent
, ent
) < 0) {
437 EXPORT_SYMBOL_GPL(proc_mkdir_data
);
439 struct proc_dir_entry
*proc_mkdir_mode(const char *name
, umode_t mode
,
440 struct proc_dir_entry
*parent
)
442 return proc_mkdir_data(name
, mode
, parent
, NULL
);
444 EXPORT_SYMBOL(proc_mkdir_mode
);
446 struct proc_dir_entry
*proc_mkdir(const char *name
,
447 struct proc_dir_entry
*parent
)
449 return proc_mkdir_data(name
, 0, parent
, NULL
);
451 EXPORT_SYMBOL(proc_mkdir
);
453 struct proc_dir_entry
*proc_create_data(const char *name
, umode_t mode
,
454 struct proc_dir_entry
*parent
,
455 const struct file_operations
*proc_fops
,
458 struct proc_dir_entry
*pde
;
459 if ((mode
& S_IFMT
) == 0)
462 if (!S_ISREG(mode
)) {
463 WARN_ON(1); /* use proc_mkdir() */
467 if ((mode
& S_IALLUGO
) == 0)
469 pde
= __proc_create(&parent
, name
, mode
, 1);
472 pde
->proc_fops
= proc_fops
;
474 if (proc_register(parent
, pde
) < 0)
482 EXPORT_SYMBOL(proc_create_data
);
484 void proc_set_size(struct proc_dir_entry
*de
, loff_t size
)
488 EXPORT_SYMBOL(proc_set_size
);
490 void proc_set_user(struct proc_dir_entry
*de
, kuid_t uid
, kgid_t gid
)
495 EXPORT_SYMBOL(proc_set_user
);
497 static void free_proc_entry(struct proc_dir_entry
*de
)
499 proc_free_inum(de
->low_ino
);
501 if (S_ISLNK(de
->mode
))
506 void pde_put(struct proc_dir_entry
*pde
)
508 if (atomic_dec_and_test(&pde
->count
))
509 free_proc_entry(pde
);
513 * Remove a /proc entry and free it if it's not currently in use.
515 void remove_proc_entry(const char *name
, struct proc_dir_entry
*parent
)
517 struct proc_dir_entry
**p
;
518 struct proc_dir_entry
*de
= NULL
;
519 const char *fn
= name
;
522 spin_lock(&proc_subdir_lock
);
523 if (__xlate_proc_name(name
, &parent
, &fn
) != 0) {
524 spin_unlock(&proc_subdir_lock
);
529 for (p
= &parent
->subdir
; *p
; p
=&(*p
)->next
) {
530 if (proc_match(len
, fn
, *p
)) {
537 spin_unlock(&proc_subdir_lock
);
539 WARN(1, "name '%s'\n", name
);
543 proc_entry_rundown(de
);
545 if (S_ISDIR(de
->mode
))
548 WARN(de
->subdir
, "%s: removing non-empty directory "
549 "'%s/%s', leaking at least '%s'\n", __func__
,
550 de
->parent
->name
, de
->name
, de
->subdir
->name
);
553 EXPORT_SYMBOL(remove_proc_entry
);
555 int remove_proc_subtree(const char *name
, struct proc_dir_entry
*parent
)
557 struct proc_dir_entry
**p
;
558 struct proc_dir_entry
*root
= NULL
, *de
, *next
;
559 const char *fn
= name
;
562 spin_lock(&proc_subdir_lock
);
563 if (__xlate_proc_name(name
, &parent
, &fn
) != 0) {
564 spin_unlock(&proc_subdir_lock
);
569 for (p
= &parent
->subdir
; *p
; p
=&(*p
)->next
) {
570 if (proc_match(len
, fn
, *p
)) {
578 spin_unlock(&proc_subdir_lock
);
585 de
->subdir
= next
->next
;
590 spin_unlock(&proc_subdir_lock
);
592 proc_entry_rundown(de
);
594 if (S_ISDIR(de
->mode
))
601 spin_lock(&proc_subdir_lock
);
607 EXPORT_SYMBOL(remove_proc_subtree
);
609 void *proc_get_parent_data(const struct inode
*inode
)
611 struct proc_dir_entry
*de
= PDE(inode
);
612 return de
->parent
->data
;
614 EXPORT_SYMBOL_GPL(proc_get_parent_data
);
616 void proc_remove(struct proc_dir_entry
*de
)
619 remove_proc_subtree(de
->name
, de
->parent
);
621 EXPORT_SYMBOL(proc_remove
);
623 void *PDE_DATA(const struct inode
*inode
)
625 return __PDE_DATA(inode
);
627 EXPORT_SYMBOL(PDE_DATA
);