Merge master.kernel.org:/pub/scm/linux/kernel/git/davem/sparc-2.6
[linux-2.6] / 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/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
22 #include "internal.h"
23
24 static 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  */
34 static 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  */
58 static void proc_delete_inode(struct inode *inode)
59 {
60         struct proc_dir_entry *de;
61         struct task_struct *tsk;
62
63         truncate_inode_pages(&inode->i_data, 0);
64
65         /* 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
80 struct vfsmount *proc_mnt;
81
82 static void proc_read_inode(struct inode * inode)
83 {
84         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
85 }
86
87 static kmem_cache_t * proc_inode_cachep;
88
89 static 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
106 static void proc_destroy_inode(struct inode *inode)
107 {
108         kmem_cache_free(proc_inode_cachep, PROC_I(inode));
109 }
110
111 static 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  
120 int __init proc_init_inodecache(void)
121 {
122         proc_inode_cachep = kmem_cache_create("proc_inode_cache",
123                                              sizeof(struct proc_inode),
124                                              0, (SLAB_RECLAIM_ACCOUNT|
125                                                 SLAB_MEM_SPREAD),
126                                              init_once, NULL);
127         if (proc_inode_cachep == NULL)
128                 return -ENOMEM;
129         return 0;
130 }
131
132 static int proc_remount(struct super_block *sb, int *flags, char *data)
133 {
134         *flags |= MS_NODIRATIME;
135         return 0;
136 }
137
138 static 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
148 struct 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
160         if (de != NULL && !try_module_get(de->owner))
161                 goto out_mod;
162
163         inode = iget(sb, ino);
164         if (!inode)
165                 goto out_ino;
166
167         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;
178                 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
184         return inode;
185
186 out_ino:
187         if (de != NULL)
188                 module_put(de->owner);
189 out_mod:
190         de_put(de);
191         return NULL;
192 }                       
193
194 int 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;
208         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
215 out_no_root:
216         printk("proc_read_super: get root inode failed\n");
217         iput(root_inode);
218         return -ENOMEM;
219 }
220 MODULE_LICENSE("GPL");