blob: 722b9c4631113d627fc8e4be5359dbf81092c8ff [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>
13#include <linux/file.h>
14#include <linux/limits.h>
15#include <linux/init.h>
16#include <linux/module.h>
17#include <linux/smp_lock.h>
18
19#include <asm/system.h>
20#include <asm/uaccess.h>
21
Adrian Bunkfee781e2006-01-08 01:04:16 -080022#include "internal.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070023
24static inline struct proc_dir_entry * de_get(struct proc_dir_entry *de)
25{
26 if (de)
27 atomic_inc(&de->count);
28 return de;
29}
30
31/*
32 * Decrements the use count and checks for deferred deletion.
33 */
34static void de_put(struct proc_dir_entry *de)
35{
36 if (de) {
37 lock_kernel();
38 if (!atomic_read(&de->count)) {
39 printk("de_put: entry %s already free!\n", de->name);
40 unlock_kernel();
41 return;
42 }
43
44 if (atomic_dec_and_test(&de->count)) {
45 if (de->deleted) {
46 printk("de_put: deferred delete of %s\n",
47 de->name);
48 free_proc_entry(de);
49 }
50 }
51 unlock_kernel();
52 }
53}
54
55/*
56 * Decrement the use count of the proc_dir_entry.
57 */
58static void proc_delete_inode(struct inode *inode)
59{
60 struct proc_dir_entry *de;
61 struct task_struct *tsk;
62
Mark Fashehfef26652005-09-09 13:01:31 -070063 truncate_inode_pages(&inode->i_data, 0);
64
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 /* Let go of any associated process */
66 tsk = PROC_I(inode)->task;
67 if (tsk)
68 put_task_struct(tsk);
69
70 /* Let go of any associated proc directory entry */
71 de = PROC_I(inode)->pde;
72 if (de) {
73 if (de->owner)
74 module_put(de->owner);
75 de_put(de);
76 }
77 clear_inode(inode);
78}
79
80struct vfsmount *proc_mnt;
81
82static void proc_read_inode(struct inode * inode)
83{
84 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
85}
86
87static kmem_cache_t * proc_inode_cachep;
88
89static struct inode *proc_alloc_inode(struct super_block *sb)
90{
91 struct proc_inode *ei;
92 struct inode *inode;
93
94 ei = (struct proc_inode *)kmem_cache_alloc(proc_inode_cachep, SLAB_KERNEL);
95 if (!ei)
96 return NULL;
97 ei->task = NULL;
98 ei->type = 0;
99 ei->op.proc_get_link = NULL;
100 ei->pde = NULL;
101 inode = &ei->vfs_inode;
102 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
103 return inode;
104}
105
106static void proc_destroy_inode(struct inode *inode)
107{
108 kmem_cache_free(proc_inode_cachep, PROC_I(inode));
109}
110
111static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
112{
113 struct proc_inode *ei = (struct proc_inode *) foo;
114
115 if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
116 SLAB_CTOR_CONSTRUCTOR)
117 inode_init_once(&ei->vfs_inode);
118}
119
120int __init proc_init_inodecache(void)
121{
122 proc_inode_cachep = kmem_cache_create("proc_inode_cache",
123 sizeof(struct proc_inode),
Paul Jacksonfffb60f2006-03-24 03:16:06 -0800124 0, (SLAB_RECLAIM_ACCOUNT|
125 SLAB_MEM_SPREAD),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 init_once, NULL);
127 if (proc_inode_cachep == NULL)
128 return -ENOMEM;
129 return 0;
130}
131
132static int proc_remount(struct super_block *sb, int *flags, char *data)
133{
134 *flags |= MS_NODIRATIME;
135 return 0;
136}
137
138static struct super_operations proc_sops = {
139 .alloc_inode = proc_alloc_inode,
140 .destroy_inode = proc_destroy_inode,
141 .read_inode = proc_read_inode,
142 .drop_inode = generic_delete_inode,
143 .delete_inode = proc_delete_inode,
144 .statfs = simple_statfs,
145 .remount_fs = proc_remount,
146};
147
148struct inode *proc_get_inode(struct super_block *sb, unsigned int ino,
149 struct proc_dir_entry *de)
150{
151 struct inode * inode;
152
153 /*
154 * Increment the use count so the dir entry can't disappear.
155 */
156 de_get(de);
157
158 WARN_ON(de && de->deleted);
159
Kirill Korotaeve9543652005-10-30 15:02:26 -0800160 if (de != NULL && !try_module_get(de->owner))
161 goto out_mod;
162
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 inode = iget(sb, ino);
164 if (!inode)
Kirill Korotaeve9543652005-10-30 15:02:26 -0800165 goto out_ino;
166
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 PROC_I(inode)->pde = de;
168 if (de) {
169 if (de->mode) {
170 inode->i_mode = de->mode;
171 inode->i_uid = de->uid;
172 inode->i_gid = de->gid;
173 }
174 if (de->size)
175 inode->i_size = de->size;
176 if (de->nlink)
177 inode->i_nlink = de->nlink;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 if (de->proc_iops)
179 inode->i_op = de->proc_iops;
180 if (de->proc_fops)
181 inode->i_fop = de->proc_fops;
182 }
183
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 return inode;
185
Kirill Korotaeve9543652005-10-30 15:02:26 -0800186out_ino:
187 if (de != NULL)
188 module_put(de->owner);
189out_mod:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 de_put(de);
Kirill Korotaeve9543652005-10-30 15:02:26 -0800191 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192}
193
194int proc_fill_super(struct super_block *s, void *data, int silent)
195{
196 struct inode * root_inode;
197
198 s->s_flags |= MS_NODIRATIME;
199 s->s_blocksize = 1024;
200 s->s_blocksize_bits = 10;
201 s->s_magic = PROC_SUPER_MAGIC;
202 s->s_op = &proc_sops;
203 s->s_time_gran = 1;
204
205 root_inode = proc_get_inode(s, PROC_ROOT_INO, &proc_root);
206 if (!root_inode)
207 goto out_no_root;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 root_inode->i_uid = 0;
209 root_inode->i_gid = 0;
210 s->s_root = d_alloc_root(root_inode);
211 if (!s->s_root)
212 goto out_no_root;
213 return 0;
214
215out_no_root:
216 printk("proc_read_super: get root inode failed\n");
217 iput(root_inode);
218 return -ENOMEM;
219}
220MODULE_LICENSE("GPL");