1 /* $NetBSD: kern_fileassoc.c,v 1.31 2008/05/05 17:11:17 ad Exp $ */
2
3 /*-
4 * Copyright (c) 2006 Elad Efrat <elad@NetBSD.org>
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. The name of the author may not be used to endorse or promote products
16 * derived from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30 #include <sys/cdefs.h>
31 __KERNEL_RCSID(0, "$NetBSD: kern_fileassoc.c,v 1.31 2008/05/05 17:11:17 ad Exp $");
32
33 #include "opt_fileassoc.h"
34
35 #include <sys/param.h>
36 #include <sys/mount.h>
37 #include <sys/queue.h>
38 #include <sys/vnode.h>
39 #include <sys/namei.h>
40 #include <sys/exec.h>
41 #include <sys/proc.h>
42 #include <sys/inttypes.h>
43 #include <sys/errno.h>
44 #include <sys/fileassoc.h>
45 #include <sys/specificdata.h>
46 #include <sys/hash.h>
47 #include <sys/fstypes.h>
48 #include <sys/kmem.h>
49 #include <sys/once.h>
50
51 #define FILEASSOC_INITIAL_TABLESIZE 128
52
53 static struct fileassoc_hash_entry *
54 fileassoc_file_lookup(struct vnode *, fhandle_t *);
55 static struct fileassoc_hash_entry *
56 fileassoc_file_add(struct vnode *, fhandle_t *);
57 static struct fileassoc_table *fileassoc_table_resize(struct fileassoc_table *);
58
59 static specificdata_domain_t fileassoc_domain;
60 static specificdata_key_t fileassoc_mountspecific_key;
61 static ONCE_DECL(control);
62
63 /*
64 * Hook entry.
65 * Includes the hook name for identification and private hook clear callback.
66 */
67 struct fileassoc {
68 LIST_ENTRY(fileassoc) list;
69 const char *name; /* name. */
70 fileassoc_cleanup_cb_t cleanup_cb; /* clear callback. */
71 specificdata_key_t key;
72 };
73
74 static LIST_HEAD(, fileassoc) fileassoc_list;
75
76 /* An entry in the per-mount hash table. */
77 struct fileassoc_hash_entry {
78 fhandle_t *handle; /* File handle */
79 specificdata_reference data; /* Hooks. */
80 u_int nassocs; /* # of hooks. */
81 LIST_ENTRY(fileassoc_hash_entry) entries; /* List pointer. */
82 };
83
84 LIST_HEAD(fileassoc_hashhead, fileassoc_hash_entry);
85
86 struct fileassoc_table {
87 struct fileassoc_hashhead *hash_tbl;
88 size_t hash_size; /* Number of slots. */
89 u_long hash_mask;
90 size_t hash_used; /* # of used slots. */
91 specificdata_reference data;
92 };
93
94 /*
95 * Hashing function: Takes a number modulus the mask to give back an
96 * index into the hash table.
97 */
98 #define FILEASSOC_HASH(tbl, handle) \
99 (hash32_buf((handle), FHANDLE_SIZE(handle), HASH32_BUF_INIT) \
100 & ((tbl)->hash_mask))
101
102 static void *
103 file_getdata(struct fileassoc_hash_entry *e, const struct fileassoc *assoc)
104 {
105
106 return specificdata_getspecific(fileassoc_domain, &e->data,
107 assoc->key);
108 }
109
110 static void
111 file_setdata(struct fileassoc_hash_entry *e, const struct fileassoc *assoc,
112 void *data)
113 {
114
115 specificdata_setspecific(fileassoc_domain, &e->data, assoc->key,
116 data);
117 }
118
119 static void
120 file_cleanup(struct fileassoc_hash_entry *e, const struct fileassoc *assoc)
121 {
122 fileassoc_cleanup_cb_t cb;
123 void *data;
124
125 cb = assoc->cleanup_cb;
126 if (cb == NULL) {
127 return;
128 }
129 data = file_getdata(e, assoc);
130 (*cb)(data);
131 }
132
133 static void
134 file_free(struct fileassoc_hash_entry *e)
135 {
136 struct fileassoc *assoc;
137
138 LIST_REMOVE(e, entries);
139
140 LIST_FOREACH(assoc, &fileassoc_list, list) {
141 file_cleanup(e, assoc);
142 }
143 vfs_composefh_free(e->handle);
144 specificdata_fini(fileassoc_domain, &e->data);
145 kmem_free(e, sizeof(*e));
146 }
147
148 static void
149 table_dtor(void *vp)
150 {
151 struct fileassoc_table *tbl = vp;
152 struct fileassoc_hashhead *hh;
153 u_long i;
154
155 /* Remove all entries from the table and lists */
156 hh = tbl->hash_tbl;
157 for (i = 0; i < tbl->hash_size; i++) {
158 struct fileassoc_hash_entry *mhe;
159
160 while ((mhe = LIST_FIRST(&hh[i])) != NULL) {
161 file_free(mhe);
162 }
163 }
164
165 /* Remove hash table and sysctl node */
166 hashdone(tbl->hash_tbl, HASH_LIST, tbl->hash_mask);
167 specificdata_fini(fileassoc_domain, &tbl->data);
168 kmem_free(tbl, sizeof(*tbl));
169 }
170
171 /*
172 * Initialize the fileassoc subsystem.
173 */
174 static int
175 fileassoc_init(void)
176 {
177 int error;
178
179 error = mount_specific_key_create(&fileassoc_mountspecific_key,
180 table_dtor);
181 if (error) {
182 return error;
183 }
184 fileassoc_domain = specificdata_domain_create();
185
186 return 0;
187 }
188
189 /*
190 * Register a new hook.
191 */
192 int
193 fileassoc_register(const char *name, fileassoc_cleanup_cb_t cleanup_cb,
194 fileassoc_t *result)
195 {
196 int error;
197 specificdata_key_t key;
198 struct fileassoc *assoc;
199
200 error = RUN_ONCE(&control, fileassoc_init);
201 if (error) {
202 return error;
203 }
204 error = specificdata_key_create(fileassoc_domain, &key, NULL);
205 if (error) {
206 return error;
207 }
208 assoc = kmem_alloc(sizeof(*assoc), KM_SLEEP);
209 assoc->name = name;
210 assoc->cleanup_cb = cleanup_cb;
211 assoc->key = key;
212 LIST_INSERT_HEAD(&fileassoc_list, assoc, list);
213 *result = assoc;
214
215 return 0;
216 }
217
218 /*
219 * Deregister a hook.
220 */
221 int
222 fileassoc_deregister(fileassoc_t assoc)
223 {
224
225 LIST_REMOVE(assoc, list);
226 specificdata_key_delete(fileassoc_domain, assoc->key);
227 kmem_free(assoc, sizeof(*assoc));
228
229 return 0;
230 }
231
232 /*
233 * Get the hash table for the specified device.
234 */
235 static struct fileassoc_table *
236 fileassoc_table_lookup(struct mount *mp)
237 {
238 int error;
239
240 error = RUN_ONCE(&control, fileassoc_init);
241 if (error) {
242 return NULL;
243 }
244 return mount_getspecific(mp, fileassoc_mountspecific_key);
245 }
246
247 /*
248 * Perform a lookup on a hash table. If hint is non-zero then use the value
249 * of the hint as the identifier instead of performing a lookup for the
250 * fileid.
251 */
252 static struct fileassoc_hash_entry *
253 fileassoc_file_lookup(struct vnode *vp, fhandle_t *hint)
254 {
255 struct fileassoc_table *tbl;
256 struct fileassoc_hashhead *tble;
257 struct fileassoc_hash_entry *e;
258 size_t indx;
259 fhandle_t *th;
260 int error;
261
262 tbl = fileassoc_table_lookup(vp->v_mount);
263 if (tbl == NULL) {
264 return NULL;
265 }
266
267 if (hint == NULL) {
268 error = vfs_composefh_alloc(vp, &th);
269 if (error)
270 return (NULL);
271 } else {
272 th = hint;
273 }
274
275 indx = FILEASSOC_HASH(tbl, th);
276 tble = &(tbl->hash_tbl[indx]);
277
278 LIST_FOREACH(e, tble, entries) {
279 if (((FHANDLE_FILEID(e->handle)->fid_len ==
280 FHANDLE_FILEID(th)->fid_len)) &&
281 (memcmp(FHANDLE_FILEID(e->handle), FHANDLE_FILEID(th),
282 (FHANDLE_FILEID(th))->fid_len) == 0)) {
283 break;
284 }
285 }
286
287 if (hint == NULL)
288 vfs_composefh_free(th);
289
290 return e;
291 }
292
293 /*
294 * Return hook data associated with a vnode.
295 */
296 void *
297 fileassoc_lookup(struct vnode *vp, fileassoc_t assoc)
298 {
299 struct fileassoc_hash_entry *mhe;
300
301 mhe = fileassoc_file_lookup(vp, NULL);
302 if (mhe == NULL)
303 return (NULL);
304
305 return file_getdata(mhe, assoc);
306 }
307
308 static struct fileassoc_table *
309 fileassoc_table_resize(struct fileassoc_table *tbl)
310 {
311 struct fileassoc_table *newtbl;
312 struct fileassoc_hashhead *hh;
313 u_long i;
314
315 /*
316 * Allocate a new table. Like the condition in fileassoc_file_add(),
317 * this is also temporary -- just double the number of slots.
318 */
319 newtbl = kmem_zalloc(sizeof(*newtbl), KM_SLEEP);
320 newtbl->hash_size = (tbl->hash_size * 2);
321 if (newtbl->hash_size < tbl->hash_size)
322 newtbl->hash_size = tbl->hash_size;
323 newtbl->hash_tbl = hashinit(newtbl->hash_size, HASH_LIST,
324 true, &newtbl->hash_mask);
325 newtbl->hash_used = 0;
326 specificdata_init(fileassoc_domain, &newtbl->data);
327
328 /* XXX we need to make sure nothing uses fileassoc here! */
329
330 hh = tbl->hash_tbl;
331 for (i = 0; i < tbl->hash_size; i++) {
332 struct fileassoc_hash_entry *mhe;
333
334 while ((mhe = LIST_FIRST(&hh[i])) != NULL) {
335 struct fileassoc_hashhead *vhh;
336 size_t indx;
337
338 LIST_REMOVE(mhe, entries);
339
340 indx = FILEASSOC_HASH(newtbl, mhe->handle);
341 vhh = &(newtbl->hash_tbl[indx]);
342
343 LIST_INSERT_HEAD(vhh, mhe, entries);
344
345 newtbl->hash_used++;
346 }
347 }
348
349 if (tbl->hash_used != newtbl->hash_used)
350 panic("fileassoc_table_resize: inconsistency detected! "
351 "needed %zu entries, got %zu", tbl->hash_used,
352 newtbl->hash_used);
353
354 hashdone(tbl->hash_tbl, HASH_LIST, tbl->hash_mask);
355 specificdata_fini(fileassoc_domain, &tbl->data);
356 kmem_free(tbl, sizeof(*tbl));
357
358 return (newtbl);
359 }
360
361 /*
362 * Create a new fileassoc table.
363 */
364 static struct fileassoc_table *
365 fileassoc_table_add(struct mount *mp)
366 {
367 struct fileassoc_table *tbl;
368
369 /* Check for existing table for device. */
370 tbl = fileassoc_table_lookup(mp);
371 if (tbl != NULL)
372 return (tbl);
373
374 /* Allocate and initialize a table. */
375 tbl = kmem_zalloc(sizeof(*tbl), KM_SLEEP);
376 tbl->hash_size = FILEASSOC_INITIAL_TABLESIZE;
377 tbl->hash_tbl = hashinit(tbl->hash_size, HASH_LIST, true,
378 &tbl->hash_mask);
379 tbl->hash_used = 0;
380 specificdata_init(fileassoc_domain, &tbl->data);
381
382 mount_setspecific(mp, fileassoc_mountspecific_key, tbl);
383
384 return (tbl);
385 }
386
387 /*
388 * Delete a table.
389 */
390 int
391 fileassoc_table_delete(struct mount *mp)
392 {
393 struct fileassoc_table *tbl;
394
395 tbl = fileassoc_table_lookup(mp);
396 if (tbl == NULL)
397 return (EEXIST);
398
399 mount_setspecific(mp, fileassoc_mountspecific_key, NULL);
400 table_dtor(tbl);
401
402 return (0);
403 }
404
405 /*
406 * Run a callback for each hook entry in a table.
407 */
408 int
409 fileassoc_table_run(struct mount *mp, fileassoc_t assoc, fileassoc_cb_t cb,
410 void *cookie)
411 {
412 struct fileassoc_table *tbl;
413 struct fileassoc_hashhead *hh;
414 u_long i;
415
416 tbl = fileassoc_table_lookup(mp);
417 if (tbl == NULL)
418 return (EEXIST);
419
420 hh = tbl->hash_tbl;
421 for (i = 0; i < tbl->hash_size; i++) {
422 struct fileassoc_hash_entry *mhe;
423
424 LIST_FOREACH(mhe, &hh[i], entries) {
425 void *data;
426
427 data = file_getdata(mhe, assoc);
428 if (data != NULL)
429 cb(data, cookie);
430 }
431 }
432
433 return (0);
434 }
435
436 /*
437 * Clear a table for a given hook.
438 */
439 int
440 fileassoc_table_clear(struct mount *mp, fileassoc_t assoc)
441 {
442 struct fileassoc_table *tbl;
443 struct fileassoc_hashhead *hh;
444 u_long i;
445
446 tbl = fileassoc_table_lookup(mp);
447 if (tbl == NULL)
448 return (EEXIST);
449
450 hh = tbl->hash_tbl;
451 for (i = 0; i < tbl->hash_size; i++) {
452 struct fileassoc_hash_entry *mhe;
453
454 LIST_FOREACH(mhe, &hh[i], entries) {
455 file_cleanup(mhe, assoc);
456 file_setdata(mhe, assoc, NULL);
457 }
458 }
459
460 return (0);
461 }
462
463 /*
464 * Add a file entry to a table.
465 */
466 static struct fileassoc_hash_entry *
467 fileassoc_file_add(struct vnode *vp, fhandle_t *hint)
468 {
469 struct fileassoc_table *tbl;
470 struct fileassoc_hashhead *vhh;
471 struct fileassoc_hash_entry *e;
472 size_t indx;
473 fhandle_t *th;
474 int error;
475
476 if (hint == NULL) {
477 error = vfs_composefh_alloc(vp, &th);
478 if (error)
479 return (NULL);
480 } else
481 th = hint;
482
483 e = fileassoc_file_lookup(vp, th);
484 if (e != NULL) {
485 if (hint == NULL)
486 vfs_composefh_free(th);
487
488 return (e);
489 }
490
491 tbl = fileassoc_table_lookup(vp->v_mount);
492 if (tbl == NULL) {
493 tbl = fileassoc_table_add(vp->v_mount);
494 }
495
496 indx = FILEASSOC_HASH(tbl, th);
497 vhh = &(tbl->hash_tbl[indx]);
498
499 e = kmem_zalloc(sizeof(*e), KM_SLEEP);
500 e->handle = th;
501 specificdata_init(fileassoc_domain, &e->data);
502 LIST_INSERT_HEAD(vhh, e, entries);
503
504 /*
505 * This decides when we need to resize the table. For now,
506 * resize it whenever we "filled" up the number of slots it
507 * has. That's not really true unless of course we had zero
508 * collisions. Think positive! :)
509 */
510 if (++(tbl->hash_used) == tbl->hash_size) {
511 struct fileassoc_table *newtbl;
512
513 newtbl = fileassoc_table_resize(tbl);
514 mount_setspecific(vp->v_mount, fileassoc_mountspecific_key,
515 newtbl);
516 }
517
518 return (e);
519 }
520
521 /*
522 * Delete a file entry from a table.
523 */
524 int
525 fileassoc_file_delete(struct vnode *vp)
526 {
527 struct fileassoc_table *tbl;
528 struct fileassoc_hash_entry *mhe;
529
530 KERNEL_LOCK(1, NULL);
531
532 mhe = fileassoc_file_lookup(vp, NULL);
533 if (mhe == NULL) {
534 KERNEL_UNLOCK_ONE(NULL);
535 return (ENOENT);
536 }
537
538 file_free(mhe);
539
540 tbl = fileassoc_table_lookup(vp->v_mount);
541 --(tbl->hash_used); /* XXX gc? */
542
543 KERNEL_UNLOCK_ONE(NULL);
544
545 return (0);
546 }
547
548 /*
549 * Add a hook to a vnode.
550 */
551 int
552 fileassoc_add(struct vnode *vp, fileassoc_t assoc, void *data)
553 {
554 struct fileassoc_hash_entry *e;
555 void *olddata;
556
557 e = fileassoc_file_lookup(vp, NULL);
558 if (e == NULL) {
559 e = fileassoc_file_add(vp, NULL);
560 if (e == NULL)
561 return (ENOTDIR);
562 }
563
564 olddata = file_getdata(e, assoc);
565 if (olddata != NULL)
566 return (EEXIST);
567
568 file_setdata(e, assoc, data);
569
570 e->nassocs++;
571
572 return (0);
573 }
574
575 /*
576 * Clear a hook from a vnode.
577 */
578 int
579 fileassoc_clear(struct vnode *vp, fileassoc_t assoc)
580 {
581 struct fileassoc_hash_entry *mhe;
582
583 mhe = fileassoc_file_lookup(vp, NULL);
584 if (mhe == NULL)
585 return (ENOENT);
586
587 file_cleanup(mhe, assoc);
588 file_setdata(mhe, assoc, NULL);
589
590 --(mhe->nassocs); /* XXX gc? */
591
592 return (0);
593 }
Cache object: a4d2c3b843305a058670a8072b7129d0
|