mm: Remove slab destructors from kmem_cache_create().
[linux-2.6.git] / fs / proc / inode.c
1 /*
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/completion.h>
14 #include <linux/file.h>
15 #include <linux/limits.h>
16 #include <linux/init.h>
17 #include <linux/module.h>
18 #include <linux/smp_lock.h>
19
20 #include <asm/system.h>
21 #include <asm/uaccess.h>
22
23 #include "internal.h"
24
25 struct proc_dir_entry *de_get(struct proc_dir_entry *de)
26 {
27         if (de)
28                 atomic_inc(&de->count);
29         return de;
30 }
31
32 /*
33  * Decrements the use count and checks for deferred deletion.
34  */
35 void de_put(struct proc_dir_entry *de)
36 {
37         if (de) {       
38                 lock_kernel();          
39                 if (!atomic_read(&de->count)) {
40                         printk("de_put: entry %s already free!\n", de->name);
41                         unlock_kernel();
42                         return;
43                 }
44
45                 if (atomic_dec_and_test(&de->count)) {
46                         if (de->deleted) {
47                                 printk("de_put: deferred delete of %s\n",
48                                         de->name);
49                                 free_proc_entry(de);
50                         }
51                 }               
52                 unlock_kernel();
53         }
54 }
55
56 /*
57  * Decrement the use count of the proc_dir_entry.
58  */
59 static void proc_delete_inode(struct inode *inode)
60 {
61         struct proc_dir_entry *de;
62
63         truncate_inode_pages(&inode->i_data, 0);
64
65         /* Stop tracking associated processes */
66         put_pid(PROC_I(inode)->pid);
67
68         /* Let go of any associated proc directory entry */
69         de = PROC_I(inode)->pde;
70         if (de) {
71                 if (de->owner)
72                         module_put(de->owner);
73                 de_put(de);
74         }
75         clear_inode(inode);
76 }
77
78 struct vfsmount *proc_mnt;
79
80 static void proc_read_inode(struct inode * inode)
81 {
82         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
83 }
84
85 static struct kmem_cache * proc_inode_cachep;
86
87 static struct inode *proc_alloc_inode(struct super_block *sb)
88 {
89         struct proc_inode *ei;
90         struct inode *inode;
91
92         ei = (struct proc_inode *)kmem_cache_alloc(proc_inode_cachep, GFP_KERNEL);
93         if (!ei)
94                 return NULL;
95         ei->pid = NULL;
96         ei->fd = 0;
97         ei->op.proc_get_link = NULL;
98         ei->pde = NULL;
99         inode = &ei->vfs_inode;
100         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
101         return inode;
102 }
103
104 static void proc_destroy_inode(struct inode *inode)
105 {
106         kmem_cache_free(proc_inode_cachep, PROC_I(inode));
107 }
108
109 static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flags)
110 {
111         struct proc_inode *ei = (struct proc_inode *) foo;
112
113         inode_init_once(&ei->vfs_inode);
114 }
115
116 int __init proc_init_inodecache(void)
117 {
118         proc_inode_cachep = kmem_cache_create("proc_inode_cache",
119                                              sizeof(struct proc_inode),
120                                              0, (SLAB_RECLAIM_ACCOUNT|
121                                                 SLAB_MEM_SPREAD),
122                                              init_once);
123         if (proc_inode_cachep == NULL)
124                 return -ENOMEM;
125         return 0;
126 }
127
128 static int proc_remount(struct super_block *sb, int *flags, char *data)
129 {
130         *flags |= MS_NODIRATIME;
131         return 0;
132 }
133
134 static const struct super_operations proc_sops = {
135         .alloc_inode    = proc_alloc_inode,
136         .destroy_inode  = proc_destroy_inode,
137         .read_inode     = proc_read_inode,
138         .drop_inode     = generic_delete_inode,
139         .delete_inode   = proc_delete_inode,
140         .statfs         = simple_statfs,
141         .remount_fs     = proc_remount,
142 };
143
144 static void pde_users_dec(struct proc_dir_entry *pde)
145 {
146         spin_lock(&pde->pde_unload_lock);
147         pde->pde_users--;
148         if (pde->pde_unload_completion && pde->pde_users == 0)
149                 complete(pde->pde_unload_completion);
150         spin_unlock(&pde->pde_unload_lock);
151 }
152
153 static loff_t proc_reg_llseek(struct file *file, loff_t offset, int whence)
154 {
155         struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
156         loff_t rv = -EINVAL;
157         loff_t (*llseek)(struct file *, loff_t, int);
158
159         spin_lock(&pde->pde_unload_lock);
160         /*
161          * remove_proc_entry() is going to delete PDE (as part of module
162          * cleanup sequence). No new callers into module allowed.
163          */
164         if (!pde->proc_fops) {
165                 spin_unlock(&pde->pde_unload_lock);
166                 return rv;
167         }
168         /*
169          * Bump refcount so that remove_proc_entry will wail for ->llseek to
170          * complete.
171          */
172         pde->pde_users++;
173         /*
174          * Save function pointer under lock, to protect against ->proc_fops
175          * NULL'ifying right after ->pde_unload_lock is dropped.
176          */
177         llseek = pde->proc_fops->llseek;
178         spin_unlock(&pde->pde_unload_lock);
179
180         if (!llseek)
181                 llseek = default_llseek;
182         rv = llseek(file, offset, whence);
183
184         pde_users_dec(pde);
185         return rv;
186 }
187
188 static ssize_t proc_reg_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
189 {
190         struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
191         ssize_t rv = -EIO;
192         ssize_t (*read)(struct file *, char __user *, size_t, loff_t *);
193
194         spin_lock(&pde->pde_unload_lock);
195         if (!pde->proc_fops) {
196                 spin_unlock(&pde->pde_unload_lock);
197                 return rv;
198         }
199         pde->pde_users++;
200         read = pde->proc_fops->read;
201         spin_unlock(&pde->pde_unload_lock);
202
203         if (read)
204                 rv = read(file, buf, count, ppos);
205
206         pde_users_dec(pde);
207         return rv;
208 }
209
210 static ssize_t proc_reg_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
211 {
212         struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
213         ssize_t rv = -EIO;
214         ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *);
215
216         spin_lock(&pde->pde_unload_lock);
217         if (!pde->proc_fops) {
218                 spin_unlock(&pde->pde_unload_lock);
219                 return rv;
220         }
221         pde->pde_users++;
222         write = pde->proc_fops->write;
223         spin_unlock(&pde->pde_unload_lock);
224
225         if (write)
226                 rv = write(file, buf, count, ppos);
227
228         pde_users_dec(pde);
229         return rv;
230 }
231
232 static unsigned int proc_reg_poll(struct file *file, struct poll_table_struct *pts)
233 {
234         struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
235         unsigned int rv = 0;
236         unsigned int (*poll)(struct file *, struct poll_table_struct *);
237
238         spin_lock(&pde->pde_unload_lock);
239         if (!pde->proc_fops) {
240                 spin_unlock(&pde->pde_unload_lock);
241                 return rv;
242         }
243         pde->pde_users++;
244         poll = pde->proc_fops->poll;
245         spin_unlock(&pde->pde_unload_lock);
246
247         if (poll)
248                 rv = poll(file, pts);
249
250         pde_users_dec(pde);
251         return rv;
252 }
253
254 static long proc_reg_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
255 {
256         struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
257         long rv = -ENOTTY;
258         long (*unlocked_ioctl)(struct file *, unsigned int, unsigned long);
259         int (*ioctl)(struct inode *, struct file *, unsigned int, unsigned long);
260
261         spin_lock(&pde->pde_unload_lock);
262         if (!pde->proc_fops) {
263                 spin_unlock(&pde->pde_unload_lock);
264                 return rv;
265         }
266         pde->pde_users++;
267         unlocked_ioctl = pde->proc_fops->unlocked_ioctl;
268         ioctl = pde->proc_fops->ioctl;
269         spin_unlock(&pde->pde_unload_lock);
270
271         if (unlocked_ioctl) {
272                 rv = unlocked_ioctl(file, cmd, arg);
273                 if (rv == -ENOIOCTLCMD)
274                         rv = -EINVAL;
275         } else if (ioctl) {
276                 lock_kernel();
277                 rv = ioctl(file->f_path.dentry->d_inode, file, cmd, arg);
278                 unlock_kernel();
279         }
280
281         pde_users_dec(pde);
282         return rv;
283 }
284
285 #ifdef CONFIG_COMPAT
286 static long proc_reg_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
287 {
288         struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
289         long rv = -ENOTTY;
290         long (*compat_ioctl)(struct file *, unsigned int, unsigned long);
291
292         spin_lock(&pde->pde_unload_lock);
293         if (!pde->proc_fops) {
294                 spin_unlock(&pde->pde_unload_lock);
295                 return rv;
296         }
297         pde->pde_users++;
298         compat_ioctl = pde->proc_fops->compat_ioctl;
299         spin_unlock(&pde->pde_unload_lock);
300
301         if (compat_ioctl)
302                 rv = compat_ioctl(file, cmd, arg);
303
304         pde_users_dec(pde);
305         return rv;
306 }
307 #endif
308
309 static int proc_reg_mmap(struct file *file, struct vm_area_struct *vma)
310 {
311         struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
312         int rv = -EIO;
313         int (*mmap)(struct file *, struct vm_area_struct *);
314
315         spin_lock(&pde->pde_unload_lock);
316         if (!pde->proc_fops) {
317                 spin_unlock(&pde->pde_unload_lock);
318                 return rv;
319         }
320         pde->pde_users++;
321         mmap = pde->proc_fops->mmap;
322         spin_unlock(&pde->pde_unload_lock);
323
324         if (mmap)
325                 rv = mmap(file, vma);
326
327         pde_users_dec(pde);
328         return rv;
329 }
330
331 static int proc_reg_open(struct inode *inode, struct file *file)
332 {
333         struct proc_dir_entry *pde = PDE(inode);
334         int rv = 0;
335         int (*open)(struct inode *, struct file *);
336
337         spin_lock(&pde->pde_unload_lock);
338         if (!pde->proc_fops) {
339                 spin_unlock(&pde->pde_unload_lock);
340                 return rv;
341         }
342         pde->pde_users++;
343         open = pde->proc_fops->open;
344         spin_unlock(&pde->pde_unload_lock);
345
346         if (open)
347                 rv = open(inode, file);
348
349         pde_users_dec(pde);
350         return rv;
351 }
352
353 static int proc_reg_release(struct inode *inode, struct file *file)
354 {
355         struct proc_dir_entry *pde = PDE(inode);
356         int rv = 0;
357         int (*release)(struct inode *, struct file *);
358
359         spin_lock(&pde->pde_unload_lock);
360         if (!pde->proc_fops) {
361                 spin_unlock(&pde->pde_unload_lock);
362                 return rv;
363         }
364         pde->pde_users++;
365         release = pde->proc_fops->release;
366         spin_unlock(&pde->pde_unload_lock);
367
368         if (release)
369                 rv = release(inode, file);
370
371         pde_users_dec(pde);
372         return rv;
373 }
374
375 static const struct file_operations proc_reg_file_ops = {
376         .llseek         = proc_reg_llseek,
377         .read           = proc_reg_read,
378         .write          = proc_reg_write,
379         .poll           = proc_reg_poll,
380         .unlocked_ioctl = proc_reg_unlocked_ioctl,
381 #ifdef CONFIG_COMPAT
382         .compat_ioctl   = proc_reg_compat_ioctl,
383 #endif
384         .mmap           = proc_reg_mmap,
385         .open           = proc_reg_open,
386         .release        = proc_reg_release,
387 };
388
389 struct inode *proc_get_inode(struct super_block *sb, unsigned int ino,
390                                 struct proc_dir_entry *de)
391 {
392         struct inode * inode;
393
394         if (de != NULL && !try_module_get(de->owner))
395                 goto out_mod;
396
397         inode = iget(sb, ino);
398         if (!inode)
399                 goto out_ino;
400
401         PROC_I(inode)->fd = 0;
402         PROC_I(inode)->pde = de;
403         if (de) {
404                 if (de->mode) {
405                         inode->i_mode = de->mode;
406                         inode->i_uid = de->uid;
407                         inode->i_gid = de->gid;
408                 }
409                 if (de->size)
410                         inode->i_size = de->size;
411                 if (de->nlink)
412                         inode->i_nlink = de->nlink;
413                 if (de->proc_iops)
414                         inode->i_op = de->proc_iops;
415                 if (de->proc_fops) {
416                         if (S_ISREG(inode->i_mode))
417                                 inode->i_fop = &proc_reg_file_ops;
418                         else
419                                 inode->i_fop = de->proc_fops;
420                 }
421         }
422
423         return inode;
424
425 out_ino:
426         if (de != NULL)
427                 module_put(de->owner);
428 out_mod:
429         return NULL;
430 }                       
431
432 int proc_fill_super(struct super_block *s, void *data, int silent)
433 {
434         struct inode * root_inode;
435
436         s->s_flags |= MS_NODIRATIME | MS_NOSUID | MS_NOEXEC;
437         s->s_blocksize = 1024;
438         s->s_blocksize_bits = 10;
439         s->s_magic = PROC_SUPER_MAGIC;
440         s->s_op = &proc_sops;
441         s->s_time_gran = 1;
442         
443         de_get(&proc_root);
444         root_inode = proc_get_inode(s, PROC_ROOT_INO, &proc_root);
445         if (!root_inode)
446                 goto out_no_root;
447         root_inode->i_uid = 0;
448         root_inode->i_gid = 0;
449         s->s_root = d_alloc_root(root_inode);
450         if (!s->s_root)
451                 goto out_no_root;
452         return 0;
453
454 out_no_root:
455         printk("proc_read_super: get root inode failed\n");
456         iput(root_inode);
457         de_put(&proc_root);
458         return -ENOMEM;
459 }
460 MODULE_LICENSE("GPL");