devfs_rule.c revision 150501
1100206Sdd/*- 2100206Sdd * Copyright (c) 2002 Dima Dorfman. 3100206Sdd * All rights reserved. 4100206Sdd * 5100206Sdd * Redistribution and use in source and binary forms, with or without 6100206Sdd * modification, are permitted provided that the following conditions 7100206Sdd * are met: 8100206Sdd * 1. Redistributions of source code must retain the above copyright 9100206Sdd * notice, this list of conditions and the following disclaimer. 10100206Sdd * 2. Redistributions in binary form must reproduce the above copyright 11100206Sdd * notice, this list of conditions and the following disclaimer in the 12100206Sdd * documentation and/or other materials provided with the distribution. 13100206Sdd * 14100206Sdd * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15100206Sdd * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16100206Sdd * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17100206Sdd * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18100206Sdd * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19100206Sdd * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20100206Sdd * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21100206Sdd * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22100206Sdd * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23100206Sdd * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24100206Sdd * SUCH DAMAGE. 25100206Sdd * 26100206Sdd * $FreeBSD: head/sys/fs/devfs/devfs_rule.c 150501 2005-09-24 07:03:09Z phk $ 27100206Sdd */ 28100206Sdd 29100206Sdd/* 30100206Sdd * DEVFS ruleset implementation. 31100206Sdd * 32100206Sdd * A note on terminology: To "run" a rule on a dirent is to take the 33100206Sdd * prescribed action; to "apply" a rule is to check whether it matches 34100206Sdd * a dirent and run if if it does. 35100206Sdd * 36100206Sdd * A note on locking: Only foreign entry points (non-static functions) 37100206Sdd * should deal with locking. Everything else assumes we already hold 38100206Sdd * the required kind of lock. 39100206Sdd * 40100206Sdd * A note on namespace: devfs_rules_* are the non-static functions for 41100206Sdd * the entire "ruleset" subsystem, devfs_rule_* are the static 42100206Sdd * functions that operate on rules, and devfs_ruleset_* are the static 43100206Sdd * functions that operate on rulesets. The line between the last two 44100206Sdd * isn't always clear, but the guideline is still useful. 45100206Sdd * 46100206Sdd * A note on "special" identifiers: Ruleset 0 is the NULL, or empty, 47100206Sdd * ruleset; it cannot be deleted or changed in any way. This may be 48100206Sdd * assumed inside the code; e.g., a ruleset of 0 may be interpeted to 49100206Sdd * mean "no ruleset". The interpretation of rule 0 is 50100206Sdd * command-dependent, but in no case is there a real rule with number 51100206Sdd * 0. 52100206Sdd * 53100206Sdd * A note on errno codes: To make it easier for the userland to tell 54100206Sdd * what went wrong, we sometimes use errno codes that are not entirely 55100206Sdd * appropriate for the error but that would be less ambiguous than the 56100206Sdd * appropriate "generic" code. For example, when we can't find a 57100206Sdd * ruleset, we return ESRCH instead of ENOENT (except in 58100206Sdd * DEVFSIO_{R,S}GETNEXT, where a nonexistent ruleset means "end of 59100206Sdd * list", and the userland expects ENOENT to be this indicator); this 60100206Sdd * way, when an operation fails, it's clear that what couldn't be 61100206Sdd * found is a ruleset and not a rule (well, it's clear to those who 62100206Sdd * know the convention). 63100206Sdd */ 64100206Sdd 65100206Sdd#include "opt_devfs.h" 66100206Sdd 67100206Sdd#include <sys/param.h> 68100206Sdd#include <sys/systm.h> 69100206Sdd#include <sys/conf.h> 70100206Sdd#include <sys/kernel.h> 71100206Sdd#include <sys/malloc.h> 72100206Sdd#include <sys/dirent.h> 73100206Sdd#include <sys/ioccom.h> 74150342Sphk#include <sys/lock.h> 75150150Sphk#include <sys/sx.h> 76100206Sdd 77100206Sdd#include <fs/devfs/devfs.h> 78150342Sphk#include <fs/devfs/devfs_int.h> 79100206Sdd 80100206Sdd/* 81100206Sdd * Kernel version of devfs_rule. 82100206Sdd */ 83100206Sddstruct devfs_krule { 84150501Sphk TAILQ_ENTRY(devfs_krule) dk_list; 85150501Sphk struct devfs_ruleset *dk_ruleset; 86150501Sphk struct devfs_rule dk_rule; 87100206Sdd}; 88100206Sdd 89150501SphkTAILQ_HEAD(rulehead, devfs_krule); 90150501Sphkstatic MALLOC_DEFINE(M_DEVFSRULE, "DEVFS_RULE", "DEVFS rule storage"); 91150501Sphk 92100206Sdd/* 93100206Sdd * Structure to describe a ruleset. 94100206Sdd */ 95100206Sddstruct devfs_ruleset { 96150501Sphk TAILQ_ENTRY(devfs_ruleset) ds_list; 97150501Sphk struct rulehead ds_rules; 98150501Sphk devfs_rsnum ds_number; 99150501Sphk int ds_refcount; 100100206Sdd}; 101100206Sdd 102100206Sddstatic devfs_rid devfs_rid_input(devfs_rid rid, struct devfs_mount *dm); 103100206Sdd 104100206Sddstatic void devfs_rule_applyde_recursive(struct devfs_krule *dk, 105100206Sdd struct devfs_dirent *de); 106100206Sddstatic void devfs_rule_applydm(struct devfs_krule *dk, struct devfs_mount *dm); 107100206Sddstatic int devfs_rule_autonumber(struct devfs_ruleset *ds, devfs_rnum *rnp); 108100206Sddstatic struct devfs_krule *devfs_rule_byid(devfs_rid rid); 109150501Sphkstatic int devfs_rule_delete(struct devfs_krule *dkp); 110130585Sphkstatic struct cdev *devfs_rule_getdev(struct devfs_dirent *de); 111100206Sddstatic int devfs_rule_input(struct devfs_rule *dr, struct devfs_mount *dm); 112100206Sddstatic int devfs_rule_insert(struct devfs_rule *dr); 113100206Sddstatic int devfs_rule_match(struct devfs_krule *dk, struct devfs_dirent *de); 114100206Sddstatic int devfs_rule_matchpath(struct devfs_krule *dk, 115100206Sdd struct devfs_dirent *de); 116150147Sphkstatic void devfs_rule_run(struct devfs_krule *dk, struct devfs_dirent *de, unsigned depth); 117100206Sdd 118100206Sddstatic void devfs_ruleset_applyde(struct devfs_ruleset *ds, 119150147Sphk struct devfs_dirent *de, unsigned depth); 120100206Sddstatic void devfs_ruleset_applydm(struct devfs_ruleset *ds, 121100206Sdd struct devfs_mount *dm); 122100206Sddstatic struct devfs_ruleset *devfs_ruleset_bynum(devfs_rsnum rsnum); 123100206Sddstatic struct devfs_ruleset *devfs_ruleset_create(devfs_rsnum rsnum); 124150501Sphkstatic void devfs_ruleset_reap(struct devfs_ruleset *dsp); 125100206Sddstatic int devfs_ruleset_use(devfs_rsnum rsnum, struct devfs_mount *dm); 126100206Sdd 127150150Sphkstatic struct sx sx_rules; 128150501SphkSX_SYSINIT(sx_rules, &sx_rules, "DEVFS ruleset lock"); 129100206Sdd 130150501Sphkstatic TAILQ_HEAD(, devfs_ruleset) devfs_rulesets = 131150501Sphk TAILQ_HEAD_INITIALIZER(devfs_rulesets); 132150501Sphk 133100206Sdd/* 134150147Sphk * Called to apply the proper rules for 'de' before it can be 135100206Sdd * exposed to the userland. This should be called with an exclusive 136100206Sdd * lock on dm in case we need to run anything. 137100206Sdd */ 138100206Sddvoid 139100206Sdddevfs_rules_apply(struct devfs_mount *dm, struct devfs_dirent *de) 140100206Sdd{ 141100206Sdd struct devfs_ruleset *ds; 142100206Sdd 143150501Sphk if (dm->dm_ruleset == 0) 144150501Sphk return; 145150150Sphk sx_slock(&sx_rules); 146100206Sdd ds = devfs_ruleset_bynum(dm->dm_ruleset); 147100206Sdd KASSERT(ds != NULL, ("mount-point has NULL ruleset")); 148150147Sphk devfs_ruleset_applyde(ds, de, devfs_rule_depth); 149150150Sphk sx_sunlock(&sx_rules); 150100206Sdd} 151100206Sdd 152100206Sdd/* 153100206Sdd * Rule subsystem ioctl hook. 154100206Sdd */ 155100206Sddint 156150149Sphkdevfs_rules_ioctl(struct devfs_mount *dm, u_long cmd, caddr_t data, struct thread *td) 157100206Sdd{ 158100206Sdd struct devfs_ruleset *ds; 159100206Sdd struct devfs_krule *dk; 160100206Sdd struct devfs_rule *dr; 161100206Sdd devfs_rsnum rsnum; 162100206Sdd devfs_rnum rnum; 163100206Sdd devfs_rid rid; 164100206Sdd int error; 165100206Sdd 166150342Sphk sx_assert(&dm->dm_lock, SX_XLOCKED); 167150342Sphk 168100206Sdd /* 169100206Sdd * XXX: This returns an error regardless of whether we 170100206Sdd * actually support the cmd or not. 171100206Sdd */ 172100206Sdd error = suser(td); 173100206Sdd if (error != 0) 174100206Sdd return (error); 175100206Sdd 176150150Sphk sx_xlock(&sx_rules); 177150342Sphk 178100206Sdd switch (cmd) { 179100206Sdd case DEVFSIO_RADD: 180100206Sdd dr = (struct devfs_rule *)data; 181100206Sdd error = devfs_rule_input(dr, dm); 182100206Sdd if (error != 0) 183150501Sphk break; 184100206Sdd dk = devfs_rule_byid(dr->dr_id); 185100206Sdd if (dk != NULL) { 186100206Sdd error = EEXIST; 187150501Sphk break; 188100206Sdd } 189150501Sphk if (rid2rsn(dr->dr_id) == 0) 190150501Sphk return (EIO); 191100206Sdd error = devfs_rule_insert(dr); 192100206Sdd break; 193100206Sdd case DEVFSIO_RAPPLY: 194100206Sdd dr = (struct devfs_rule *)data; 195100206Sdd error = devfs_rule_input(dr, dm); 196100206Sdd if (error != 0) 197150501Sphk break; 198100206Sdd 199100206Sdd /* 200100206Sdd * This is one of many possible hackish 201100206Sdd * implementations. The primary contender is an 202100206Sdd * implementation where the rule we read in is 203100206Sdd * temporarily inserted into some ruleset, perhaps 204100206Sdd * with a hypothetical DRO_NOAUTO flag so that it 205100206Sdd * doesn't get used where it isn't intended, and 206100206Sdd * applied in the normal way. This can be done in the 207100206Sdd * userland (DEVFSIO_ADD, DEVFSIO_APPLYID, 208100206Sdd * DEVFSIO_DEL) or in the kernel; either way it breaks 209100206Sdd * some corner case assumptions in other parts of the 210100206Sdd * code (not that this implementation doesn't do 211100206Sdd * that). 212100206Sdd */ 213100206Sdd if (dr->dr_iacts & DRA_INCSET && 214100206Sdd devfs_ruleset_bynum(dr->dr_incset) == NULL) { 215100206Sdd error = ESRCH; 216150501Sphk break; 217100206Sdd } 218111119Simp dk = malloc(sizeof(*dk), M_TEMP, M_WAITOK | M_ZERO); 219100206Sdd memcpy(&dk->dk_rule, dr, sizeof(*dr)); 220100206Sdd devfs_rule_applydm(dk, dm); 221100206Sdd free(dk, M_TEMP); 222100206Sdd break; 223100206Sdd case DEVFSIO_RAPPLYID: 224100206Sdd rid = *(devfs_rid *)data; 225100206Sdd rid = devfs_rid_input(rid, dm); 226100206Sdd dk = devfs_rule_byid(rid); 227100206Sdd if (dk == NULL) { 228100206Sdd error = ENOENT; 229150501Sphk break; 230100206Sdd } 231100206Sdd devfs_rule_applydm(dk, dm); 232100206Sdd break; 233100206Sdd case DEVFSIO_RDEL: 234100206Sdd rid = *(devfs_rid *)data; 235100206Sdd rid = devfs_rid_input(rid, dm); 236100206Sdd dk = devfs_rule_byid(rid); 237100206Sdd if (dk == NULL) { 238100206Sdd error = ENOENT; 239150501Sphk break; 240100206Sdd } 241100206Sdd ds = dk->dk_ruleset; 242150501Sphk error = devfs_rule_delete(dk); 243100206Sdd break; 244100206Sdd case DEVFSIO_RGETNEXT: 245100206Sdd dr = (struct devfs_rule *)data; 246100206Sdd error = devfs_rule_input(dr, dm); 247100206Sdd if (error != 0) 248150501Sphk break; 249100206Sdd /* 250100206Sdd * We can't use devfs_rule_byid() here since that 251100206Sdd * requires the rule specified to exist, but we want 252100206Sdd * getnext(N) to work whether there is a rule N or not 253100206Sdd * (specifically, getnext(0) must work, but we should 254100206Sdd * never have a rule 0 since the add command 255100206Sdd * interprets 0 to mean "auto-number"). 256100206Sdd */ 257100206Sdd ds = devfs_ruleset_bynum(rid2rsn(dr->dr_id)); 258100206Sdd if (ds == NULL) { 259100206Sdd error = ENOENT; 260150501Sphk break; 261100206Sdd } 262100206Sdd rnum = rid2rn(dr->dr_id); 263150501Sphk TAILQ_FOREACH(dk, &ds->ds_rules, dk_list) { 264100206Sdd if (rid2rn(dk->dk_rule.dr_id) > rnum) 265100206Sdd break; 266100206Sdd } 267100206Sdd if (dk == NULL) { 268100206Sdd error = ENOENT; 269150501Sphk break; 270100206Sdd } 271100206Sdd memcpy(dr, &dk->dk_rule, sizeof(*dr)); 272100206Sdd break; 273100206Sdd case DEVFSIO_SUSE: 274100206Sdd rsnum = *(devfs_rsnum *)data; 275100206Sdd error = devfs_ruleset_use(rsnum, dm); 276100206Sdd break; 277100206Sdd case DEVFSIO_SAPPLY: 278100206Sdd rsnum = *(devfs_rsnum *)data; 279100206Sdd rsnum = rid2rsn(devfs_rid_input(mkrid(rsnum, 0), dm)); 280100206Sdd ds = devfs_ruleset_bynum(rsnum); 281100206Sdd if (ds == NULL) { 282100206Sdd error = ESRCH; 283150501Sphk break; 284100206Sdd } 285100206Sdd devfs_ruleset_applydm(ds, dm); 286100206Sdd break; 287100206Sdd case DEVFSIO_SGETNEXT: 288100206Sdd rsnum = *(devfs_rsnum *)data; 289150501Sphk TAILQ_FOREACH(ds, &devfs_rulesets, ds_list) { 290100206Sdd if (ds->ds_number > rsnum) 291100206Sdd break; 292100206Sdd } 293150501Sphk if (ds == NULL) { 294100206Sdd error = ENOENT; 295150501Sphk break; 296100206Sdd } 297150501Sphk *(devfs_rsnum *)data = ds->ds_number; 298100206Sdd break; 299100206Sdd default: 300100206Sdd error = ENOIOCTL; 301100206Sdd break; 302100206Sdd } 303100206Sdd 304150150Sphk sx_xunlock(&sx_rules); 305100206Sdd return (error); 306100206Sdd} 307100206Sdd 308100206Sdd/* 309100206Sdd * Adjust the rule identifier to use the ruleset of dm if one isn't 310100206Sdd * explicitly specified. 311100206Sdd * 312100206Sdd * Note that after this operation, rid2rsn(rid) might still be 0, and 313100206Sdd * that's okay; ruleset 0 is a valid ruleset, but when it's read in 314100206Sdd * from the userland, it means "current ruleset for this mount-point". 315100206Sdd */ 316100206Sddstatic devfs_rid 317100206Sdddevfs_rid_input(devfs_rid rid, struct devfs_mount *dm) 318100206Sdd{ 319100206Sdd 320100206Sdd if (rid2rsn(rid) == 0) 321100206Sdd return (mkrid(dm->dm_ruleset, rid2rn(rid))); 322100206Sdd else 323100206Sdd return (rid); 324100206Sdd} 325100206Sdd 326100206Sdd/* 327100206Sdd * Apply dk to de and everything under de. 328100206Sdd * 329100206Sdd * XXX: This method needs a function call for every nested 330100206Sdd * subdirectory in a devfs mount. If we plan to have many of these, 331100206Sdd * we might eventually run out of kernel stack space. 332150342Sphk * XXX: a linear search could be done through the cdev list instead. 333100206Sdd */ 334100206Sddstatic void 335100206Sdddevfs_rule_applyde_recursive(struct devfs_krule *dk, struct devfs_dirent *de) 336100206Sdd{ 337100206Sdd struct devfs_dirent *de2; 338100206Sdd 339150147Sphk TAILQ_FOREACH(de2, &de->de_dlist, de_list) 340100206Sdd devfs_rule_applyde_recursive(dk, de2); 341150147Sphk devfs_rule_run(dk, de, devfs_rule_depth); 342100206Sdd} 343100206Sdd 344100206Sdd/* 345100206Sdd * Apply dk to all entires in dm. 346100206Sdd */ 347100206Sddstatic void 348100206Sdddevfs_rule_applydm(struct devfs_krule *dk, struct devfs_mount *dm) 349100206Sdd{ 350100206Sdd 351149107Sphk devfs_rule_applyde_recursive(dk, dm->dm_rootdir); 352100206Sdd} 353100206Sdd 354100206Sdd/* 355100206Sdd * Automatically select a number for a new rule in ds, and write the 356100206Sdd * result into rnump. 357100206Sdd */ 358100206Sddstatic int 359100206Sdddevfs_rule_autonumber(struct devfs_ruleset *ds, devfs_rnum *rnump) 360100206Sdd{ 361100206Sdd struct devfs_krule *dk; 362100206Sdd 363100206Sdd /* Find the last rule. */ 364150501Sphk dk = TAILQ_LAST(&ds->ds_rules, rulehead); 365100206Sdd if (dk == NULL) 366100206Sdd *rnump = 100; 367100206Sdd else { 368100206Sdd *rnump = rid2rn(dk->dk_rule.dr_id) + 100; 369100206Sdd /* Detect overflow. */ 370100206Sdd if (*rnump < rid2rn(dk->dk_rule.dr_id)) 371100206Sdd return (ERANGE); 372100206Sdd } 373100206Sdd KASSERT(devfs_rule_byid(mkrid(ds->ds_number, *rnump)) == NULL, 374100206Sdd ("autonumbering resulted in an already existing rule")); 375100206Sdd return (0); 376100206Sdd} 377100206Sdd 378100206Sdd/* 379100206Sdd * Find a krule by id. 380100206Sdd */ 381100206Sddstatic struct devfs_krule * 382100206Sdddevfs_rule_byid(devfs_rid rid) 383100206Sdd{ 384100206Sdd struct devfs_ruleset *ds; 385100206Sdd struct devfs_krule *dk; 386100206Sdd devfs_rnum rn; 387100206Sdd 388100206Sdd rn = rid2rn(rid); 389100206Sdd ds = devfs_ruleset_bynum(rid2rsn(rid)); 390100206Sdd if (ds == NULL) 391100206Sdd return (NULL); 392150501Sphk TAILQ_FOREACH(dk, &ds->ds_rules, dk_list) { 393100206Sdd if (rid2rn(dk->dk_rule.dr_id) == rn) 394100206Sdd return (dk); 395100206Sdd else if (rid2rn(dk->dk_rule.dr_id) > rn) 396100206Sdd break; 397100206Sdd } 398100206Sdd return (NULL); 399100206Sdd} 400100206Sdd 401100206Sdd/* 402100206Sdd * Remove dkp from any lists it may be on and remove memory associated 403100206Sdd * with it. 404100206Sdd */ 405100206Sddstatic int 406150501Sphkdevfs_rule_delete(struct devfs_krule *dk) 407100206Sdd{ 408100206Sdd struct devfs_ruleset *ds; 409100206Sdd 410100206Sdd if (dk->dk_rule.dr_iacts & DRA_INCSET) { 411100206Sdd ds = devfs_ruleset_bynum(dk->dk_rule.dr_incset); 412100206Sdd KASSERT(ds != NULL, ("DRA_INCSET but bad dr_incset")); 413100206Sdd --ds->ds_refcount; 414150501Sphk devfs_ruleset_reap(ds); 415100206Sdd } 416150501Sphk ds = dk->dk_ruleset; 417150501Sphk TAILQ_REMOVE(&ds->ds_rules, dk, dk_list); 418150501Sphk devfs_ruleset_reap(ds); 419150501Sphk free(dk, M_DEVFSRULE); 420100206Sdd return (0); 421100206Sdd} 422100206Sdd 423100206Sdd/* 424130585Sphk * Get a struct cdev *corresponding to de so we can try to match rules based 425130585Sphk * on it. If this routine returns NULL, there is no struct cdev *associated 426100206Sdd * with the dirent (symlinks and directories don't have dev_ts), and 427100206Sdd * the caller should assume that any critera dependent on a dev_t 428100206Sdd * don't match. 429100206Sdd */ 430130585Sphkstatic struct cdev * 431100206Sdddevfs_rule_getdev(struct devfs_dirent *de) 432100206Sdd{ 433100206Sdd 434150342Sphk if (de->de_cdp == NULL) 435150342Sphk return (NULL); 436150342Sphk if (de->de_cdp->cdp_flags & CDP_ACTIVE) 437150342Sphk return (&de->de_cdp->cdp_c); 438100206Sdd else 439150342Sphk return (NULL); 440100206Sdd} 441100206Sdd 442100206Sdd/* 443100206Sdd * Do what we need to do to a rule that we just loaded from the 444100206Sdd * userland. In particular, we need to check the magic, and adjust 445100206Sdd * the ruleset appropriate if desired. 446100206Sdd */ 447100206Sddstatic int 448100206Sdddevfs_rule_input(struct devfs_rule *dr, struct devfs_mount *dm) 449100206Sdd{ 450100206Sdd 451100206Sdd if (dr->dr_magic != DEVFS_MAGIC) 452100206Sdd return (ERPCMISMATCH); 453100206Sdd dr->dr_id = devfs_rid_input(dr->dr_id, dm); 454100206Sdd return (0); 455100206Sdd} 456100206Sdd 457100206Sdd/* 458100206Sdd * Import dr into the appropriate place in the kernel (i.e., make a 459100206Sdd * krule). The value of dr is copied, so the pointer may be destroyed 460100206Sdd * after this call completes. 461100206Sdd */ 462100206Sddstatic int 463100206Sdddevfs_rule_insert(struct devfs_rule *dr) 464100206Sdd{ 465100206Sdd struct devfs_ruleset *ds, *dsi; 466150501Sphk struct devfs_krule *k1; 467100206Sdd struct devfs_krule *dk; 468100206Sdd devfs_rsnum rsnum; 469100206Sdd devfs_rnum dkrn; 470100206Sdd int error; 471100206Sdd 472100206Sdd /* 473100206Sdd * This stuff seems out of place here, but we want to do it as 474100206Sdd * soon as possible so that if it fails, we don't have to roll 475100206Sdd * back any changes we already made (e.g., ruleset creation). 476100206Sdd */ 477100206Sdd if (dr->dr_iacts & DRA_INCSET) { 478100206Sdd dsi = devfs_ruleset_bynum(dr->dr_incset); 479100206Sdd if (dsi == NULL) 480100206Sdd return (ESRCH); 481100206Sdd } else 482100206Sdd dsi = NULL; 483100206Sdd 484100206Sdd rsnum = rid2rsn(dr->dr_id); 485150501Sphk KASSERT(rsnum != 0, ("Inserting into ruleset zero")); 486150501Sphk 487100206Sdd ds = devfs_ruleset_bynum(rsnum); 488100206Sdd if (ds == NULL) 489100206Sdd ds = devfs_ruleset_create(rsnum); 490100206Sdd dkrn = rid2rn(dr->dr_id); 491100206Sdd if (dkrn == 0) { 492100206Sdd error = devfs_rule_autonumber(ds, &dkrn); 493150501Sphk if (error != 0) { 494150501Sphk devfs_ruleset_reap(ds); 495100206Sdd return (error); 496150501Sphk } 497100206Sdd } 498100206Sdd 499150501Sphk dk = malloc(sizeof(*dk), M_DEVFSRULE, M_WAITOK | M_ZERO); 500100206Sdd dk->dk_ruleset = ds; 501100206Sdd if (dsi != NULL) 502100206Sdd ++dsi->ds_refcount; 503100206Sdd /* XXX: Inspect dr? */ 504100206Sdd memcpy(&dk->dk_rule, dr, sizeof(*dr)); 505100206Sdd dk->dk_rule.dr_id = mkrid(rid2rsn(dk->dk_rule.dr_id), dkrn); 506100206Sdd 507150501Sphk TAILQ_FOREACH(k1, &ds->ds_rules, dk_list) { 508150501Sphk if (rid2rn(k1->dk_rule.dr_id) > dkrn) { 509150501Sphk TAILQ_INSERT_BEFORE(k1, dk, dk_list); 510150501Sphk break; 511100206Sdd } 512100206Sdd } 513150501Sphk if (k1 == NULL) 514150501Sphk TAILQ_INSERT_TAIL(&ds->ds_rules, dk, dk_list); 515100206Sdd return (0); 516100206Sdd} 517100206Sdd 518100206Sdd/* 519100206Sdd * Determine whether dk matches de. Returns 1 if dk should be run on 520100206Sdd * de; 0, otherwise. 521100206Sdd */ 522100206Sddstatic int 523100206Sdddevfs_rule_match(struct devfs_krule *dk, struct devfs_dirent *de) 524100206Sdd{ 525100206Sdd struct devfs_rule *dr = &dk->dk_rule; 526130585Sphk struct cdev *dev; 527100206Sdd 528100206Sdd dev = devfs_rule_getdev(de); 529100206Sdd /* 530100206Sdd * At this point, if dev is NULL, we should assume that any 531100206Sdd * criteria that depend on it don't match. We should *not* 532100206Sdd * just ignore them (i.e., act like they weren't specified), 533100206Sdd * since that makes a rule that only has criteria dependent on 534130585Sphk * the struct cdev *match all symlinks and directories. 535100206Sdd * 536100206Sdd * Note also that the following tests are somewhat reversed: 537100206Sdd * They're actually testing to see whether the condition does 538100206Sdd * *not* match, since the default is to assume the rule should 539100206Sdd * be run (such as if there are no conditions). 540135727Sphk * 541135727Sphk * XXX: lacks threadref on dev 542100206Sdd */ 543100206Sdd if (dr->dr_icond & DRC_DSWFLAGS) 544100206Sdd if (dev == NULL || 545100206Sdd (dev->si_devsw->d_flags & dr->dr_dswflags) == 0) 546150147Sphk return (0); 547100206Sdd if (dr->dr_icond & DRC_PATHPTRN) 548100206Sdd if (!devfs_rule_matchpath(dk, de)) 549150147Sphk return (0); 550100206Sdd 551100206Sdd return (1); 552100206Sdd} 553100206Sdd 554100206Sdd/* 555100206Sdd * Determine whether dk matches de on account of dr_pathptrn. 556100206Sdd */ 557100206Sddstatic int 558100206Sdddevfs_rule_matchpath(struct devfs_krule *dk, struct devfs_dirent *de) 559100206Sdd{ 560100206Sdd struct devfs_rule *dr = &dk->dk_rule; 561100206Sdd char *pname; 562130585Sphk struct cdev *dev; 563100206Sdd 564100206Sdd dev = devfs_rule_getdev(de); 565100206Sdd if (dev != NULL) 566100206Sdd pname = dev->si_name; 567124798Scperciva else if (de->de_dirent->d_type == DT_LNK || 568124804Scperciva de->de_dirent->d_type == DT_DIR) 569109090Sdd pname = de->de_dirent->d_name; 570100206Sdd else 571100206Sdd return (0); 572100206Sdd KASSERT(pname != NULL, ("devfs_rule_matchpath: NULL pname")); 573100206Sdd 574104653Sdd return (fnmatch(dr->dr_pathptrn, pname, 0) == 0); 575100206Sdd} 576100206Sdd 577100206Sdd/* 578100206Sdd * Run dk on de. 579100206Sdd */ 580100206Sddstatic void 581150147Sphkdevfs_rule_run(struct devfs_krule *dk, struct devfs_dirent *de, unsigned depth) 582100206Sdd{ 583100206Sdd struct devfs_rule *dr = &dk->dk_rule; 584100206Sdd struct devfs_ruleset *ds; 585100206Sdd 586150147Sphk if (!devfs_rule_match(dk, de)) 587150147Sphk return; 588100206Sdd if (dr->dr_iacts & DRA_BACTS) { 589100206Sdd if (dr->dr_bacts & DRB_HIDE) 590100206Sdd de->de_flags |= DE_WHITEOUT; 591100206Sdd if (dr->dr_bacts & DRB_UNHIDE) 592100206Sdd de->de_flags &= ~DE_WHITEOUT; 593100206Sdd } 594100206Sdd if (dr->dr_iacts & DRA_UID) 595100206Sdd de->de_uid = dr->dr_uid; 596100206Sdd if (dr->dr_iacts & DRA_GID) 597100206Sdd de->de_gid = dr->dr_gid; 598100206Sdd if (dr->dr_iacts & DRA_MODE) 599100206Sdd de->de_mode = dr->dr_mode; 600100206Sdd if (dr->dr_iacts & DRA_INCSET) { 601150147Sphk /* 602150147Sphk * XXX: we should tell the user if the depth is exceeded here 603150147Sphk * XXX: but it is not obvious how to. A return value will 604150147Sphk * XXX: not work as this is called when devices are created 605150147Sphk * XXX: long time after the rules were instantiated. 606150147Sphk * XXX: a printf() would probably give too much noise, or 607150147Sphk * XXX: DoS the machine. I guess a a rate-limited message 608150147Sphk * XXX: might work. 609150147Sphk */ 610150147Sphk if (depth > 0) { 611150147Sphk ds = devfs_ruleset_bynum(dk->dk_rule.dr_incset); 612150147Sphk KASSERT(ds != NULL, ("DRA_INCSET but bad dr_incset")); 613150147Sphk devfs_ruleset_applyde(ds, de, depth - 1); 614150147Sphk } 615100206Sdd } 616100206Sdd} 617100206Sdd 618100206Sdd/* 619100206Sdd * Apply all the rules in ds to de. 620100206Sdd */ 621100206Sddstatic void 622150147Sphkdevfs_ruleset_applyde(struct devfs_ruleset *ds, struct devfs_dirent *de, unsigned depth) 623100206Sdd{ 624100206Sdd struct devfs_krule *dk; 625100206Sdd 626150501Sphk TAILQ_FOREACH(dk, &ds->ds_rules, dk_list) 627150147Sphk devfs_rule_run(dk, de, depth); 628100206Sdd} 629100206Sdd 630100206Sdd/* 631100206Sdd * Apply all the rules in ds to all the entires in dm. 632100206Sdd */ 633100206Sddstatic void 634100206Sdddevfs_ruleset_applydm(struct devfs_ruleset *ds, struct devfs_mount *dm) 635100206Sdd{ 636100206Sdd struct devfs_krule *dk; 637100206Sdd 638100206Sdd /* 639100206Sdd * XXX: Does it matter whether we do 640100206Sdd * 641100206Sdd * foreach(dk in ds) 642100206Sdd * foreach(de in dm) 643100206Sdd * apply(dk to de) 644100206Sdd * 645100206Sdd * as opposed to 646100206Sdd * 647100206Sdd * foreach(de in dm) 648100206Sdd * foreach(dk in ds) 649100206Sdd * apply(dk to de) 650100206Sdd * 651100206Sdd * The end result is obviously the same, but does the order 652100206Sdd * matter? 653100206Sdd */ 654150501Sphk TAILQ_FOREACH(dk, &ds->ds_rules, dk_list) 655100206Sdd devfs_rule_applydm(dk, dm); 656100206Sdd} 657100206Sdd 658100206Sdd/* 659100206Sdd * Find a ruleset by number. 660100206Sdd */ 661100206Sddstatic struct devfs_ruleset * 662100206Sdddevfs_ruleset_bynum(devfs_rsnum rsnum) 663100206Sdd{ 664100206Sdd struct devfs_ruleset *ds; 665100206Sdd 666150501Sphk TAILQ_FOREACH(ds, &devfs_rulesets, ds_list) { 667100206Sdd if (ds->ds_number == rsnum) 668100206Sdd return (ds); 669100206Sdd } 670100206Sdd return (NULL); 671100206Sdd} 672100206Sdd 673100206Sdd/* 674100206Sdd * Create a new ruleset. 675100206Sdd */ 676100206Sddstatic struct devfs_ruleset * 677100206Sdddevfs_ruleset_create(devfs_rsnum rsnum) 678100206Sdd{ 679150501Sphk struct devfs_ruleset *s1; 680100206Sdd struct devfs_ruleset *ds; 681100206Sdd 682150501Sphk KASSERT(rsnum != 0, ("creating ruleset zero")); 683150501Sphk 684100206Sdd KASSERT(devfs_ruleset_bynum(rsnum) == NULL, 685100206Sdd ("creating already existent ruleset %d", rsnum)); 686100206Sdd 687150501Sphk ds = malloc(sizeof(*ds), M_DEVFSRULE, M_WAITOK | M_ZERO); 688100206Sdd ds->ds_number = rsnum; 689150501Sphk TAILQ_INIT(&ds->ds_rules); 690100206Sdd 691150501Sphk TAILQ_FOREACH(s1, &devfs_rulesets, ds_list) { 692150501Sphk if (s1->ds_number > rsnum) { 693150501Sphk TAILQ_INSERT_BEFORE(s1, ds, ds_list); 694150501Sphk break; 695100206Sdd } 696100206Sdd } 697150501Sphk if (s1 == NULL) 698150501Sphk TAILQ_INSERT_TAIL(&devfs_rulesets, ds, ds_list); 699100206Sdd return (ds); 700100206Sdd} 701100206Sdd 702100206Sdd/* 703100206Sdd * Remove a ruleset from the system if it's empty and not used 704100206Sdd * anywhere. This should be called after every time a rule is deleted 705100206Sdd * from this ruleset or the reference count is decremented. 706100206Sdd */ 707100206Sddstatic void 708150501Sphkdevfs_ruleset_reap(struct devfs_ruleset *ds) 709100206Sdd{ 710100206Sdd 711150501Sphk KASSERT(ds->ds_number != 0, ("reaping ruleset zero ")); 712150501Sphk 713150501Sphk if (!TAILQ_EMPTY(&ds->ds_rules) || ds->ds_refcount != 0) 714150501Sphk return; 715150501Sphk 716150501Sphk TAILQ_REMOVE(&devfs_rulesets, ds, ds_list); 717150501Sphk free(ds, M_DEVFSRULE); 718100206Sdd} 719100206Sdd 720100206Sdd/* 721100206Sdd * Make rsnum the active ruleset for dm. 722100206Sdd */ 723100206Sddstatic int 724100206Sdddevfs_ruleset_use(devfs_rsnum rsnum, struct devfs_mount *dm) 725100206Sdd{ 726100206Sdd struct devfs_ruleset *cds, *ds; 727100206Sdd 728100206Sdd ds = devfs_ruleset_bynum(rsnum); 729100206Sdd if (ds == NULL) 730100206Sdd ds = devfs_ruleset_create(rsnum); 731150501Sphk if (dm->dm_ruleset != 0) { 732150501Sphk cds = devfs_ruleset_bynum(dm->dm_ruleset); 733150501Sphk --cds->ds_refcount; 734150501Sphk devfs_ruleset_reap(cds); 735150501Sphk } 736100206Sdd 737100206Sdd /* These should probably be made atomic somehow. */ 738100206Sdd ++ds->ds_refcount; 739100206Sdd dm->dm_ruleset = rsnum; 740100206Sdd 741100206Sdd return (0); 742100206Sdd} 743150501Sphk 744150501Sphkvoid 745150501Sphkdevfs_rules_cleanup(struct devfs_mount *dm) 746150501Sphk{ 747150501Sphk struct devfs_ruleset *ds; 748150501Sphk 749150501Sphk sx_assert(&dm->dm_lock, SX_XLOCKED); 750150501Sphk if (dm->dm_ruleset != 0) { 751150501Sphk ds = devfs_ruleset_bynum(dm->dm_ruleset); 752150501Sphk --ds->ds_refcount; 753150501Sphk devfs_ruleset_reap(ds); 754150501Sphk } 755150501Sphk} 756