Commit | Line | Data |
---|---|---|
1da177e4 LT |
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 | ||
1da177e4 | 15 | #include <linux/syscalls.h> |
630d9c47 | 16 | #include <linux/export.h> |
1da177e4 LT |
17 | #include <linux/slab.h> |
18 | #include <linux/list.h> | |
19 | #include <linux/mount.h> | |
16f7e0fe | 20 | #include <linux/capability.h> |
1da177e4 LT |
21 | #include <linux/dcache.h> |
22 | #include <linux/mm.h> | |
4e950f6f | 23 | #include <linux/err.h> |
1da177e4 LT |
24 | #include <linux/errno.h> |
25 | #include <linux/dcookies.h> | |
353ab6e9 | 26 | #include <linux/mutex.h> |
448678a0 | 27 | #include <linux/path.h> |
1da177e4 LT |
28 | #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 | */ | |
34 | struct dcookie_struct { | |
448678a0 | 35 | struct path path; |
1da177e4 LT |
36 | struct list_head hash_list; |
37 | }; | |
38 | ||
39 | static LIST_HEAD(dcookie_users); | |
353ab6e9 | 40 | static DEFINE_MUTEX(dcookie_mutex); |
e18b890b | 41 | static struct kmem_cache *dcookie_cache __read_mostly; |
fa3536cc ED |
42 | static struct list_head *dcookie_hashtable __read_mostly; |
43 | static size_t hash_size __read_mostly; | |
1da177e4 LT |
44 | |
45 | static 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 */ | |
52 | static inline unsigned long dcookie_value(struct dcookie_struct * dcs) | |
53 | { | |
448678a0 | 54 | return (unsigned long)dcs->path.dentry; |
1da177e4 LT |
55 | } |
56 | ||
57 | ||
58 | static size_t dcookie_hash(unsigned long dcookie) | |
59 | { | |
60 | return (dcookie >> L1_CACHE_SHIFT) & (hash_size - 1); | |
61 | } | |
62 | ||
63 | ||
64 | static 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 | ||
85 | static 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 | ||
448678a0 | 92 | static struct dcookie_struct *alloc_dcookie(struct path *path) |
1da177e4 | 93 | { |
448678a0 JB |
94 | struct dcookie_struct *dcs = kmem_cache_alloc(dcookie_cache, |
95 | GFP_KERNEL); | |
c2452f32 | 96 | struct dentry *d; |
1da177e4 LT |
97 | if (!dcs) |
98 | return NULL; | |
99 | ||
c2452f32 NP |
100 | d = path->dentry; |
101 | spin_lock(&d->d_lock); | |
102 | d->d_flags |= DCACHE_COOKIE; | |
103 | spin_unlock(&d->d_lock); | |
104 | ||
448678a0 JB |
105 | dcs->path = *path; |
106 | path_get(path); | |
1da177e4 | 107 | hash_dcookie(dcs); |
1da177e4 LT |
108 | 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 | */ | |
448678a0 | 115 | int get_dcookie(struct path *path, unsigned long *cookie) |
1da177e4 LT |
116 | { |
117 | int err = 0; | |
118 | struct dcookie_struct * dcs; | |
119 | ||
353ab6e9 | 120 | mutex_lock(&dcookie_mutex); |
1da177e4 LT |
121 | |
122 | if (!is_live()) { | |
123 | err = -EINVAL; | |
124 | goto out; | |
125 | } | |
126 | ||
c2452f32 NP |
127 | if (path->dentry->d_flags & DCACHE_COOKIE) { |
128 | dcs = find_dcookie((unsigned long)path->dentry); | |
129 | } else { | |
448678a0 | 130 | dcs = alloc_dcookie(path); |
c2452f32 NP |
131 | if (!dcs) { |
132 | err = -ENOMEM; | |
133 | goto out; | |
134 | } | |
1da177e4 LT |
135 | } |
136 | ||
137 | *cookie = dcookie_value(dcs); | |
138 | ||
139 | out: | |
353ab6e9 | 140 | mutex_unlock(&dcookie_mutex); |
1da177e4 LT |
141 | 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 | */ | |
4a0fd5bf | 148 | SYSCALL_DEFINE3(lookup_dcookie, u64, cookie64, char __user *, buf, size_t, len) |
1da177e4 LT |
149 | { |
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 | ||
353ab6e9 | 163 | mutex_lock(&dcookie_mutex); |
1da177e4 LT |
164 | |
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) ? */ | |
cf28b486 | 179 | path = d_path(&dcs->path, kbuf, PAGE_SIZE); |
1da177e4 | 180 | |
fe47ae7f RR |
181 | mutex_unlock(&dcookie_mutex); |
182 | ||
1da177e4 LT |
183 | 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 | ||
197 | out_free: | |
198 | kfree(kbuf); | |
fe47ae7f | 199 | return err; |
1da177e4 | 200 | out: |
353ab6e9 | 201 | mutex_unlock(&dcookie_mutex); |
1da177e4 LT |
202 | return err; |
203 | } | |
1da177e4 LT |
204 | |
205 | static int dcookie_init(void) | |
206 | { | |
207 | struct list_head * d; | |
208 | unsigned int i, hash_bits; | |
209 | int err = -ENOMEM; | |
210 | ||
211 | dcookie_cache = kmem_cache_create("dcookie_cache", | |
212 | sizeof(struct dcookie_struct), | |
20c2df83 | 213 | 0, 0, NULL); |
1da177e4 LT |
214 | |
215 | if (!dcookie_cache) | |
216 | goto out; | |
217 | ||
218 | dcookie_hashtable = kmalloc(PAGE_SIZE, GFP_KERNEL); | |
219 | if (!dcookie_hashtable) | |
220 | goto out_kmem; | |
221 | ||
222 | err = 0; | |
223 | ||
224 | /* | |
225 | * Find the power-of-two list-heads that can fit into the allocation.. | |
226 | * We don't guarantee that "sizeof(struct list_head)" is necessarily | |
227 | * a power-of-two. | |
228 | */ | |
229 | hash_size = PAGE_SIZE / sizeof(struct list_head); | |
230 | hash_bits = 0; | |
231 | do { | |
232 | hash_bits++; | |
233 | } while ((hash_size >> hash_bits) != 0); | |
234 | hash_bits--; | |
235 | ||
236 | /* | |
237 | * Re-calculate the actual number of entries and the mask | |
238 | * from the number of bits we can fit. | |
239 | */ | |
240 | hash_size = 1UL << hash_bits; | |
241 | ||
242 | /* And initialize the newly allocated array */ | |
243 | d = dcookie_hashtable; | |
244 | i = hash_size; | |
245 | do { | |
246 | INIT_LIST_HEAD(d); | |
247 | d++; | |
248 | i--; | |
249 | } while (i); | |
250 | ||
251 | out: | |
252 | return err; | |
253 | out_kmem: | |
254 | kmem_cache_destroy(dcookie_cache); | |
255 | goto out; | |
256 | } | |
257 | ||
258 | ||
259 | static void free_dcookie(struct dcookie_struct * dcs) | |
260 | { | |
c2452f32 NP |
261 | struct dentry *d = dcs->path.dentry; |
262 | ||
263 | spin_lock(&d->d_lock); | |
264 | d->d_flags &= ~DCACHE_COOKIE; | |
265 | spin_unlock(&d->d_lock); | |
266 | ||
448678a0 | 267 | path_put(&dcs->path); |
1da177e4 LT |
268 | kmem_cache_free(dcookie_cache, dcs); |
269 | } | |
270 | ||
271 | ||
272 | static void dcookie_exit(void) | |
273 | { | |
274 | struct list_head * list; | |
275 | struct list_head * pos; | |
276 | struct list_head * pos2; | |
277 | struct dcookie_struct * dcs; | |
278 | size_t i; | |
279 | ||
280 | for (i = 0; i < hash_size; ++i) { | |
281 | list = dcookie_hashtable + i; | |
282 | list_for_each_safe(pos, pos2, list) { | |
283 | dcs = list_entry(pos, struct dcookie_struct, hash_list); | |
284 | list_del(&dcs->hash_list); | |
285 | free_dcookie(dcs); | |
286 | } | |
287 | } | |
288 | ||
289 | kfree(dcookie_hashtable); | |
290 | kmem_cache_destroy(dcookie_cache); | |
291 | } | |
292 | ||
293 | ||
294 | struct dcookie_user { | |
295 | struct list_head next; | |
296 | }; | |
297 | ||
298 | struct dcookie_user * dcookie_register(void) | |
299 | { | |
300 | struct dcookie_user * user; | |
301 | ||
353ab6e9 | 302 | mutex_lock(&dcookie_mutex); |
1da177e4 LT |
303 | |
304 | user = kmalloc(sizeof(struct dcookie_user), GFP_KERNEL); | |
305 | if (!user) | |
306 | goto out; | |
307 | ||
308 | if (!is_live() && dcookie_init()) | |
309 | goto out_free; | |
310 | ||
311 | list_add(&user->next, &dcookie_users); | |
312 | ||
313 | out: | |
353ab6e9 | 314 | mutex_unlock(&dcookie_mutex); |
1da177e4 LT |
315 | return user; |
316 | out_free: | |
317 | kfree(user); | |
318 | user = NULL; | |
319 | goto out; | |
320 | } | |
321 | ||
322 | ||
323 | void dcookie_unregister(struct dcookie_user * user) | |
324 | { | |
353ab6e9 | 325 | mutex_lock(&dcookie_mutex); |
1da177e4 LT |
326 | |
327 | list_del(&user->next); | |
328 | kfree(user); | |
329 | ||
330 | if (!is_live()) | |
331 | dcookie_exit(); | |
332 | ||
353ab6e9 | 333 | mutex_unlock(&dcookie_mutex); |
1da177e4 LT |
334 | } |
335 | ||
336 | EXPORT_SYMBOL_GPL(dcookie_register); | |
337 | EXPORT_SYMBOL_GPL(dcookie_unregister); | |
338 | EXPORT_SYMBOL_GPL(get_dcookie); |