blob: 792cbf55fa9592cefbd6b2446ed26d573301beee [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>
16#include <linux/module.h>
17#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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <asm/uaccess.h>
28
29/* The dcookies are allocated from a kmem_cache and
30 * hashed onto a small number of lists. None of the
31 * code here is particularly performance critical
32 */
33struct dcookie_struct {
34 struct dentry * dentry;
35 struct vfsmount * vfsmnt;
36 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{
54 return (unsigned long)dcs->dentry;
55}
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
92static struct dcookie_struct * alloc_dcookie(struct dentry * dentry,
93 struct vfsmount * vfsmnt)
94{
95 struct dcookie_struct * dcs = kmem_cache_alloc(dcookie_cache, GFP_KERNEL);
96 if (!dcs)
97 return NULL;
98
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 dentry->d_cookie = dcs;
100
Miklos Szeredi732dbef62005-07-07 17:57:29 -0700101 dcs->dentry = dget(dentry);
102 dcs->vfsmnt = mntget(vfsmnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 hash_dcookie(dcs);
104
105 return dcs;
106}
107
108
109/* This is the main kernel-side routine that retrieves the cookie
110 * value for a dentry/vfsmnt pair.
111 */
112int get_dcookie(struct dentry * dentry, struct vfsmount * vfsmnt,
113 unsigned long * cookie)
114{
115 int err = 0;
116 struct dcookie_struct * dcs;
117
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800118 mutex_lock(&dcookie_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119
120 if (!is_live()) {
121 err = -EINVAL;
122 goto out;
123 }
124
125 dcs = dentry->d_cookie;
126
127 if (!dcs)
128 dcs = alloc_dcookie(dentry, vfsmnt);
129
130 if (!dcs) {
131 err = -ENOMEM;
132 goto out;
133 }
134
135 *cookie = dcookie_value(dcs);
136
137out:
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800138 mutex_unlock(&dcookie_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 return err;
140}
141
142
143/* And here is where the userspace process can look up the cookie value
144 * to retrieve the path.
145 */
146asmlinkage long sys_lookup_dcookie(u64 cookie64, char __user * buf, size_t len)
147{
148 unsigned long cookie = (unsigned long)cookie64;
149 int err = -EINVAL;
150 char * kbuf;
151 char * path;
152 size_t pathlen;
153 struct dcookie_struct * dcs;
154
155 /* we could leak path information to users
156 * without dir read permission without this
157 */
158 if (!capable(CAP_SYS_ADMIN))
159 return -EPERM;
160
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800161 mutex_lock(&dcookie_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162
163 if (!is_live()) {
164 err = -EINVAL;
165 goto out;
166 }
167
168 if (!(dcs = find_dcookie(cookie)))
169 goto out;
170
171 err = -ENOMEM;
172 kbuf = kmalloc(PAGE_SIZE, GFP_KERNEL);
173 if (!kbuf)
174 goto out;
175
176 /* FIXME: (deleted) ? */
177 path = d_path(dcs->dentry, dcs->vfsmnt, kbuf, PAGE_SIZE);
178
179 if (IS_ERR(path)) {
180 err = PTR_ERR(path);
181 goto out_free;
182 }
183
184 err = -ERANGE;
185
186 pathlen = kbuf + PAGE_SIZE - path;
187 if (pathlen <= len) {
188 err = pathlen;
189 if (copy_to_user(buf, path, pathlen))
190 err = -EFAULT;
191 }
192
193out_free:
194 kfree(kbuf);
195out:
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800196 mutex_unlock(&dcookie_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 return err;
198}
199
200
201static int dcookie_init(void)
202{
203 struct list_head * d;
204 unsigned int i, hash_bits;
205 int err = -ENOMEM;
206
207 dcookie_cache = kmem_cache_create("dcookie_cache",
208 sizeof(struct dcookie_struct),
Paul Mundt20c2df82007-07-20 10:11:58 +0900209 0, 0, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210
211 if (!dcookie_cache)
212 goto out;
213
214 dcookie_hashtable = kmalloc(PAGE_SIZE, GFP_KERNEL);
215 if (!dcookie_hashtable)
216 goto out_kmem;
217
218 err = 0;
219
220 /*
221 * Find the power-of-two list-heads that can fit into the allocation..
222 * We don't guarantee that "sizeof(struct list_head)" is necessarily
223 * a power-of-two.
224 */
225 hash_size = PAGE_SIZE / sizeof(struct list_head);
226 hash_bits = 0;
227 do {
228 hash_bits++;
229 } while ((hash_size >> hash_bits) != 0);
230 hash_bits--;
231
232 /*
233 * Re-calculate the actual number of entries and the mask
234 * from the number of bits we can fit.
235 */
236 hash_size = 1UL << hash_bits;
237
238 /* And initialize the newly allocated array */
239 d = dcookie_hashtable;
240 i = hash_size;
241 do {
242 INIT_LIST_HEAD(d);
243 d++;
244 i--;
245 } while (i);
246
247out:
248 return err;
249out_kmem:
250 kmem_cache_destroy(dcookie_cache);
251 goto out;
252}
253
254
255static void free_dcookie(struct dcookie_struct * dcs)
256{
257 dcs->dentry->d_cookie = NULL;
258 dput(dcs->dentry);
259 mntput(dcs->vfsmnt);
260 kmem_cache_free(dcookie_cache, dcs);
261}
262
263
264static void dcookie_exit(void)
265{
266 struct list_head * list;
267 struct list_head * pos;
268 struct list_head * pos2;
269 struct dcookie_struct * dcs;
270 size_t i;
271
272 for (i = 0; i < hash_size; ++i) {
273 list = dcookie_hashtable + i;
274 list_for_each_safe(pos, pos2, list) {
275 dcs = list_entry(pos, struct dcookie_struct, hash_list);
276 list_del(&dcs->hash_list);
277 free_dcookie(dcs);
278 }
279 }
280
281 kfree(dcookie_hashtable);
282 kmem_cache_destroy(dcookie_cache);
283}
284
285
286struct dcookie_user {
287 struct list_head next;
288};
289
290struct dcookie_user * dcookie_register(void)
291{
292 struct dcookie_user * user;
293
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800294 mutex_lock(&dcookie_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295
296 user = kmalloc(sizeof(struct dcookie_user), GFP_KERNEL);
297 if (!user)
298 goto out;
299
300 if (!is_live() && dcookie_init())
301 goto out_free;
302
303 list_add(&user->next, &dcookie_users);
304
305out:
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800306 mutex_unlock(&dcookie_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 return user;
308out_free:
309 kfree(user);
310 user = NULL;
311 goto out;
312}
313
314
315void dcookie_unregister(struct dcookie_user * user)
316{
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800317 mutex_lock(&dcookie_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318
319 list_del(&user->next);
320 kfree(user);
321
322 if (!is_live())
323 dcookie_exit();
324
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800325 mutex_unlock(&dcookie_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326}
327
328EXPORT_SYMBOL_GPL(dcookie_register);
329EXPORT_SYMBOL_GPL(dcookie_unregister);
330EXPORT_SYMBOL_GPL(get_dcookie);