[PATCH] cpuset memory spread: slab cache filesystems
[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/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|SLAB_MEM_SPREAD,
125                                              init_once, NULL);
126         if (proc_inode_cachep == NULL)
127                 return -ENOMEM;
128         return 0;
129 }
130
131 static int proc_remount(struct super_block *sb, int *flags, char *data)
132 {
133         *flags |= MS_NODIRATIME;
134         return 0;
135 }
136
137 static struct super_operations proc_sops = { 
138         .alloc_inode    = proc_alloc_inode,
139         .destroy_inode  = proc_destroy_inode,
140         .read_inode     = proc_read_inode,
141         .drop_inode     = generic_delete_inode,
142         .delete_inode   = proc_delete_inode,
143         .statfs         = simple_statfs,
144         .remount_fs     = proc_remount,
145 };
146
147 struct inode *proc_get_inode(struct super_block *sb, unsigned int ino,
148                                 struct proc_dir_entry *de)
149 {
150         struct inode * inode;
151
152         /*
153          * Increment the use count so the dir entry can't disappear.
154          */
155         de_get(de);
156
157         WARN_ON(de && de->deleted);
158
159         if (de != NULL && !try_module_get(de->owner))
160                 goto out_mod;
161
162         inode = iget(sb, ino);
163         if (!inode)
164                 goto out_ino;
165
166         PROC_I(inode)->pde = de;
167         if (de) {
168                 if (de->mode) {
169                         inode->i_mode = de->mode;
170                         inode->i_uid = de->uid;
171                         inode->i_gid = de->gid;
172                 }
173                 if (de->size)
174                         inode->i_size = de->size;
175                 if (de->nlink)
176                         inode->i_nlink = de->nlink;
177                 if (de->proc_iops)
178                         inode->i_op = de->proc_iops;
179                 if (de->proc_fops)
180                         inode->i_fop = de->proc_fops;
181         }
182
183         return inode;
184
185 out_ino:
186         if (de != NULL)
187                 module_put(de->owner);
188 out_mod:
189         de_put(de);
190         return NULL;
191 }                       
192
193 int proc_fill_super(struct super_block *s, void *data, int silent)
194 {
195         struct inode * root_inode;
196
197         s->s_flags |= MS_NODIRATIME;
198         s->s_blocksize = 1024;
199         s->s_blocksize_bits = 10;
200         s->s_magic = PROC_SUPER_MAGIC;
201         s->s_op = &proc_sops;
202         s->s_time_gran = 1;
203         
204         root_inode = proc_get_inode(s, PROC_ROOT_INO, &proc_root);
205         if (!root_inode)
206                 goto out_no_root;
207         root_inode->i_uid = 0;
208         root_inode->i_gid = 0;
209         s->s_root = d_alloc_root(root_inode);
210         if (!s->s_root)
211                 goto out_no_root;
212         return 0;
213
214 out_no_root:
215         printk("proc_read_super: get root inode failed\n");
216         iput(root_inode);
217         return -ENOMEM;
218 }
219 MODULE_LICENSE("GPL");