kern_fileassoc.c revision 1.4
1 /* $NetBSD: kern_fileassoc.c,v 1.4 2006/07/20 09:00:41 cube Exp $ */ 2 3 /*- 4 * Copyright (c) 2006 Elad Efrat <elad (at) 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. All advertising materials mentioning features or use of this software 16 * must display the following acknowledgement: 17 * This product includes software developed by Elad Efrat. 18 * 4. The name of the author may not be used to endorse or promote products 19 * derived from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 22 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 23 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 24 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 26 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 30 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 #include <sys/param.h> 34 #include <sys/mount.h> 35 #include <sys/queue.h> 36 #include <sys/malloc.h> 37 #include <sys/vnode.h> 38 #include <sys/namei.h> 39 #include <sys/exec.h> 40 #include <sys/proc.h> 41 #include <sys/inttypes.h> 42 #include <sys/errno.h> 43 #include <sys/fileassoc.h> 44 #include <sys/hash.h> 45 46 /* 47 * Hook entry. 48 * Includes the hook name for identification and private hook clear callback. 49 */ 50 struct fileassoc_hook { 51 const char *hook_name; /* Hook name. */ 52 fileassoc_cleanup_cb_t hook_cleanup_cb; /* Hook clear callback. */ 53 }; 54 55 /* An entry in the per-device hash table. */ 56 struct fileassoc_hash_entry { 57 ino_t fileid; /* File id. */ 58 void *hooks[FILEASSOC_NHOOKS]; /* Hooks. */ 59 LIST_ENTRY(fileassoc_hash_entry) entries; /* List pointer. */ 60 }; 61 62 LIST_HEAD(fileassoc_hashhead, fileassoc_hash_entry); 63 64 struct fileassoc_table { 65 struct fileassoc_hashhead *hash_tbl; 66 size_t hash_size; /* Number of slots. */ 67 struct mount *tbl_mntpt; 68 u_long hash_mask; 69 void *tables[FILEASSOC_NHOOKS]; 70 LIST_ENTRY(fileassoc_table) hash_list; /* List pointer. */ 71 }; 72 73 struct fileassoc_hook fileassoc_hooks[FILEASSOC_NHOOKS]; 74 int fileassoc_nhooks; 75 76 /* Global list of hash tables, one per device. */ 77 LIST_HEAD(, fileassoc_table) fileassoc_tables; 78 79 /* 80 * Hashing function: Takes a number modulus the mask to give back 81 * an index into the hash table. 82 */ 83 #define FILEASSOC_HASH(tbl, fileid) \ 84 (hash32_buf(&(fileid), sizeof((fileid)), HASH32_BUF_INIT) \ 85 & ((tbl)->hash_mask)) 86 87 /* 88 * Initialize the fileassoc subsystem. 89 */ 90 void 91 fileassoc_init(void) 92 { 93 memset(fileassoc_hooks, 0, sizeof(fileassoc_hooks)); 94 fileassoc_nhooks = 0; 95 } 96 97 /* 98 * Register a new hook. 99 */ 100 fileassoc_t 101 fileassoc_register(const char *name, fileassoc_cleanup_cb_t cleanup_cb) 102 { 103 int i; 104 105 if (fileassoc_nhooks >= FILEASSOC_NHOOKS) 106 return (-1); 107 108 for (i = 0; i < FILEASSOC_NHOOKS; i++) 109 if (fileassoc_hooks[i].hook_name == NULL) 110 break; 111 112 fileassoc_hooks[i].hook_name = name; 113 fileassoc_hooks[i].hook_cleanup_cb = cleanup_cb; 114 115 fileassoc_nhooks++; 116 117 return (i); 118 } 119 120 /* 121 * Deregister a hook. 122 */ 123 int 124 fileassoc_deregister(fileassoc_t id) 125 { 126 if (id < 0 || id >= FILEASSOC_NHOOKS) 127 return (EINVAL); 128 129 fileassoc_hooks[id].hook_name = NULL; 130 fileassoc_hooks[id].hook_cleanup_cb = NULL; 131 132 fileassoc_nhooks--; 133 134 return (0); 135 } 136 137 /* 138 * Get the hash table for the specified device. 139 */ 140 static struct fileassoc_table * 141 fileassoc_table_lookup(struct mount *mp) 142 { 143 struct fileassoc_table *tbl; 144 145 LIST_FOREACH(tbl, &fileassoc_tables, hash_list) { 146 if (tbl->tbl_mntpt == mp) 147 return (tbl); 148 } 149 150 return (NULL); 151 } 152 153 /* 154 * Perform a lookup on a hash table. 155 */ 156 static struct fileassoc_hash_entry * 157 fileassoc_file_lookup(struct vnode *vp) 158 { 159 struct fileassoc_table *tbl; 160 struct fileassoc_hashhead *tble; 161 struct fileassoc_hash_entry *e; 162 struct vattr va; 163 size_t indx; 164 int error; 165 166 error = VOP_GETATTR(vp, &va, curlwp->l_proc->p_cred, curlwp); 167 if (error) 168 return (NULL); 169 170 tbl = fileassoc_table_lookup(vp->v_mount); 171 if (tbl == NULL) 172 return (NULL); 173 174 /* 175 * XXX: We should NOT rely on fileid here! 176 */ 177 indx = FILEASSOC_HASH(tbl, va.va_fileid); 178 tble = &(tbl->hash_tbl[indx & ((tbl)->hash_mask)]); 179 180 LIST_FOREACH(e, tble, entries) { 181 if ((e != NULL) && (e->fileid == va.va_fileid)) 182 return (e); 183 } 184 185 return (NULL); 186 } 187 188 /* 189 * Return hook data associated with a vnode. 190 */ 191 void * 192 fileassoc_lookup(struct vnode *vp, fileassoc_t id) 193 { 194 struct fileassoc_hash_entry *mhe; 195 196 mhe = fileassoc_file_lookup(vp); 197 if (mhe == NULL) 198 return (NULL); 199 200 return (mhe->hooks[id]); 201 } 202 203 /* 204 * Create a new fileassoc table. 205 */ 206 int 207 fileassoc_table_add(struct mount *mp, size_t size) 208 { 209 struct fileassoc_table *tbl; 210 211 /* Check for existing table for device. */ 212 if (fileassoc_table_lookup(mp) != NULL) 213 return (EEXIST); 214 215 /* Allocate and initialize a Veriexec hash table. */ 216 tbl = malloc(sizeof(*tbl), M_TEMP, M_WAITOK | M_ZERO); 217 tbl->hash_size = size; 218 tbl->tbl_mntpt = mp; 219 tbl->hash_tbl = hashinit(size, HASH_LIST, M_TEMP, 220 M_WAITOK | M_ZERO, &tbl->hash_mask); 221 222 LIST_INSERT_HEAD(&fileassoc_tables, tbl, hash_list); 223 224 return (0); 225 } 226 227 /* 228 * Delete a table. 229 */ 230 int 231 fileassoc_table_delete(struct mount *mp) 232 { 233 struct fileassoc_table *tbl; 234 struct fileassoc_hashhead *hh; 235 u_long i; 236 int j; 237 238 tbl = fileassoc_table_lookup(mp); 239 if (tbl == NULL) 240 return (EEXIST); 241 242 /* Remove all entries from the table and lists */ 243 hh = tbl->hash_tbl; 244 for (i = 0; i < tbl->hash_size; i++) { 245 struct fileassoc_hash_entry *mhe; 246 247 while (LIST_FIRST(&hh[i]) != NULL) { 248 mhe = LIST_FIRST(&hh[i]); 249 LIST_REMOVE(mhe, entries); 250 251 for (j = 0; j < fileassoc_nhooks; j++) 252 if (fileassoc_hooks[j].hook_cleanup_cb != NULL) 253 (fileassoc_hooks[j].hook_cleanup_cb) 254 (mhe->hooks[j], 255 FILEASSOC_CLEANUP_FILE); 256 257 free(mhe, M_TEMP); 258 } 259 } 260 261 for (j = 0; j < fileassoc_nhooks; j++) 262 if (fileassoc_hooks[j].hook_cleanup_cb != NULL) 263 (fileassoc_hooks[j].hook_cleanup_cb)(tbl->tables[j], 264 FILEASSOC_CLEANUP_TABLE); 265 266 /* Remove hash table and sysctl node */ 267 hashdone(tbl->hash_tbl, M_TEMP); 268 LIST_REMOVE(tbl, hash_list); 269 270 return (0); 271 } 272 273 /* 274 * Clear a table for a given hook. 275 */ 276 int 277 fileassoc_table_clear(struct mount *mp, fileassoc_t id) 278 { 279 struct fileassoc_table *tbl; 280 struct fileassoc_hashhead *hh; 281 fileassoc_cleanup_cb_t cleanup_cb; 282 u_long i; 283 284 tbl = fileassoc_table_lookup(mp); 285 if (tbl == NULL) 286 return (EEXIST); 287 288 cleanup_cb = fileassoc_hooks[id].hook_cleanup_cb; 289 290 hh = tbl->hash_tbl; 291 for (i = 0; i < tbl->hash_size; i++) { 292 struct fileassoc_hash_entry *mhe; 293 294 LIST_FOREACH(mhe, &hh[i], entries) { 295 if ((mhe->hooks[id] != NULL) && cleanup_cb != NULL) 296 cleanup_cb(mhe->hooks[id], 297 FILEASSOC_CLEANUP_FILE); 298 299 mhe->hooks[id] = NULL; 300 } 301 } 302 303 if ((tbl->tables[id] != NULL) && cleanup_cb != NULL) 304 cleanup_cb(tbl->tables[id], FILEASSOC_CLEANUP_TABLE); 305 306 tbl->tables[id] = NULL; 307 308 return (0); 309 } 310 311 /* 312 * Add hook-specific data on a fileassoc table. 313 */ 314 int 315 fileassoc_tabledata_add(struct mount *mp, fileassoc_t id, void *data) 316 { 317 struct fileassoc_table *tbl; 318 319 tbl = fileassoc_table_lookup(mp); 320 if (tbl == NULL) 321 return (EFAULT); 322 323 tbl->tables[id] = data; 324 325 return (0); 326 } 327 328 /* 329 * Clear hook-specific data on a fileassoc table. 330 */ 331 int 332 fileassoc_tabledata_clear(struct mount *mp, fileassoc_t id) 333 { 334 struct fileassoc_table *tbl; 335 336 tbl = fileassoc_table_lookup(mp); 337 if (tbl == NULL) 338 return (EFAULT); 339 340 tbl->tables[id] = NULL; 341 342 return (0); 343 } 344 345 /* 346 * Retrieve hook-specific data from a fileassoc table. 347 */ 348 void * 349 fileassoc_tabledata_lookup(struct mount *mp, fileassoc_t id) 350 { 351 struct fileassoc_table *tbl; 352 353 tbl = fileassoc_table_lookup(mp); 354 if (tbl == NULL) 355 return (NULL); 356 357 return (tbl->tables[id]); 358 } 359 360 /* 361 * Add a file entry to a table. 362 */ 363 static struct fileassoc_hash_entry * 364 fileassoc_file_add(struct vnode *vp) 365 { 366 struct fileassoc_table *tbl; 367 struct fileassoc_hashhead *vhh; 368 struct fileassoc_hash_entry *e; 369 struct vattr va; 370 size_t indx; 371 int error; 372 373 error = VOP_GETATTR(vp, &va, curlwp->l_proc->p_cred, curlwp); 374 if (error) 375 return (NULL); 376 377 e = fileassoc_file_lookup(vp); 378 if (e != NULL) 379 return (e); 380 381 tbl = fileassoc_table_lookup(vp->v_mount); 382 if (tbl == NULL) 383 return (NULL); 384 385 /* 386 * XXX: We should NOT rely on fileid here! 387 */ 388 indx = FILEASSOC_HASH(tbl, va.va_fileid); 389 vhh = &(tbl->hash_tbl[indx & ((tbl)->hash_mask)]); 390 391 e = malloc(sizeof(*e), M_TEMP, M_WAITOK | M_ZERO); 392 e->fileid = va.va_fileid; 393 LIST_INSERT_HEAD(vhh, e, entries); 394 395 return (e); 396 } 397 398 /* 399 * Delete a file entry from a table. 400 */ 401 int 402 fileassoc_file_delete(struct vnode *vp) 403 { 404 struct fileassoc_hash_entry *mhe; 405 int i; 406 407 mhe = fileassoc_file_lookup(vp); 408 if (mhe == NULL) 409 return (ENOENT); 410 411 LIST_REMOVE(mhe, entries); 412 413 for (i = 0; i < fileassoc_nhooks; i++) 414 if (fileassoc_hooks[i].hook_cleanup_cb != NULL) 415 (fileassoc_hooks[i].hook_cleanup_cb)(mhe->hooks[i], 416 FILEASSOC_CLEANUP_FILE); 417 418 free(mhe, M_TEMP); 419 420 return (0); 421 } 422 423 /* 424 * Add a hook to a vnode. 425 */ 426 int 427 fileassoc_add(struct vnode *vp, fileassoc_t id, void *data) 428 { 429 struct fileassoc_hash_entry *e; 430 431 e = fileassoc_file_lookup(vp); 432 if (e == NULL) { 433 e = fileassoc_file_add(vp); 434 if (e == NULL) 435 return (ENOTDIR); 436 } 437 438 if (e->hooks[id] != NULL) 439 return (EEXIST); 440 441 e->hooks[id] = data; 442 443 return (0); 444 } 445 446 /* 447 * Clear a hook from a vnode. 448 */ 449 int 450 fileassoc_clear(struct vnode *vp, fileassoc_t id) 451 { 452 struct fileassoc_hash_entry *mhe; 453 fileassoc_cleanup_cb_t cleanup_cb; 454 455 mhe = fileassoc_file_lookup(vp); 456 if (mhe == NULL) 457 return (ENOENT); 458 459 cleanup_cb = fileassoc_hooks[id].hook_cleanup_cb; 460 if ((mhe->hooks[id] != NULL) && cleanup_cb != NULL) 461 cleanup_cb(mhe->hooks[id], FILEASSOC_CLEANUP_FILE); 462 463 mhe->hooks[id] = NULL; 464 465 return (0); 466 } 467
Indexes created Sun Sep 21 16:09:51 GMT 2025