[PATCH] capable/capability.h (fs/)
[linux-2.6.git] / fs / dcookies.c
1 /*
2  * dcookies.c
3  *
4  * Copyright 2002 John Levon <levon@movementarian.org>
5  *
6  * Persistent cookie-path mappings. These are used by
7  * profilers to convert a per-task EIP value into something
8  * non-transitory that can be processed at a later date.
9  * This is done by locking the dentry/vfsmnt pair in the
10  * kernel until released by the tasks needing the persistent
11  * objects. The tag is simply an unsigned long that refers
12  * to the pair and can be looked up from userspace.
13  */
14
15 #include <linux/config.h>
16 #include <linux/syscalls.h>
17 #include <linux/module.h>
18 #include <linux/slab.h>
19 #include <linux/list.h>
20 #include <linux/mount.h>
21 #include <linux/capability.h>
22 #include <linux/dcache.h>
23 #include <linux/mm.h>
24 #include <linux/errno.h>
25 #include <linux/dcookies.h>
26 #include <asm/uaccess.h>
27
28 /* The dcookies are allocated from a kmem_cache and
29  * hashed onto a small number of lists. None of the
30  * code here is particularly performance critical
31  */
32 struct dcookie_struct {
33         struct dentry * dentry;
34         struct vfsmount * vfsmnt;
35         struct list_head hash_list;
36 };
37
38 static LIST_HEAD(dcookie_users);
39 static DECLARE_MUTEX(dcookie_sem);
40 static kmem_cache_t * dcookie_cache;
41 static struct list_head * dcookie_hashtable;
42 static size_t hash_size;
43
44 static inline int is_live(void)
45 {
46         return !(list_empty(&dcookie_users));
47 }
48
49
50 /* The dentry is locked, its address will do for the cookie */
51 static inline unsigned long dcookie_value(struct dcookie_struct * dcs)
52 {
53         return (unsigned long)dcs->dentry;
54 }
55
56
57 static size_t dcookie_hash(unsigned long dcookie)
58 {
59         return (dcookie >> L1_CACHE_SHIFT) & (hash_size - 1);
60 }
61
62
63 static struct dcookie_struct * find_dcookie(unsigned long dcookie)
64 {
65         struct dcookie_struct *found = NULL;
66         struct dcookie_struct * dcs;
67         struct list_head * pos;
68         struct list_head * list;
69
70         list = dcookie_hashtable + dcookie_hash(dcookie);
71
72         list_for_each(pos, list) {
73                 dcs = list_entry(pos, struct dcookie_struct, hash_list);
74                 if (dcookie_value(dcs) == dcookie) {
75                         found = dcs;
76                         break;
77                 }
78         }
79
80         return found;
81 }
82
83
84 static void hash_dcookie(struct dcookie_struct * dcs)
85 {
86         struct list_head * list = dcookie_hashtable + dcookie_hash(dcookie_value(dcs));
87         list_add(&dcs->hash_list, list);
88 }
89
90
91 static struct dcookie_struct * alloc_dcookie(struct dentry * dentry,
92         struct vfsmount * vfsmnt)
93 {
94         struct dcookie_struct * dcs = kmem_cache_alloc(dcookie_cache, GFP_KERNEL);
95         if (!dcs)
96                 return NULL;
97
98         dentry->d_cookie = dcs;
99
100         dcs->dentry = dget(dentry);
101         dcs->vfsmnt = mntget(vfsmnt);
102         hash_dcookie(dcs);
103
104         return dcs;
105 }
106
107
108 /* This is the main kernel-side routine that retrieves the cookie
109  * value for a dentry/vfsmnt pair.
110  */
111 int get_dcookie(struct dentry * dentry, struct vfsmount * vfsmnt,
112         unsigned long * cookie)
113 {
114         int err = 0;
115         struct dcookie_struct * dcs;
116
117         down(&dcookie_sem);
118
119         if (!is_live()) {
120                 err = -EINVAL;
121                 goto out;
122         }
123
124         dcs = dentry->d_cookie;
125
126         if (!dcs)
127                 dcs = alloc_dcookie(dentry, vfsmnt);
128
129         if (!dcs) {
130                 err = -ENOMEM;
131                 goto out;
132         }
133
134         *cookie = dcookie_value(dcs);
135
136 out:
137         up(&dcookie_sem);
138         return err;
139 }
140
141
142 /* And here is where the userspace process can look up the cookie value
143  * to retrieve the path.
144  */
145 asmlinkage long sys_lookup_dcookie(u64 cookie64, char __user * buf, size_t len)
146 {
147         unsigned long cookie = (unsigned long)cookie64;
148         int err = -EINVAL;
149         char * kbuf;
150         char * path;
151         size_t pathlen;
152         struct dcookie_struct * dcs;
153
154         /* we could leak path information to users
155          * without dir read permission without this
156          */
157         if (!capable(CAP_SYS_ADMIN))
158                 return -EPERM;
159
160         down(&dcookie_sem);
161
162         if (!is_live()) {
163                 err = -EINVAL;
164                 goto out;
165         }
166
167         if (!(dcs = find_dcookie(cookie)))
168                 goto out;
169
170         err = -ENOMEM;
171         kbuf = kmalloc(PAGE_SIZE, GFP_KERNEL);
172         if (!kbuf)
173                 goto out;
174
175         /* FIXME: (deleted) ? */
176         path = d_path(dcs->dentry, dcs->vfsmnt, kbuf, PAGE_SIZE);
177
178         if (IS_ERR(path)) {
179                 err = PTR_ERR(path);
180                 goto out_free;
181         }
182
183         err = -ERANGE;
184  
185         pathlen = kbuf + PAGE_SIZE - path;
186         if (pathlen <= len) {
187                 err = pathlen;
188                 if (copy_to_user(buf, path, pathlen))
189                         err = -EFAULT;
190         }
191
192 out_free:
193         kfree(kbuf);
194 out:
195         up(&dcookie_sem);
196         return err;
197 }
198
199
200 static int dcookie_init(void)
201 {
202         struct list_head * d;
203         unsigned int i, hash_bits;
204         int err = -ENOMEM;
205
206         dcookie_cache = kmem_cache_create("dcookie_cache",
207                 sizeof(struct dcookie_struct),
208                 0, 0, NULL, NULL);
209
210         if (!dcookie_cache)
211                 goto out;
212
213         dcookie_hashtable = kmalloc(PAGE_SIZE, GFP_KERNEL);
214         if (!dcookie_hashtable)
215                 goto out_kmem;
216
217         err = 0;
218
219         /*
220          * Find the power-of-two list-heads that can fit into the allocation..
221          * We don't guarantee that "sizeof(struct list_head)" is necessarily
222          * a power-of-two.
223          */
224         hash_size = PAGE_SIZE / sizeof(struct list_head);
225         hash_bits = 0;
226         do {
227                 hash_bits++;
228         } while ((hash_size >> hash_bits) != 0);
229         hash_bits--;
230
231         /*
232          * Re-calculate the actual number of entries and the mask
233          * from the number of bits we can fit.
234          */
235         hash_size = 1UL << hash_bits;
236
237         /* And initialize the newly allocated array */
238         d = dcookie_hashtable;
239         i = hash_size;
240         do {
241                 INIT_LIST_HEAD(d);
242                 d++;
243                 i--;
244         } while (i);
245
246 out:
247         return err;
248 out_kmem:
249         kmem_cache_destroy(dcookie_cache);
250         goto out;
251 }
252
253
254 static void free_dcookie(struct dcookie_struct * dcs)
255 {
256         dcs->dentry->d_cookie = NULL;
257         dput(dcs->dentry);
258         mntput(dcs->vfsmnt);
259         kmem_cache_free(dcookie_cache, dcs);
260 }
261
262
263 static void dcookie_exit(void)
264 {
265         struct list_head * list;
266         struct list_head * pos;
267         struct list_head * pos2;
268         struct dcookie_struct * dcs;
269         size_t i;
270
271         for (i = 0; i < hash_size; ++i) {
272                 list = dcookie_hashtable + i;
273                 list_for_each_safe(pos, pos2, list) {
274                         dcs = list_entry(pos, struct dcookie_struct, hash_list);
275                         list_del(&dcs->hash_list);
276                         free_dcookie(dcs);
277                 }
278         }
279
280         kfree(dcookie_hashtable);
281         kmem_cache_destroy(dcookie_cache);
282 }
283
284
285 struct dcookie_user {
286         struct list_head next;
287 };
288  
289 struct dcookie_user * dcookie_register(void)
290 {
291         struct dcookie_user * user;
292
293         down(&dcookie_sem);
294
295         user = kmalloc(sizeof(struct dcookie_user), GFP_KERNEL);
296         if (!user)
297                 goto out;
298
299         if (!is_live() && dcookie_init())
300                 goto out_free;
301
302         list_add(&user->next, &dcookie_users);
303
304 out:
305         up(&dcookie_sem);
306         return user;
307 out_free:
308         kfree(user);
309         user = NULL;
310         goto out;
311 }
312
313
314 void dcookie_unregister(struct dcookie_user * user)
315 {
316         down(&dcookie_sem);
317
318         list_del(&user->next);
319         kfree(user);
320
321         if (!is_live())
322                 dcookie_exit();
323
324         up(&dcookie_sem);
325 }
326
327 EXPORT_SYMBOL_GPL(dcookie_register);
328 EXPORT_SYMBOL_GPL(dcookie_unregister);
329 EXPORT_SYMBOL_GPL(get_dcookie);