4 * Copyright 2002 John Levon <levon@movementarian.org>
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.
15 #include <linux/syscalls.h>
16 #include <linux/module.h>
17 #include <linux/slab.h>
18 #include <linux/list.h>
19 #include <linux/mount.h>
20 #include <linux/capability.h>
21 #include <linux/dcache.h>
23 #include <linux/err.h>
24 #include <linux/errno.h>
25 #include <linux/dcookies.h>
26 #include <linux/mutex.h>
27 #include <linux/path.h>
28 #include <asm/uaccess.h>
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
34 struct dcookie_struct
{
36 struct list_head hash_list
;
39 static LIST_HEAD(dcookie_users
);
40 static DEFINE_MUTEX(dcookie_mutex
);
41 static struct kmem_cache
*dcookie_cache __read_mostly
;
42 static struct list_head
*dcookie_hashtable __read_mostly
;
43 static size_t hash_size __read_mostly
;
45 static inline int is_live(void)
47 return !(list_empty(&dcookie_users
));
51 /* The dentry is locked, its address will do for the cookie */
52 static inline unsigned long dcookie_value(struct dcookie_struct
* dcs
)
54 return (unsigned long)dcs
->path
.dentry
;
58 static size_t dcookie_hash(unsigned long dcookie
)
60 return (dcookie
>> L1_CACHE_SHIFT
) & (hash_size
- 1);
64 static struct dcookie_struct
* find_dcookie(unsigned long dcookie
)
66 struct dcookie_struct
*found
= NULL
;
67 struct dcookie_struct
* dcs
;
68 struct list_head
* pos
;
69 struct list_head
* list
;
71 list
= dcookie_hashtable
+ dcookie_hash(dcookie
);
73 list_for_each(pos
, list
) {
74 dcs
= list_entry(pos
, struct dcookie_struct
, hash_list
);
75 if (dcookie_value(dcs
) == dcookie
) {
85 static void hash_dcookie(struct dcookie_struct
* dcs
)
87 struct list_head
* list
= dcookie_hashtable
+ dcookie_hash(dcookie_value(dcs
));
88 list_add(&dcs
->hash_list
, list
);
92 static struct dcookie_struct
*alloc_dcookie(struct path
*path
)
94 struct dcookie_struct
*dcs
= kmem_cache_alloc(dcookie_cache
,
101 spin_lock(&d
->d_lock
);
102 d
->d_flags
|= DCACHE_COOKIE
;
103 spin_unlock(&d
->d_lock
);
112 /* This is the main kernel-side routine that retrieves the cookie
113 * value for a dentry/vfsmnt pair.
115 int get_dcookie(struct path
*path
, unsigned long *cookie
)
118 struct dcookie_struct
* dcs
;
120 mutex_lock(&dcookie_mutex
);
127 if (path
->dentry
->d_flags
& DCACHE_COOKIE
) {
128 dcs
= find_dcookie((unsigned long)path
->dentry
);
130 dcs
= alloc_dcookie(path
);
137 *cookie
= dcookie_value(dcs
);
140 mutex_unlock(&dcookie_mutex
);
145 /* And here is where the userspace process can look up the cookie value
146 * to retrieve the path.
148 SYSCALL_DEFINE(lookup_dcookie
)(u64 cookie64
, char __user
* buf
, size_t len
)
150 unsigned long cookie
= (unsigned long)cookie64
;
155 struct dcookie_struct
* dcs
;
157 /* we could leak path information to users
158 * without dir read permission without this
160 if (!capable(CAP_SYS_ADMIN
))
163 mutex_lock(&dcookie_mutex
);
170 if (!(dcs
= find_dcookie(cookie
)))
174 kbuf
= kmalloc(PAGE_SIZE
, GFP_KERNEL
);
178 /* FIXME: (deleted) ? */
179 path
= d_path(&dcs
->path
, kbuf
, PAGE_SIZE
);
188 pathlen
= kbuf
+ PAGE_SIZE
- path
;
189 if (pathlen
<= len
) {
191 if (copy_to_user(buf
, path
, pathlen
))
198 mutex_unlock(&dcookie_mutex
);
201 #ifdef CONFIG_HAVE_SYSCALL_WRAPPERS
202 asmlinkage
long SyS_lookup_dcookie(u64 cookie64
, long buf
, long len
)
204 return SYSC_lookup_dcookie(cookie64
, (char __user
*) buf
, (size_t) len
);
206 SYSCALL_ALIAS(sys_lookup_dcookie
, SyS_lookup_dcookie
);
209 static int dcookie_init(void)
211 struct list_head
* d
;
212 unsigned int i
, hash_bits
;
215 dcookie_cache
= kmem_cache_create("dcookie_cache",
216 sizeof(struct dcookie_struct
),
222 dcookie_hashtable
= kmalloc(PAGE_SIZE
, GFP_KERNEL
);
223 if (!dcookie_hashtable
)
229 * Find the power-of-two list-heads that can fit into the allocation..
230 * We don't guarantee that "sizeof(struct list_head)" is necessarily
233 hash_size
= PAGE_SIZE
/ sizeof(struct list_head
);
237 } while ((hash_size
>> hash_bits
) != 0);
241 * Re-calculate the actual number of entries and the mask
242 * from the number of bits we can fit.
244 hash_size
= 1UL << hash_bits
;
246 /* And initialize the newly allocated array */
247 d
= dcookie_hashtable
;
258 kmem_cache_destroy(dcookie_cache
);
263 static void free_dcookie(struct dcookie_struct
* dcs
)
265 struct dentry
*d
= dcs
->path
.dentry
;
267 spin_lock(&d
->d_lock
);
268 d
->d_flags
&= ~DCACHE_COOKIE
;
269 spin_unlock(&d
->d_lock
);
271 path_put(&dcs
->path
);
272 kmem_cache_free(dcookie_cache
, dcs
);
276 static void dcookie_exit(void)
278 struct list_head
* list
;
279 struct list_head
* pos
;
280 struct list_head
* pos2
;
281 struct dcookie_struct
* dcs
;
284 for (i
= 0; i
< hash_size
; ++i
) {
285 list
= dcookie_hashtable
+ i
;
286 list_for_each_safe(pos
, pos2
, list
) {
287 dcs
= list_entry(pos
, struct dcookie_struct
, hash_list
);
288 list_del(&dcs
->hash_list
);
293 kfree(dcookie_hashtable
);
294 kmem_cache_destroy(dcookie_cache
);
298 struct dcookie_user
{
299 struct list_head next
;
302 struct dcookie_user
* dcookie_register(void)
304 struct dcookie_user
* user
;
306 mutex_lock(&dcookie_mutex
);
308 user
= kmalloc(sizeof(struct dcookie_user
), GFP_KERNEL
);
312 if (!is_live() && dcookie_init())
315 list_add(&user
->next
, &dcookie_users
);
318 mutex_unlock(&dcookie_mutex
);
327 void dcookie_unregister(struct dcookie_user
* user
)
329 mutex_lock(&dcookie_mutex
);
331 list_del(&user
->next
);
337 mutex_unlock(&dcookie_mutex
);
340 EXPORT_SYMBOL_GPL(dcookie_register
);
341 EXPORT_SYMBOL_GPL(dcookie_unregister
);
342 EXPORT_SYMBOL_GPL(get_dcookie
);