Contents of /alx-src/tags/kernel26-2.6.12-alx-r9/fs/dcookies.c
Parent Directory | Revision Log
Revision 630 -
(show annotations)
(download)
Wed Mar 4 11:03:09 2009 UTC (15 years, 6 months ago) by niro
File MIME type: text/plain
File size: 6446 byte(s)
Wed Mar 4 11:03:09 2009 UTC (15 years, 6 months ago) by niro
File MIME type: text/plain
File size: 6446 byte(s)
Tag kernel26-2.6.12-alx-r9
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/dcache.h> |
22 | #include <linux/mm.h> |
23 | #include <linux/errno.h> |
24 | #include <linux/dcookies.h> |
25 | #include <asm/uaccess.h> |
26 | |
27 | /* The dcookies are allocated from a kmem_cache and |
28 | * hashed onto a small number of lists. None of the |
29 | * code here is particularly performance critical |
30 | */ |
31 | struct dcookie_struct { |
32 | struct dentry * dentry; |
33 | struct vfsmount * vfsmnt; |
34 | struct list_head hash_list; |
35 | }; |
36 | |
37 | static LIST_HEAD(dcookie_users); |
38 | static DECLARE_MUTEX(dcookie_sem); |
39 | static kmem_cache_t * dcookie_cache; |
40 | static struct list_head * dcookie_hashtable; |
41 | static size_t hash_size; |
42 | |
43 | static inline int is_live(void) |
44 | { |
45 | return !(list_empty(&dcookie_users)); |
46 | } |
47 | |
48 | |
49 | /* The dentry is locked, its address will do for the cookie */ |
50 | static inline unsigned long dcookie_value(struct dcookie_struct * dcs) |
51 | { |
52 | return (unsigned long)dcs->dentry; |
53 | } |
54 | |
55 | |
56 | static size_t dcookie_hash(unsigned long dcookie) |
57 | { |
58 | return (dcookie >> L1_CACHE_SHIFT) & (hash_size - 1); |
59 | } |
60 | |
61 | |
62 | static struct dcookie_struct * find_dcookie(unsigned long dcookie) |
63 | { |
64 | struct dcookie_struct *found = NULL; |
65 | struct dcookie_struct * dcs; |
66 | struct list_head * pos; |
67 | struct list_head * list; |
68 | |
69 | list = dcookie_hashtable + dcookie_hash(dcookie); |
70 | |
71 | list_for_each(pos, list) { |
72 | dcs = list_entry(pos, struct dcookie_struct, hash_list); |
73 | if (dcookie_value(dcs) == dcookie) { |
74 | found = dcs; |
75 | break; |
76 | } |
77 | } |
78 | |
79 | return found; |
80 | } |
81 | |
82 | |
83 | static void hash_dcookie(struct dcookie_struct * dcs) |
84 | { |
85 | struct list_head * list = dcookie_hashtable + dcookie_hash(dcookie_value(dcs)); |
86 | list_add(&dcs->hash_list, list); |
87 | } |
88 | |
89 | |
90 | static struct dcookie_struct * alloc_dcookie(struct dentry * dentry, |
91 | struct vfsmount * vfsmnt) |
92 | { |
93 | struct dcookie_struct * dcs = kmem_cache_alloc(dcookie_cache, GFP_KERNEL); |
94 | if (!dcs) |
95 | return NULL; |
96 | |
97 | atomic_inc(&dentry->d_count); |
98 | atomic_inc(&vfsmnt->mnt_count); |
99 | dentry->d_cookie = dcs; |
100 | |
101 | dcs->dentry = dentry; |
102 | dcs->vfsmnt = vfsmnt; |
103 | 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 | */ |
112 | int get_dcookie(struct dentry * dentry, struct vfsmount * vfsmnt, |
113 | unsigned long * cookie) |
114 | { |
115 | int err = 0; |
116 | struct dcookie_struct * dcs; |
117 | |
118 | down(&dcookie_sem); |
119 | |
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 | |
137 | out: |
138 | up(&dcookie_sem); |
139 | 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 | */ |
146 | asmlinkage 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 | |
161 | down(&dcookie_sem); |
162 | |
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 | |
193 | out_free: |
194 | kfree(kbuf); |
195 | out: |
196 | up(&dcookie_sem); |
197 | return err; |
198 | } |
199 | |
200 | |
201 | static 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), |
209 | 0, 0, NULL, NULL); |
210 | |
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 | |
247 | out: |
248 | return err; |
249 | out_kmem: |
250 | kmem_cache_destroy(dcookie_cache); |
251 | goto out; |
252 | } |
253 | |
254 | |
255 | static 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 | |
264 | static 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 | |
286 | struct dcookie_user { |
287 | struct list_head next; |
288 | }; |
289 | |
290 | struct dcookie_user * dcookie_register(void) |
291 | { |
292 | struct dcookie_user * user; |
293 | |
294 | down(&dcookie_sem); |
295 | |
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 | |
305 | out: |
306 | up(&dcookie_sem); |
307 | return user; |
308 | out_free: |
309 | kfree(user); |
310 | user = NULL; |
311 | goto out; |
312 | } |
313 | |
314 | |
315 | void dcookie_unregister(struct dcookie_user * user) |
316 | { |
317 | down(&dcookie_sem); |
318 | |
319 | list_del(&user->next); |
320 | kfree(user); |
321 | |
322 | if (!is_live()) |
323 | dcookie_exit(); |
324 | |
325 | up(&dcookie_sem); |
326 | } |
327 | |
328 | EXPORT_SYMBOL_GPL(dcookie_register); |
329 | EXPORT_SYMBOL_GPL(dcookie_unregister); |
330 | EXPORT_SYMBOL_GPL(get_dcookie); |