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