blob: 17c779967828c1e49f6e65291704a54e390b6577 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/syscalls.h>
Paul Gortmaker630d9c42011-11-16 23:57:37 -050016#include <linux/export.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/slab.h>
18#include <linux/list.h>
19#include <linux/mount.h>
Randy Dunlap16f7e0f2006-01-11 12:17:46 -080020#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <linux/dcache.h>
22#include <linux/mm.h>
Alexey Dobriyan4e950f62007-07-30 02:36:13 +040023#include <linux/err.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <linux/errno.h>
25#include <linux/dcookies.h>
Ingo Molnar353ab6e2006-03-26 01:37:12 -080026#include <linux/mutex.h>
Jan Blunck448678a2008-02-14 19:38:36 -080027#include <linux/path.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <asm/uaccess.h>
29
30/* The dcookies are allocated from a kmem_cache and
31 * hashed onto a small number of lists. None of the
32 * code here is particularly performance critical
33 */
34struct dcookie_struct {
Jan Blunck448678a2008-02-14 19:38:36 -080035 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -070036 struct list_head hash_list;
37};
38
39static LIST_HEAD(dcookie_users);
Ingo Molnar353ab6e2006-03-26 01:37:12 -080040static DEFINE_MUTEX(dcookie_mutex);
Christoph Lametere18b8902006-12-06 20:33:20 -080041static struct kmem_cache *dcookie_cache __read_mostly;
Eric Dumazetfa3536c2006-03-26 01:37:24 -080042static struct list_head *dcookie_hashtable __read_mostly;
43static size_t hash_size __read_mostly;
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
45static inline int is_live(void)
46{
47 return !(list_empty(&dcookie_users));
48}
49
50
51/* The dentry is locked, its address will do for the cookie */
52static inline unsigned long dcookie_value(struct dcookie_struct * dcs)
53{
Jan Blunck448678a2008-02-14 19:38:36 -080054 return (unsigned long)dcs->path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -070055}
56
57
58static size_t dcookie_hash(unsigned long dcookie)
59{
60 return (dcookie >> L1_CACHE_SHIFT) & (hash_size - 1);
61}
62
63
64static struct dcookie_struct * find_dcookie(unsigned long dcookie)
65{
66 struct dcookie_struct *found = NULL;
67 struct dcookie_struct * dcs;
68 struct list_head * pos;
69 struct list_head * list;
70
71 list = dcookie_hashtable + dcookie_hash(dcookie);
72
73 list_for_each(pos, list) {
74 dcs = list_entry(pos, struct dcookie_struct, hash_list);
75 if (dcookie_value(dcs) == dcookie) {
76 found = dcs;
77 break;
78 }
79 }
80
81 return found;
82}
83
84
85static void hash_dcookie(struct dcookie_struct * dcs)
86{
87 struct list_head * list = dcookie_hashtable + dcookie_hash(dcookie_value(dcs));
88 list_add(&dcs->hash_list, list);
89}
90
91
Jan Blunck448678a2008-02-14 19:38:36 -080092static struct dcookie_struct *alloc_dcookie(struct path *path)
Linus Torvalds1da177e2005-04-16 15:20:36 -070093{
Jan Blunck448678a2008-02-14 19:38:36 -080094 struct dcookie_struct *dcs = kmem_cache_alloc(dcookie_cache,
95 GFP_KERNEL);
Nick Pigginc2452f32008-12-01 09:33:43 +010096 struct dentry *d;
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 if (!dcs)
98 return NULL;
99
Nick Pigginc2452f32008-12-01 09:33:43 +0100100 d = path->dentry;
101 spin_lock(&d->d_lock);
102 d->d_flags |= DCACHE_COOKIE;
103 spin_unlock(&d->d_lock);
104
Jan Blunck448678a2008-02-14 19:38:36 -0800105 dcs->path = *path;
106 path_get(path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 hash_dcookie(dcs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 return dcs;
109}
110
111
112/* This is the main kernel-side routine that retrieves the cookie
113 * value for a dentry/vfsmnt pair.
114 */
Jan Blunck448678a2008-02-14 19:38:36 -0800115int get_dcookie(struct path *path, unsigned long *cookie)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116{
117 int err = 0;
118 struct dcookie_struct * dcs;
119
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800120 mutex_lock(&dcookie_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121
122 if (!is_live()) {
123 err = -EINVAL;
124 goto out;
125 }
126
Nick Pigginc2452f32008-12-01 09:33:43 +0100127 if (path->dentry->d_flags & DCACHE_COOKIE) {
128 dcs = find_dcookie((unsigned long)path->dentry);
129 } else {
Jan Blunck448678a2008-02-14 19:38:36 -0800130 dcs = alloc_dcookie(path);
Nick Pigginc2452f32008-12-01 09:33:43 +0100131 if (!dcs) {
132 err = -ENOMEM;
133 goto out;
134 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 }
136
137 *cookie = dcookie_value(dcs);
138
139out:
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800140 mutex_unlock(&dcookie_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 return err;
142}
143
144
145/* And here is where the userspace process can look up the cookie value
146 * to retrieve the path.
147 */
Heiko Carstens6673e0c2009-01-14 14:14:02 +0100148SYSCALL_DEFINE(lookup_dcookie)(u64 cookie64, char __user * buf, size_t len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149{
150 unsigned long cookie = (unsigned long)cookie64;
151 int err = -EINVAL;
152 char * kbuf;
153 char * path;
154 size_t pathlen;
155 struct dcookie_struct * dcs;
156
157 /* we could leak path information to users
158 * without dir read permission without this
159 */
160 if (!capable(CAP_SYS_ADMIN))
161 return -EPERM;
162
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800163 mutex_lock(&dcookie_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164
165 if (!is_live()) {
166 err = -EINVAL;
167 goto out;
168 }
169
170 if (!(dcs = find_dcookie(cookie)))
171 goto out;
172
173 err = -ENOMEM;
174 kbuf = kmalloc(PAGE_SIZE, GFP_KERNEL);
175 if (!kbuf)
176 goto out;
177
178 /* FIXME: (deleted) ? */
Jan Blunckcf28b482008-02-14 19:38:44 -0800179 path = d_path(&dcs->path, kbuf, PAGE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180
Robert Richterfe47ae72011-05-31 12:35:41 +0200181 mutex_unlock(&dcookie_mutex);
182
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 if (IS_ERR(path)) {
184 err = PTR_ERR(path);
185 goto out_free;
186 }
187
188 err = -ERANGE;
189
190 pathlen = kbuf + PAGE_SIZE - path;
191 if (pathlen <= len) {
192 err = pathlen;
193 if (copy_to_user(buf, path, pathlen))
194 err = -EFAULT;
195 }
196
197out_free:
198 kfree(kbuf);
Robert Richterfe47ae72011-05-31 12:35:41 +0200199 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200out:
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800201 mutex_unlock(&dcookie_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 return err;
203}
Heiko Carstens6673e0c2009-01-14 14:14:02 +0100204#ifdef CONFIG_HAVE_SYSCALL_WRAPPERS
205asmlinkage long SyS_lookup_dcookie(u64 cookie64, long buf, long len)
206{
207 return SYSC_lookup_dcookie(cookie64, (char __user *) buf, (size_t) len);
208}
209SYSCALL_ALIAS(sys_lookup_dcookie, SyS_lookup_dcookie);
210#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211
212static int dcookie_init(void)
213{
214 struct list_head * d;
215 unsigned int i, hash_bits;
216 int err = -ENOMEM;
217
218 dcookie_cache = kmem_cache_create("dcookie_cache",
219 sizeof(struct dcookie_struct),
Paul Mundt20c2df82007-07-20 10:11:58 +0900220 0, 0, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221
222 if (!dcookie_cache)
223 goto out;
224
225 dcookie_hashtable = kmalloc(PAGE_SIZE, GFP_KERNEL);
226 if (!dcookie_hashtable)
227 goto out_kmem;
228
229 err = 0;
230
231 /*
232 * Find the power-of-two list-heads that can fit into the allocation..
233 * We don't guarantee that "sizeof(struct list_head)" is necessarily
234 * a power-of-two.
235 */
236 hash_size = PAGE_SIZE / sizeof(struct list_head);
237 hash_bits = 0;
238 do {
239 hash_bits++;
240 } while ((hash_size >> hash_bits) != 0);
241 hash_bits--;
242
243 /*
244 * Re-calculate the actual number of entries and the mask
245 * from the number of bits we can fit.
246 */
247 hash_size = 1UL << hash_bits;
248
249 /* And initialize the newly allocated array */
250 d = dcookie_hashtable;
251 i = hash_size;
252 do {
253 INIT_LIST_HEAD(d);
254 d++;
255 i--;
256 } while (i);
257
258out:
259 return err;
260out_kmem:
261 kmem_cache_destroy(dcookie_cache);
262 goto out;
263}
264
265
266static void free_dcookie(struct dcookie_struct * dcs)
267{
Nick Pigginc2452f32008-12-01 09:33:43 +0100268 struct dentry *d = dcs->path.dentry;
269
270 spin_lock(&d->d_lock);
271 d->d_flags &= ~DCACHE_COOKIE;
272 spin_unlock(&d->d_lock);
273
Jan Blunck448678a2008-02-14 19:38:36 -0800274 path_put(&dcs->path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 kmem_cache_free(dcookie_cache, dcs);
276}
277
278
279static void dcookie_exit(void)
280{
281 struct list_head * list;
282 struct list_head * pos;
283 struct list_head * pos2;
284 struct dcookie_struct * dcs;
285 size_t i;
286
287 for (i = 0; i < hash_size; ++i) {
288 list = dcookie_hashtable + i;
289 list_for_each_safe(pos, pos2, list) {
290 dcs = list_entry(pos, struct dcookie_struct, hash_list);
291 list_del(&dcs->hash_list);
292 free_dcookie(dcs);
293 }
294 }
295
296 kfree(dcookie_hashtable);
297 kmem_cache_destroy(dcookie_cache);
298}
299
300
301struct dcookie_user {
302 struct list_head next;
303};
304
305struct dcookie_user * dcookie_register(void)
306{
307 struct dcookie_user * user;
308
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800309 mutex_lock(&dcookie_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310
311 user = kmalloc(sizeof(struct dcookie_user), GFP_KERNEL);
312 if (!user)
313 goto out;
314
315 if (!is_live() && dcookie_init())
316 goto out_free;
317
318 list_add(&user->next, &dcookie_users);
319
320out:
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800321 mutex_unlock(&dcookie_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 return user;
323out_free:
324 kfree(user);
325 user = NULL;
326 goto out;
327}
328
329
330void dcookie_unregister(struct dcookie_user * user)
331{
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800332 mutex_lock(&dcookie_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333
334 list_del(&user->next);
335 kfree(user);
336
337 if (!is_live())
338 dcookie_exit();
339
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800340 mutex_unlock(&dcookie_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341}
342
343EXPORT_SYMBOL_GPL(dcookie_register);
344EXPORT_SYMBOL_GPL(dcookie_unregister);
345EXPORT_SYMBOL_GPL(get_dcookie);