1 /*- 2 * Copyright (c) 2002 Dima Dorfman. 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 * 26 * $FreeBSD$ 27 */ 28 29 /* 30 * DEVFS ruleset implementation. 31 * 32 * A note on terminology: To "run" a rule on a dirent is to take the 33 * prescribed action; to "apply" a rule is to check whether it matches 34 * a dirent and run if if it does. 35 * 36 * A note on locking: Only foreign entry points (non-static functions) 37 * should deal with locking. Everything else assumes we already hold 38 * the required kind of lock. 39 * 40 * A note on namespace: devfs_rules_* are the non-static functions for 41 * the entire "ruleset" subsystem, devfs_rule_* are the static 42 * functions that operate on rules, and devfs_ruleset_* are the static 43 * functions that operate on rulesets. The line between the last two 44 * isn't always clear, but the guideline is still useful. 45 * 46 * A note on "special" identifiers: Ruleset 0 is the NULL, or empty, 47 * ruleset; it cannot be deleted or changed in any way. This may be 48 * assumed inside the code; e.g., a ruleset of 0 may be interpeted to 49 * mean "no ruleset". The interpretation of rule 0 is 50 * command-dependent, but in no case is there a real rule with number 51 * 0. 52 * 53 * A note on errno codes: To make it easier for the userland to tell 54 * what went wrong, we sometimes use errno codes that are not entirely 55 * appropriate for the error but that would be less ambiguous than the 56 * appropriate "generic" code. For example, when we can't find a 57 * ruleset, we return ESRCH instead of ENOENT (except in 58 * DEVFSIO_{R,S}GETNEXT, where a nonexistent ruleset means "end of 59 * list", and the userland expects ENOENT to be this indicator); this 60 * way, when an operation fails, it's clear that what couldn't be 61 * found is a ruleset and not a rule (well, it's clear to those who 62 * know the convention). 63 */ 64 65 #include <sys/param.h> 66 #include <sys/systm.h> 67 #include <sys/conf.h> 68 #include <sys/kernel.h> 69 #include <sys/malloc.h> 70 #include <sys/priv.h> 71 #include <sys/dirent.h> 72 #include <sys/ioccom.h> 73 #include <sys/lock.h> 74 #include <sys/sx.h> 75 76 #include <fs/devfs/devfs.h> 77 #include <fs/devfs/devfs_int.h> 78 79 /* 80 * Kernel version of devfs_rule. 81 */ 82 struct devfs_krule { 83 TAILQ_ENTRY(devfs_krule) dk_list; 84 struct devfs_ruleset *dk_ruleset; 85 struct devfs_rule dk_rule; 86 }; 87 88 TAILQ_HEAD(rulehead, devfs_krule); 89 static MALLOC_DEFINE(M_DEVFSRULE, "DEVFS_RULE", "DEVFS rule storage"); 90 91 /* 92 * Structure to describe a ruleset. 93 */ 94 struct devfs_ruleset { 95 TAILQ_ENTRY(devfs_ruleset) ds_list; 96 struct rulehead ds_rules; 97 devfs_rsnum ds_number; 98 int ds_refcount; 99 }; 100 101 static devfs_rid devfs_rid_input(devfs_rid rid, struct devfs_mount *dm); 102 103 static void devfs_rule_applyde_recursive(struct devfs_krule *dk, 104 struct devfs_dirent *de); 105 static void devfs_rule_applydm(struct devfs_krule *dk, struct devfs_mount *dm); 106 static int devfs_rule_autonumber(struct devfs_ruleset *ds, devfs_rnum *rnp); 107 static struct devfs_krule *devfs_rule_byid(devfs_rid rid); 108 static int devfs_rule_delete(struct devfs_krule *dkp); 109 static struct cdev *devfs_rule_getdev(struct devfs_dirent *de); 110 static int devfs_rule_input(struct devfs_rule *dr, struct devfs_mount *dm); 111 static int devfs_rule_insert(struct devfs_rule *dr); 112 static int devfs_rule_match(struct devfs_krule *dk, struct devfs_dirent *de); 113 static int devfs_rule_matchpath(struct devfs_krule *dk, 114 struct devfs_dirent *de); 115 static void devfs_rule_run(struct devfs_krule *dk, struct devfs_dirent *de, unsigned depth); 116 117 static void devfs_ruleset_applyde(struct devfs_ruleset *ds, 118 struct devfs_dirent *de, unsigned depth); 119 static void devfs_ruleset_applydm(struct devfs_ruleset *ds, 120 struct devfs_mount *dm); 121 static struct devfs_ruleset *devfs_ruleset_bynum(devfs_rsnum rsnum); 122 static struct devfs_ruleset *devfs_ruleset_create(devfs_rsnum rsnum); 123 static void devfs_ruleset_reap(struct devfs_ruleset *dsp); 124 static int devfs_ruleset_use(devfs_rsnum rsnum, struct devfs_mount *dm); 125 126 static struct sx sx_rules; 127 SX_SYSINIT(sx_rules, &sx_rules, "DEVFS ruleset lock"); 128 129 static TAILQ_HEAD(, devfs_ruleset) devfs_rulesets = 130 TAILQ_HEAD_INITIALIZER(devfs_rulesets); 131 132 /* 133 * Called to apply the proper rules for 'de' before it can be 134 * exposed to the userland. This should be called with an exclusive 135 * lock on dm in case we need to run anything. 136 */ 137 void 138 devfs_rules_apply(struct devfs_mount *dm, struct devfs_dirent *de) 139 { 140 struct devfs_ruleset *ds; 141 142 if (dm->dm_ruleset == 0) 143 return; 144 sx_slock(&sx_rules); 145 ds = devfs_ruleset_bynum(dm->dm_ruleset); 146 KASSERT(ds != NULL, ("mount-point has NULL ruleset")); 147 devfs_ruleset_applyde(ds, de, devfs_rule_depth); 148 sx_sunlock(&sx_rules); 149 } 150 151 /* 152 * Rule subsystem ioctl hook. 153 */ 154 int 155 devfs_rules_ioctl(struct devfs_mount *dm, u_long cmd, caddr_t data, struct thread *td) 156 { 157 struct devfs_ruleset *ds; 158 struct devfs_krule *dk; 159 struct devfs_rule *dr; 160 devfs_rsnum rsnum; 161 devfs_rnum rnum; 162 devfs_rid rid; 163 int error; 164 165 sx_assert(&dm->dm_lock, SX_XLOCKED); 166 167 /* 168 * XXX: This returns an error regardless of whether we actually 169 * support the cmd or not. 170 * 171 * We could make this privileges finer grained if desired. 172 */ 173 error = priv_check(td, PRIV_DEVFS_RULE); 174 if (error) 175 return (error); 176 177 sx_xlock(&sx_rules); 178 179 switch (cmd) { 180 case DEVFSIO_RADD: 181 dr = (struct devfs_rule *)data; 182 error = devfs_rule_input(dr, dm); 183 if (error != 0) 184 break; 185 dk = devfs_rule_byid(dr->dr_id); 186 if (dk != NULL) { 187 error = EEXIST; 188 break; 189 } 190 if (rid2rsn(dr->dr_id) == 0) { 191 error = EIO; 192 break; 193 } 194 error = devfs_rule_insert(dr); 195 break; 196 case DEVFSIO_RAPPLY: 197 dr = (struct devfs_rule *)data; 198 error = devfs_rule_input(dr, dm); 199 if (error != 0) 200 break; 201 202 /* 203 * This is one of many possible hackish 204 * implementations. The primary contender is an 205 * implementation where the rule we read in is 206 * temporarily inserted into some ruleset, perhaps 207 * with a hypothetical DRO_NOAUTO flag so that it 208 * doesn't get used where it isn't intended, and 209 * applied in the normal way. This can be done in the 210 * userland (DEVFSIO_ADD, DEVFSIO_APPLYID, 211 * DEVFSIO_DEL) or in the kernel; either way it breaks 212 * some corner case assumptions in other parts of the 213 * code (not that this implementation doesn't do 214 * that). 215 */ 216 if (dr->dr_iacts & DRA_INCSET && 217 devfs_ruleset_bynum(dr->dr_incset) == NULL) { 218 error = ESRCH; 219 break; 220 } 221 dk = malloc(sizeof(*dk), M_TEMP, M_WAITOK | M_ZERO); 222 memcpy(&dk->dk_rule, dr, sizeof(*dr)); 223 devfs_rule_applydm(dk, dm); 224 free(dk, M_TEMP); 225 break; 226 case DEVFSIO_RAPPLYID: 227 rid = *(devfs_rid *)data; 228 rid = devfs_rid_input(rid, dm); 229 dk = devfs_rule_byid(rid); 230 if (dk == NULL) { 231 error = ENOENT; 232 break; 233 } 234 devfs_rule_applydm(dk, dm); 235 break; 236 case DEVFSIO_RDEL: 237 rid = *(devfs_rid *)data; 238 rid = devfs_rid_input(rid, dm); 239 dk = devfs_rule_byid(rid); 240 if (dk == NULL) { 241 error = ENOENT; 242 break; 243 } 244 ds = dk->dk_ruleset; 245 error = devfs_rule_delete(dk); 246 break; 247 case DEVFSIO_RGETNEXT: 248 dr = (struct devfs_rule *)data; 249 error = devfs_rule_input(dr, dm); 250 if (error != 0) 251 break; 252 /* 253 * We can't use devfs_rule_byid() here since that 254 * requires the rule specified to exist, but we want 255 * getnext(N) to work whether there is a rule N or not 256 * (specifically, getnext(0) must work, but we should 257 * never have a rule 0 since the add command 258 * interprets 0 to mean "auto-number"). 259 */ 260 ds = devfs_ruleset_bynum(rid2rsn(dr->dr_id)); 261 if (ds == NULL) { 262 error = ENOENT; 263 break; 264 } 265 rnum = rid2rn(dr->dr_id); 266 TAILQ_FOREACH(dk, &ds->ds_rules, dk_list) { 267 if (rid2rn(dk->dk_rule.dr_id) > rnum) 268 break; 269 } 270 if (dk == NULL) { 271 error = ENOENT; 272 break; 273 } 274 memcpy(dr, &dk->dk_rule, sizeof(*dr)); 275 break; 276 case DEVFSIO_SUSE: 277 rsnum = *(devfs_rsnum *)data; 278 error = devfs_ruleset_use(rsnum, dm); 279 break; 280 case DEVFSIO_SAPPLY: 281 rsnum = *(devfs_rsnum *)data; 282 rsnum = rid2rsn(devfs_rid_input(mkrid(rsnum, 0), dm)); 283 ds = devfs_ruleset_bynum(rsnum); 284 if (ds == NULL) { 285 error = ESRCH; 286 break; 287 } 288 devfs_ruleset_applydm(ds, dm); 289 break; 290 case DEVFSIO_SGETNEXT: 291 rsnum = *(devfs_rsnum *)data; 292 TAILQ_FOREACH(ds, &devfs_rulesets, ds_list) { 293 if (ds->ds_number > rsnum) 294 break; 295 } 296 if (ds == NULL) { 297 error = ENOENT; 298 break; 299 } 300 *(devfs_rsnum *)data = ds->ds_number; 301 break; 302 default: 303 error = ENOIOCTL; 304 break; 305 } 306 307 sx_xunlock(&sx_rules); 308 return (error); 309 } 310 311 /* 312 * Adjust the rule identifier to use the ruleset of dm if one isn't 313 * explicitly specified. 314 * 315 * Note that after this operation, rid2rsn(rid) might still be 0, and 316 * that's okay; ruleset 0 is a valid ruleset, but when it's read in 317 * from the userland, it means "current ruleset for this mount-point". 318 */ 319 static devfs_rid 320 devfs_rid_input(devfs_rid rid, struct devfs_mount *dm) 321 { 322 323 if (rid2rsn(rid) == 0) 324 return (mkrid(dm->dm_ruleset, rid2rn(rid))); 325 else 326 return (rid); 327 } 328 329 /* 330 * Apply dk to de and everything under de. 331 * 332 * XXX: This method needs a function call for every nested 333 * subdirectory in a devfs mount. If we plan to have many of these, 334 * we might eventually run out of kernel stack space. 335 * XXX: a linear search could be done through the cdev list instead. 336 */ 337 static void 338 devfs_rule_applyde_recursive(struct devfs_krule *dk, struct devfs_dirent *de) 339 { 340 struct devfs_dirent *de2; 341 342 TAILQ_FOREACH(de2, &de->de_dlist, de_list) 343 devfs_rule_applyde_recursive(dk, de2); 344 devfs_rule_run(dk, de, devfs_rule_depth); 345 } 346 347 /* 348 * Apply dk to all entires in dm. 349 */ 350 static void 351 devfs_rule_applydm(struct devfs_krule *dk, struct devfs_mount *dm) 352 { 353 354 devfs_rule_applyde_recursive(dk, dm->dm_rootdir); 355 } 356 357 /* 358 * Automatically select a number for a new rule in ds, and write the 359 * result into rnump. 360 */ 361 static int 362 devfs_rule_autonumber(struct devfs_ruleset *ds, devfs_rnum *rnump) 363 { 364 struct devfs_krule *dk; 365 366 /* Find the last rule. */ 367 dk = TAILQ_LAST(&ds->ds_rules, rulehead); 368 if (dk == NULL) 369 *rnump = 100; 370 else { 371 *rnump = rid2rn(dk->dk_rule.dr_id) + 100; 372 /* Detect overflow. */ 373 if (*rnump < rid2rn(dk->dk_rule.dr_id)) 374 return (ERANGE); 375 } 376 KASSERT(devfs_rule_byid(mkrid(ds->ds_number, *rnump)) == NULL, 377 ("autonumbering resulted in an already existing rule")); 378 return (0); 379 } 380 381 /* 382 * Find a krule by id. 383 */ 384 static struct devfs_krule * 385 devfs_rule_byid(devfs_rid rid) 386 { 387 struct devfs_ruleset *ds; 388 struct devfs_krule *dk; 389 devfs_rnum rn; 390 391 rn = rid2rn(rid); 392 ds = devfs_ruleset_bynum(rid2rsn(rid)); 393 if (ds == NULL) 394 return (NULL); 395 TAILQ_FOREACH(dk, &ds->ds_rules, dk_list) { 396 if (rid2rn(dk->dk_rule.dr_id) == rn) 397 return (dk); 398 else if (rid2rn(dk->dk_rule.dr_id) > rn) 399 break; 400 } 401 return (NULL); 402 } 403 404 /* 405 * Remove dkp from any lists it may be on and remove memory associated 406 * with it. 407 */ 408 static int 409 devfs_rule_delete(struct devfs_krule *dk) 410 { 411 struct devfs_ruleset *ds; 412 413 if (dk->dk_rule.dr_iacts & DRA_INCSET) { 414 ds = devfs_ruleset_bynum(dk->dk_rule.dr_incset); 415 KASSERT(ds != NULL, ("DRA_INCSET but bad dr_incset")); 416 --ds->ds_refcount; 417 devfs_ruleset_reap(ds); 418 } 419 ds = dk->dk_ruleset; 420 TAILQ_REMOVE(&ds->ds_rules, dk, dk_list); 421 devfs_ruleset_reap(ds); 422 free(dk, M_DEVFSRULE); 423 return (0); 424 } 425 426 /* 427 * Get a struct cdev *corresponding to de so we can try to match rules based 428 * on it. If this routine returns NULL, there is no struct cdev *associated 429 * with the dirent (symlinks and directories don't have dev_ts), and 430 * the caller should assume that any critera dependent on a dev_t 431 * don't match. 432 */ 433 static struct cdev * 434 devfs_rule_getdev(struct devfs_dirent *de) 435 { 436 437 if (de->de_cdp == NULL) 438 return (NULL); 439 if (de->de_cdp->cdp_flags & CDP_ACTIVE) 440 return (&de->de_cdp->cdp_c); 441 else 442 return (NULL); 443 } 444 445 /* 446 * Do what we need to do to a rule that we just loaded from the 447 * userland. In particular, we need to check the magic, and adjust 448 * the ruleset appropriate if desired. 449 */ 450 static int 451 devfs_rule_input(struct devfs_rule *dr, struct devfs_mount *dm) 452 { 453 454 if (dr->dr_magic != DEVFS_MAGIC) 455 return (ERPCMISMATCH); 456 dr->dr_id = devfs_rid_input(dr->dr_id, dm); 457 return (0); 458 } 459 460 /* 461 * Import dr into the appropriate place in the kernel (i.e., make a 462 * krule). The value of dr is copied, so the pointer may be destroyed 463 * after this call completes. 464 */ 465 static int 466 devfs_rule_insert(struct devfs_rule *dr) 467 { 468 struct devfs_ruleset *ds, *dsi; 469 struct devfs_krule *k1; 470 struct devfs_krule *dk; 471 devfs_rsnum rsnum; 472 devfs_rnum dkrn; 473 int error; 474 475 /* 476 * This stuff seems out of place here, but we want to do it as 477 * soon as possible so that if it fails, we don't have to roll 478 * back any changes we already made (e.g., ruleset creation). 479 */ 480 if (dr->dr_iacts & DRA_INCSET) { 481 dsi = devfs_ruleset_bynum(dr->dr_incset); 482 if (dsi == NULL) 483 return (ESRCH); 484 } else 485 dsi = NULL; 486 487 rsnum = rid2rsn(dr->dr_id); 488 KASSERT(rsnum != 0, ("Inserting into ruleset zero")); 489 490 ds = devfs_ruleset_bynum(rsnum); 491 if (ds == NULL) 492 ds = devfs_ruleset_create(rsnum); 493 dkrn = rid2rn(dr->dr_id); 494 if (dkrn == 0) { 495 error = devfs_rule_autonumber(ds, &dkrn); 496 if (error != 0) { 497 devfs_ruleset_reap(ds); 498 return (error); 499 } 500 } 501 502 dk = malloc(sizeof(*dk), M_DEVFSRULE, M_WAITOK | M_ZERO); 503 dk->dk_ruleset = ds; 504 if (dsi != NULL) 505 ++dsi->ds_refcount; 506 /* XXX: Inspect dr? */ 507 memcpy(&dk->dk_rule, dr, sizeof(*dr)); 508 dk->dk_rule.dr_id = mkrid(rid2rsn(dk->dk_rule.dr_id), dkrn); 509 510 TAILQ_FOREACH(k1, &ds->ds_rules, dk_list) { 511 if (rid2rn(k1->dk_rule.dr_id) > dkrn) { 512 TAILQ_INSERT_BEFORE(k1, dk, dk_list); 513 break; 514 } 515 } 516 if (k1 == NULL) 517 TAILQ_INSERT_TAIL(&ds->ds_rules, dk, dk_list); 518 return (0); 519 } 520 521 /* 522 * Determine whether dk matches de. Returns 1 if dk should be run on 523 * de; 0, otherwise. 524 */ 525 static int 526 devfs_rule_match(struct devfs_krule *dk, struct devfs_dirent *de) 527 { 528 struct devfs_rule *dr = &dk->dk_rule; 529 struct cdev *dev; 530 struct cdevsw *dsw; 531 int ref; 532 533 dev = devfs_rule_getdev(de); 534 /* 535 * At this point, if dev is NULL, we should assume that any 536 * criteria that depend on it don't match. We should *not* 537 * just ignore them (i.e., act like they weren't specified), 538 * since that makes a rule that only has criteria dependent on 539 * the struct cdev *match all symlinks and directories. 540 * 541 * Note also that the following tests are somewhat reversed: 542 * They're actually testing to see whether the condition does 543 * *not* match, since the default is to assume the rule should 544 * be run (such as if there are no conditions). 545 */ 546 if (dr->dr_icond & DRC_DSWFLAGS) { 547 if (dev == NULL) 548 return (0); 549 dsw = dev_refthread(dev, &ref); 550 if (dsw == NULL) 551 return (0); 552 if ((dsw->d_flags & dr->dr_dswflags) == 0) { 553 dev_relthread(dev, ref); 554 return (0); 555 } 556 dev_relthread(dev, ref); 557 } 558 if (dr->dr_icond & DRC_PATHPTRN) 559 if (!devfs_rule_matchpath(dk, de)) 560 return (0); 561 562 return (1); 563 } 564 565 /* 566 * Determine whether dk matches de on account of dr_pathptrn. 567 */ 568 static int 569 devfs_rule_matchpath(struct devfs_krule *dk, struct devfs_dirent *de) 570 { 571 struct devfs_rule *dr = &dk->dk_rule; 572 char *pname; 573 struct cdev *dev; 574 575 dev = devfs_rule_getdev(de); 576 if (dev != NULL) 577 pname = dev->si_name; 578 else if (de->de_dirent->d_type == DT_LNK || 579 de->de_dirent->d_type == DT_DIR) 580 pname = de->de_dirent->d_name; 581 else 582 return (0); 583 KASSERT(pname != NULL, ("devfs_rule_matchpath: NULL pname")); 584 585 return (fnmatch(dr->dr_pathptrn, pname, 0) == 0); 586 } 587 588 /* 589 * Run dk on de. 590 */ 591 static void 592 devfs_rule_run(struct devfs_krule *dk, struct devfs_dirent *de, unsigned depth) 593 { 594 struct devfs_rule *dr = &dk->dk_rule; 595 struct devfs_ruleset *ds; 596 597 if (!devfs_rule_match(dk, de)) 598 return; 599 if (dr->dr_iacts & DRA_BACTS) { 600 if (dr->dr_bacts & DRB_HIDE) 601 de->de_flags |= DE_WHITEOUT; 602 if (dr->dr_bacts & DRB_UNHIDE) 603 de->de_flags &= ~DE_WHITEOUT; 604 } 605 if (dr->dr_iacts & DRA_UID) 606 de->de_uid = dr->dr_uid; 607 if (dr->dr_iacts & DRA_GID) 608 de->de_gid = dr->dr_gid; 609 if (dr->dr_iacts & DRA_MODE) 610 de->de_mode = dr->dr_mode; 611 if (dr->dr_iacts & DRA_INCSET) { 612 /* 613 * XXX: we should tell the user if the depth is exceeded here 614 * XXX: but it is not obvious how to. A return value will 615 * XXX: not work as this is called when devices are created 616 * XXX: long time after the rules were instantiated. 617 * XXX: a printf() would probably give too much noise, or 618 * XXX: DoS the machine. I guess a a rate-limited message 619 * XXX: might work. 620 */ 621 if (depth > 0) { 622 ds = devfs_ruleset_bynum(dk->dk_rule.dr_incset); 623 KASSERT(ds != NULL, ("DRA_INCSET but bad dr_incset")); 624 devfs_ruleset_applyde(ds, de, depth - 1); 625 } 626 } 627 } 628 629 /* 630 * Apply all the rules in ds to de. 631 */ 632 static void 633 devfs_ruleset_applyde(struct devfs_ruleset *ds, struct devfs_dirent *de, unsigned depth) 634 { 635 struct devfs_krule *dk; 636 637 TAILQ_FOREACH(dk, &ds->ds_rules, dk_list) 638 devfs_rule_run(dk, de, depth); 639 } 640 641 /* 642 * Apply all the rules in ds to all the entires in dm. 643 */ 644 static void 645 devfs_ruleset_applydm(struct devfs_ruleset *ds, struct devfs_mount *dm) 646 { 647 struct devfs_krule *dk; 648 649 /* 650 * XXX: Does it matter whether we do 651 * 652 * foreach(dk in ds) 653 * foreach(de in dm) 654 * apply(dk to de) 655 * 656 * as opposed to 657 * 658 * foreach(de in dm) 659 * foreach(dk in ds) 660 * apply(dk to de) 661 * 662 * The end result is obviously the same, but does the order 663 * matter? 664 */ 665 TAILQ_FOREACH(dk, &ds->ds_rules, dk_list) 666 devfs_rule_applydm(dk, dm); 667 } 668 669 /* 670 * Find a ruleset by number. 671 */ 672 static struct devfs_ruleset * 673 devfs_ruleset_bynum(devfs_rsnum rsnum) 674 { 675 struct devfs_ruleset *ds; 676 677 TAILQ_FOREACH(ds, &devfs_rulesets, ds_list) { 678 if (ds->ds_number == rsnum) 679 return (ds); 680 } 681 return (NULL); 682 } 683 684 /* 685 * Create a new ruleset. 686 */ 687 static struct devfs_ruleset * 688 devfs_ruleset_create(devfs_rsnum rsnum) 689 { 690 struct devfs_ruleset *s1; 691 struct devfs_ruleset *ds; 692 693 KASSERT(rsnum != 0, ("creating ruleset zero")); 694 695 KASSERT(devfs_ruleset_bynum(rsnum) == NULL, 696 ("creating already existent ruleset %d", rsnum)); 697 698 ds = malloc(sizeof(*ds), M_DEVFSRULE, M_WAITOK | M_ZERO); 699 ds->ds_number = rsnum; 700 TAILQ_INIT(&ds->ds_rules); 701 702 TAILQ_FOREACH(s1, &devfs_rulesets, ds_list) { 703 if (s1->ds_number > rsnum) { 704 TAILQ_INSERT_BEFORE(s1, ds, ds_list); 705 break; 706 } 707 } 708 if (s1 == NULL) 709 TAILQ_INSERT_TAIL(&devfs_rulesets, ds, ds_list); 710 return (ds); 711 } 712 713 /* 714 * Remove a ruleset from the system if it's empty and not used 715 * anywhere. This should be called after every time a rule is deleted 716 * from this ruleset or the reference count is decremented. 717 */ 718 static void 719 devfs_ruleset_reap(struct devfs_ruleset *ds) 720 { 721 722 KASSERT(ds->ds_number != 0, ("reaping ruleset zero ")); 723 724 if (!TAILQ_EMPTY(&ds->ds_rules) || ds->ds_refcount != 0) 725 return; 726 727 TAILQ_REMOVE(&devfs_rulesets, ds, ds_list); 728 free(ds, M_DEVFSRULE); 729 } 730 731 /* 732 * Make rsnum the active ruleset for dm. 733 */ 734 static int 735 devfs_ruleset_use(devfs_rsnum rsnum, struct devfs_mount *dm) 736 { 737 struct devfs_ruleset *cds, *ds; 738 739 if (dm->dm_ruleset != 0) { 740 cds = devfs_ruleset_bynum(dm->dm_ruleset); 741 --cds->ds_refcount; 742 devfs_ruleset_reap(cds); 743 } 744 745 ds = devfs_ruleset_bynum(rsnum); 746 if (ds == NULL) 747 ds = devfs_ruleset_create(rsnum); 748 /* These should probably be made atomic somehow. */ 749 ++ds->ds_refcount; 750 dm->dm_ruleset = rsnum; 751 752 return (0); 753 } 754 755 void 756 devfs_rules_cleanup(struct devfs_mount *dm) 757 { 758 struct devfs_ruleset *ds; 759 760 sx_assert(&dm->dm_lock, SX_XLOCKED); 761 if (dm->dm_ruleset != 0) { 762 ds = devfs_ruleset_bynum(dm->dm_ruleset); 763 --ds->ds_refcount; 764 devfs_ruleset_reap(ds); 765 } 766 } 767