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: releng/10.2/sys/fs/devfs/devfs_rule.c 253677 2013-07-26 14:25:58Z avg $ 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 <sys/param.h> 66100206Sdd#include <sys/systm.h> 67100206Sdd#include <sys/conf.h> 68100206Sdd#include <sys/kernel.h> 69100206Sdd#include <sys/malloc.h> 70164033Srwatson#include <sys/priv.h> 71100206Sdd#include <sys/dirent.h> 72100206Sdd#include <sys/ioccom.h> 73150342Sphk#include <sys/lock.h> 74150150Sphk#include <sys/sx.h> 75100206Sdd 76100206Sdd#include <fs/devfs/devfs.h> 77150342Sphk#include <fs/devfs/devfs_int.h> 78100206Sdd 79100206Sdd/* 80100206Sdd * Kernel version of devfs_rule. 81100206Sdd */ 82100206Sddstruct devfs_krule { 83150501Sphk TAILQ_ENTRY(devfs_krule) dk_list; 84150501Sphk struct devfs_ruleset *dk_ruleset; 85150501Sphk struct devfs_rule dk_rule; 86100206Sdd}; 87100206Sdd 88150501SphkTAILQ_HEAD(rulehead, devfs_krule); 89150501Sphkstatic MALLOC_DEFINE(M_DEVFSRULE, "DEVFS_RULE", "DEVFS rule storage"); 90150501Sphk 91100206Sdd/* 92100206Sdd * Structure to describe a ruleset. 93100206Sdd */ 94100206Sddstruct devfs_ruleset { 95150501Sphk TAILQ_ENTRY(devfs_ruleset) ds_list; 96150501Sphk struct rulehead ds_rules; 97150501Sphk devfs_rsnum ds_number; 98150501Sphk int ds_refcount; 99100206Sdd}; 100100206Sdd 101100206Sddstatic devfs_rid devfs_rid_input(devfs_rid rid, struct devfs_mount *dm); 102100206Sdd 103100206Sddstatic void devfs_rule_applyde_recursive(struct devfs_krule *dk, 104253677Savg struct devfs_mount *dm, struct devfs_dirent *de); 105100206Sddstatic void devfs_rule_applydm(struct devfs_krule *dk, struct devfs_mount *dm); 106100206Sddstatic int devfs_rule_autonumber(struct devfs_ruleset *ds, devfs_rnum *rnp); 107100206Sddstatic struct devfs_krule *devfs_rule_byid(devfs_rid rid); 108150501Sphkstatic int devfs_rule_delete(struct devfs_krule *dkp); 109130585Sphkstatic struct cdev *devfs_rule_getdev(struct devfs_dirent *de); 110100206Sddstatic int devfs_rule_input(struct devfs_rule *dr, struct devfs_mount *dm); 111100206Sddstatic int devfs_rule_insert(struct devfs_rule *dr); 112253677Savgstatic int devfs_rule_match(struct devfs_krule *dk, struct devfs_mount *dm, 113100206Sdd struct devfs_dirent *de); 114253677Savgstatic int devfs_rule_matchpath(struct devfs_krule *dk, struct devfs_mount *dm, 115253677Savg struct devfs_dirent *de); 116253677Savgstatic void devfs_rule_run(struct devfs_krule *dk, struct devfs_mount *dm, 117253677Savg struct devfs_dirent *de, unsigned depth); 118100206Sdd 119100206Sddstatic void devfs_ruleset_applyde(struct devfs_ruleset *ds, 120253677Savg struct devfs_mount *dm, struct devfs_dirent *de, 121253677Savg unsigned depth); 122100206Sddstatic void devfs_ruleset_applydm(struct devfs_ruleset *ds, 123100206Sdd struct devfs_mount *dm); 124100206Sddstatic struct devfs_ruleset *devfs_ruleset_bynum(devfs_rsnum rsnum); 125100206Sddstatic struct devfs_ruleset *devfs_ruleset_create(devfs_rsnum rsnum); 126150501Sphkstatic void devfs_ruleset_reap(struct devfs_ruleset *dsp); 127100206Sddstatic int devfs_ruleset_use(devfs_rsnum rsnum, struct devfs_mount *dm); 128100206Sdd 129150150Sphkstatic struct sx sx_rules; 130150501SphkSX_SYSINIT(sx_rules, &sx_rules, "DEVFS ruleset lock"); 131100206Sdd 132150501Sphkstatic TAILQ_HEAD(, devfs_ruleset) devfs_rulesets = 133150501Sphk TAILQ_HEAD_INITIALIZER(devfs_rulesets); 134150501Sphk 135100206Sdd/* 136150147Sphk * Called to apply the proper rules for 'de' before it can be 137100206Sdd * exposed to the userland. This should be called with an exclusive 138100206Sdd * lock on dm in case we need to run anything. 139100206Sdd */ 140100206Sddvoid 141100206Sdddevfs_rules_apply(struct devfs_mount *dm, struct devfs_dirent *de) 142100206Sdd{ 143100206Sdd struct devfs_ruleset *ds; 144100206Sdd 145216461Sjh sx_assert(&dm->dm_lock, SX_XLOCKED); 146216461Sjh 147150501Sphk if (dm->dm_ruleset == 0) 148150501Sphk return; 149150150Sphk sx_slock(&sx_rules); 150100206Sdd ds = devfs_ruleset_bynum(dm->dm_ruleset); 151100206Sdd KASSERT(ds != NULL, ("mount-point has NULL ruleset")); 152253677Savg devfs_ruleset_applyde(ds, dm, de, devfs_rule_depth); 153150150Sphk sx_sunlock(&sx_rules); 154100206Sdd} 155100206Sdd 156100206Sdd/* 157100206Sdd * Rule subsystem ioctl hook. 158100206Sdd */ 159100206Sddint 160150149Sphkdevfs_rules_ioctl(struct devfs_mount *dm, u_long cmd, caddr_t data, struct thread *td) 161100206Sdd{ 162100206Sdd struct devfs_ruleset *ds; 163100206Sdd struct devfs_krule *dk; 164100206Sdd struct devfs_rule *dr; 165100206Sdd devfs_rsnum rsnum; 166100206Sdd devfs_rnum rnum; 167100206Sdd devfs_rid rid; 168100206Sdd int error; 169100206Sdd 170150342Sphk sx_assert(&dm->dm_lock, SX_XLOCKED); 171150342Sphk 172100206Sdd /* 173164033Srwatson * XXX: This returns an error regardless of whether we actually 174164033Srwatson * support the cmd or not. 175164033Srwatson * 176164033Srwatson * We could make this privileges finer grained if desired. 177100206Sdd */ 178164033Srwatson error = priv_check(td, PRIV_DEVFS_RULE); 179164033Srwatson if (error) 180100206Sdd return (error); 181100206Sdd 182150150Sphk sx_xlock(&sx_rules); 183150342Sphk 184100206Sdd switch (cmd) { 185100206Sdd case DEVFSIO_RADD: 186100206Sdd dr = (struct devfs_rule *)data; 187100206Sdd error = devfs_rule_input(dr, dm); 188100206Sdd if (error != 0) 189150501Sphk break; 190100206Sdd dk = devfs_rule_byid(dr->dr_id); 191100206Sdd if (dk != NULL) { 192100206Sdd error = EEXIST; 193150501Sphk break; 194100206Sdd } 195153986Srwatson if (rid2rsn(dr->dr_id) == 0) { 196153986Srwatson error = EIO; 197153986Srwatson break; 198153986Srwatson } 199100206Sdd error = devfs_rule_insert(dr); 200100206Sdd break; 201100206Sdd case DEVFSIO_RAPPLY: 202100206Sdd dr = (struct devfs_rule *)data; 203100206Sdd error = devfs_rule_input(dr, dm); 204100206Sdd if (error != 0) 205150501Sphk break; 206100206Sdd 207100206Sdd /* 208100206Sdd * This is one of many possible hackish 209100206Sdd * implementations. The primary contender is an 210100206Sdd * implementation where the rule we read in is 211100206Sdd * temporarily inserted into some ruleset, perhaps 212100206Sdd * with a hypothetical DRO_NOAUTO flag so that it 213100206Sdd * doesn't get used where it isn't intended, and 214100206Sdd * applied in the normal way. This can be done in the 215100206Sdd * userland (DEVFSIO_ADD, DEVFSIO_APPLYID, 216100206Sdd * DEVFSIO_DEL) or in the kernel; either way it breaks 217100206Sdd * some corner case assumptions in other parts of the 218100206Sdd * code (not that this implementation doesn't do 219100206Sdd * that). 220100206Sdd */ 221100206Sdd if (dr->dr_iacts & DRA_INCSET && 222100206Sdd devfs_ruleset_bynum(dr->dr_incset) == NULL) { 223100206Sdd error = ESRCH; 224150501Sphk break; 225100206Sdd } 226111119Simp dk = malloc(sizeof(*dk), M_TEMP, M_WAITOK | M_ZERO); 227100206Sdd memcpy(&dk->dk_rule, dr, sizeof(*dr)); 228100206Sdd devfs_rule_applydm(dk, dm); 229100206Sdd free(dk, M_TEMP); 230100206Sdd break; 231100206Sdd case DEVFSIO_RAPPLYID: 232100206Sdd rid = *(devfs_rid *)data; 233100206Sdd rid = devfs_rid_input(rid, dm); 234100206Sdd dk = devfs_rule_byid(rid); 235100206Sdd if (dk == NULL) { 236100206Sdd error = ENOENT; 237150501Sphk break; 238100206Sdd } 239100206Sdd devfs_rule_applydm(dk, dm); 240100206Sdd break; 241100206Sdd case DEVFSIO_RDEL: 242100206Sdd rid = *(devfs_rid *)data; 243100206Sdd rid = devfs_rid_input(rid, dm); 244100206Sdd dk = devfs_rule_byid(rid); 245100206Sdd if (dk == NULL) { 246100206Sdd error = ENOENT; 247150501Sphk break; 248100206Sdd } 249100206Sdd ds = dk->dk_ruleset; 250150501Sphk error = devfs_rule_delete(dk); 251100206Sdd break; 252100206Sdd case DEVFSIO_RGETNEXT: 253100206Sdd dr = (struct devfs_rule *)data; 254100206Sdd error = devfs_rule_input(dr, dm); 255100206Sdd if (error != 0) 256150501Sphk break; 257100206Sdd /* 258100206Sdd * We can't use devfs_rule_byid() here since that 259100206Sdd * requires the rule specified to exist, but we want 260100206Sdd * getnext(N) to work whether there is a rule N or not 261100206Sdd * (specifically, getnext(0) must work, but we should 262100206Sdd * never have a rule 0 since the add command 263100206Sdd * interprets 0 to mean "auto-number"). 264100206Sdd */ 265100206Sdd ds = devfs_ruleset_bynum(rid2rsn(dr->dr_id)); 266100206Sdd if (ds == NULL) { 267100206Sdd error = ENOENT; 268150501Sphk break; 269100206Sdd } 270100206Sdd rnum = rid2rn(dr->dr_id); 271150501Sphk TAILQ_FOREACH(dk, &ds->ds_rules, dk_list) { 272100206Sdd if (rid2rn(dk->dk_rule.dr_id) > rnum) 273100206Sdd break; 274100206Sdd } 275100206Sdd if (dk == NULL) { 276100206Sdd error = ENOENT; 277150501Sphk break; 278100206Sdd } 279100206Sdd memcpy(dr, &dk->dk_rule, sizeof(*dr)); 280100206Sdd break; 281100206Sdd case DEVFSIO_SUSE: 282100206Sdd rsnum = *(devfs_rsnum *)data; 283100206Sdd error = devfs_ruleset_use(rsnum, dm); 284100206Sdd break; 285100206Sdd case DEVFSIO_SAPPLY: 286100206Sdd rsnum = *(devfs_rsnum *)data; 287100206Sdd rsnum = rid2rsn(devfs_rid_input(mkrid(rsnum, 0), dm)); 288100206Sdd ds = devfs_ruleset_bynum(rsnum); 289100206Sdd if (ds == NULL) { 290100206Sdd error = ESRCH; 291150501Sphk break; 292100206Sdd } 293100206Sdd devfs_ruleset_applydm(ds, dm); 294100206Sdd break; 295100206Sdd case DEVFSIO_SGETNEXT: 296100206Sdd rsnum = *(devfs_rsnum *)data; 297150501Sphk TAILQ_FOREACH(ds, &devfs_rulesets, ds_list) { 298100206Sdd if (ds->ds_number > rsnum) 299100206Sdd break; 300100206Sdd } 301150501Sphk if (ds == NULL) { 302100206Sdd error = ENOENT; 303150501Sphk break; 304100206Sdd } 305150501Sphk *(devfs_rsnum *)data = ds->ds_number; 306100206Sdd break; 307100206Sdd default: 308100206Sdd error = ENOIOCTL; 309100206Sdd break; 310100206Sdd } 311100206Sdd 312150150Sphk sx_xunlock(&sx_rules); 313100206Sdd return (error); 314100206Sdd} 315100206Sdd 316100206Sdd/* 317100206Sdd * Adjust the rule identifier to use the ruleset of dm if one isn't 318100206Sdd * explicitly specified. 319100206Sdd * 320100206Sdd * Note that after this operation, rid2rsn(rid) might still be 0, and 321100206Sdd * that's okay; ruleset 0 is a valid ruleset, but when it's read in 322100206Sdd * from the userland, it means "current ruleset for this mount-point". 323100206Sdd */ 324100206Sddstatic devfs_rid 325100206Sdddevfs_rid_input(devfs_rid rid, struct devfs_mount *dm) 326100206Sdd{ 327100206Sdd 328100206Sdd if (rid2rsn(rid) == 0) 329100206Sdd return (mkrid(dm->dm_ruleset, rid2rn(rid))); 330100206Sdd else 331100206Sdd return (rid); 332100206Sdd} 333100206Sdd 334100206Sdd/* 335100206Sdd * Apply dk to de and everything under de. 336100206Sdd * 337100206Sdd * XXX: This method needs a function call for every nested 338100206Sdd * subdirectory in a devfs mount. If we plan to have many of these, 339100206Sdd * we might eventually run out of kernel stack space. 340150342Sphk * XXX: a linear search could be done through the cdev list instead. 341100206Sdd */ 342100206Sddstatic void 343253677Savgdevfs_rule_applyde_recursive(struct devfs_krule *dk, struct devfs_mount *dm, 344253677Savg struct devfs_dirent *de) 345100206Sdd{ 346100206Sdd struct devfs_dirent *de2; 347100206Sdd 348150147Sphk TAILQ_FOREACH(de2, &de->de_dlist, de_list) 349253677Savg devfs_rule_applyde_recursive(dk, dm, de2); 350253677Savg devfs_rule_run(dk, dm, de, devfs_rule_depth); 351100206Sdd} 352100206Sdd 353100206Sdd/* 354100206Sdd * Apply dk to all entires in dm. 355100206Sdd */ 356100206Sddstatic void 357100206Sdddevfs_rule_applydm(struct devfs_krule *dk, struct devfs_mount *dm) 358100206Sdd{ 359100206Sdd 360253677Savg devfs_rule_applyde_recursive(dk, dm, dm->dm_rootdir); 361100206Sdd} 362100206Sdd 363100206Sdd/* 364100206Sdd * Automatically select a number for a new rule in ds, and write the 365100206Sdd * result into rnump. 366100206Sdd */ 367100206Sddstatic int 368100206Sdddevfs_rule_autonumber(struct devfs_ruleset *ds, devfs_rnum *rnump) 369100206Sdd{ 370100206Sdd struct devfs_krule *dk; 371100206Sdd 372100206Sdd /* Find the last rule. */ 373150501Sphk dk = TAILQ_LAST(&ds->ds_rules, rulehead); 374100206Sdd if (dk == NULL) 375100206Sdd *rnump = 100; 376100206Sdd else { 377100206Sdd *rnump = rid2rn(dk->dk_rule.dr_id) + 100; 378100206Sdd /* Detect overflow. */ 379100206Sdd if (*rnump < rid2rn(dk->dk_rule.dr_id)) 380100206Sdd return (ERANGE); 381100206Sdd } 382100206Sdd KASSERT(devfs_rule_byid(mkrid(ds->ds_number, *rnump)) == NULL, 383100206Sdd ("autonumbering resulted in an already existing rule")); 384100206Sdd return (0); 385100206Sdd} 386100206Sdd 387100206Sdd/* 388100206Sdd * Find a krule by id. 389100206Sdd */ 390100206Sddstatic struct devfs_krule * 391100206Sdddevfs_rule_byid(devfs_rid rid) 392100206Sdd{ 393100206Sdd struct devfs_ruleset *ds; 394100206Sdd struct devfs_krule *dk; 395100206Sdd devfs_rnum rn; 396100206Sdd 397100206Sdd rn = rid2rn(rid); 398100206Sdd ds = devfs_ruleset_bynum(rid2rsn(rid)); 399100206Sdd if (ds == NULL) 400100206Sdd return (NULL); 401150501Sphk TAILQ_FOREACH(dk, &ds->ds_rules, dk_list) { 402100206Sdd if (rid2rn(dk->dk_rule.dr_id) == rn) 403100206Sdd return (dk); 404100206Sdd else if (rid2rn(dk->dk_rule.dr_id) > rn) 405100206Sdd break; 406100206Sdd } 407100206Sdd return (NULL); 408100206Sdd} 409100206Sdd 410100206Sdd/* 411100206Sdd * Remove dkp from any lists it may be on and remove memory associated 412100206Sdd * with it. 413100206Sdd */ 414100206Sddstatic int 415150501Sphkdevfs_rule_delete(struct devfs_krule *dk) 416100206Sdd{ 417100206Sdd struct devfs_ruleset *ds; 418100206Sdd 419100206Sdd if (dk->dk_rule.dr_iacts & DRA_INCSET) { 420100206Sdd ds = devfs_ruleset_bynum(dk->dk_rule.dr_incset); 421100206Sdd KASSERT(ds != NULL, ("DRA_INCSET but bad dr_incset")); 422100206Sdd --ds->ds_refcount; 423150501Sphk devfs_ruleset_reap(ds); 424100206Sdd } 425150501Sphk ds = dk->dk_ruleset; 426150501Sphk TAILQ_REMOVE(&ds->ds_rules, dk, dk_list); 427150501Sphk devfs_ruleset_reap(ds); 428150501Sphk free(dk, M_DEVFSRULE); 429100206Sdd return (0); 430100206Sdd} 431100206Sdd 432100206Sdd/* 433130585Sphk * Get a struct cdev *corresponding to de so we can try to match rules based 434130585Sphk * on it. If this routine returns NULL, there is no struct cdev *associated 435100206Sdd * with the dirent (symlinks and directories don't have dev_ts), and 436100206Sdd * the caller should assume that any critera dependent on a dev_t 437100206Sdd * don't match. 438100206Sdd */ 439130585Sphkstatic struct cdev * 440100206Sdddevfs_rule_getdev(struct devfs_dirent *de) 441100206Sdd{ 442100206Sdd 443150342Sphk if (de->de_cdp == NULL) 444150342Sphk return (NULL); 445150342Sphk if (de->de_cdp->cdp_flags & CDP_ACTIVE) 446150342Sphk return (&de->de_cdp->cdp_c); 447100206Sdd else 448150342Sphk return (NULL); 449100206Sdd} 450100206Sdd 451100206Sdd/* 452100206Sdd * Do what we need to do to a rule that we just loaded from the 453100206Sdd * userland. In particular, we need to check the magic, and adjust 454100206Sdd * the ruleset appropriate if desired. 455100206Sdd */ 456100206Sddstatic int 457100206Sdddevfs_rule_input(struct devfs_rule *dr, struct devfs_mount *dm) 458100206Sdd{ 459100206Sdd 460100206Sdd if (dr->dr_magic != DEVFS_MAGIC) 461100206Sdd return (ERPCMISMATCH); 462100206Sdd dr->dr_id = devfs_rid_input(dr->dr_id, dm); 463100206Sdd return (0); 464100206Sdd} 465100206Sdd 466100206Sdd/* 467100206Sdd * Import dr into the appropriate place in the kernel (i.e., make a 468100206Sdd * krule). The value of dr is copied, so the pointer may be destroyed 469100206Sdd * after this call completes. 470100206Sdd */ 471100206Sddstatic int 472100206Sdddevfs_rule_insert(struct devfs_rule *dr) 473100206Sdd{ 474100206Sdd struct devfs_ruleset *ds, *dsi; 475150501Sphk struct devfs_krule *k1; 476100206Sdd struct devfs_krule *dk; 477100206Sdd devfs_rsnum rsnum; 478100206Sdd devfs_rnum dkrn; 479100206Sdd int error; 480100206Sdd 481100206Sdd /* 482100206Sdd * This stuff seems out of place here, but we want to do it as 483100206Sdd * soon as possible so that if it fails, we don't have to roll 484100206Sdd * back any changes we already made (e.g., ruleset creation). 485100206Sdd */ 486100206Sdd if (dr->dr_iacts & DRA_INCSET) { 487100206Sdd dsi = devfs_ruleset_bynum(dr->dr_incset); 488100206Sdd if (dsi == NULL) 489100206Sdd return (ESRCH); 490100206Sdd } else 491100206Sdd dsi = NULL; 492100206Sdd 493100206Sdd rsnum = rid2rsn(dr->dr_id); 494150501Sphk KASSERT(rsnum != 0, ("Inserting into ruleset zero")); 495150501Sphk 496100206Sdd ds = devfs_ruleset_bynum(rsnum); 497100206Sdd if (ds == NULL) 498100206Sdd ds = devfs_ruleset_create(rsnum); 499100206Sdd dkrn = rid2rn(dr->dr_id); 500100206Sdd if (dkrn == 0) { 501100206Sdd error = devfs_rule_autonumber(ds, &dkrn); 502150501Sphk if (error != 0) { 503150501Sphk devfs_ruleset_reap(ds); 504100206Sdd return (error); 505150501Sphk } 506100206Sdd } 507100206Sdd 508150501Sphk dk = malloc(sizeof(*dk), M_DEVFSRULE, M_WAITOK | M_ZERO); 509100206Sdd dk->dk_ruleset = ds; 510100206Sdd if (dsi != NULL) 511100206Sdd ++dsi->ds_refcount; 512100206Sdd /* XXX: Inspect dr? */ 513100206Sdd memcpy(&dk->dk_rule, dr, sizeof(*dr)); 514100206Sdd dk->dk_rule.dr_id = mkrid(rid2rsn(dk->dk_rule.dr_id), dkrn); 515100206Sdd 516150501Sphk TAILQ_FOREACH(k1, &ds->ds_rules, dk_list) { 517150501Sphk if (rid2rn(k1->dk_rule.dr_id) > dkrn) { 518150501Sphk TAILQ_INSERT_BEFORE(k1, dk, dk_list); 519150501Sphk break; 520100206Sdd } 521100206Sdd } 522150501Sphk if (k1 == NULL) 523150501Sphk TAILQ_INSERT_TAIL(&ds->ds_rules, dk, dk_list); 524100206Sdd return (0); 525100206Sdd} 526100206Sdd 527100206Sdd/* 528100206Sdd * Determine whether dk matches de. Returns 1 if dk should be run on 529100206Sdd * de; 0, otherwise. 530100206Sdd */ 531100206Sddstatic int 532253677Savgdevfs_rule_match(struct devfs_krule *dk, struct devfs_mount *dm, 533253677Savg struct devfs_dirent *de) 534100206Sdd{ 535100206Sdd struct devfs_rule *dr = &dk->dk_rule; 536130585Sphk struct cdev *dev; 537177458Skib struct cdevsw *dsw; 538210923Skib int ref; 539100206Sdd 540100206Sdd dev = devfs_rule_getdev(de); 541100206Sdd /* 542100206Sdd * At this point, if dev is NULL, we should assume that any 543100206Sdd * criteria that depend on it don't match. We should *not* 544100206Sdd * just ignore them (i.e., act like they weren't specified), 545100206Sdd * since that makes a rule that only has criteria dependent on 546130585Sphk * the struct cdev *match all symlinks and directories. 547100206Sdd * 548100206Sdd * Note also that the following tests are somewhat reversed: 549100206Sdd * They're actually testing to see whether the condition does 550100206Sdd * *not* match, since the default is to assume the rule should 551100206Sdd * be run (such as if there are no conditions). 552100206Sdd */ 553177458Skib if (dr->dr_icond & DRC_DSWFLAGS) { 554177458Skib if (dev == NULL) 555150147Sphk return (0); 556210923Skib dsw = dev_refthread(dev, &ref); 557177458Skib if (dsw == NULL) 558177458Skib return (0); 559177458Skib if ((dsw->d_flags & dr->dr_dswflags) == 0) { 560210923Skib dev_relthread(dev, ref); 561177458Skib return (0); 562177458Skib } 563210923Skib dev_relthread(dev, ref); 564177458Skib } 565100206Sdd if (dr->dr_icond & DRC_PATHPTRN) 566253677Savg if (!devfs_rule_matchpath(dk, dm, de)) 567150147Sphk return (0); 568100206Sdd 569100206Sdd return (1); 570100206Sdd} 571100206Sdd 572100206Sdd/* 573100206Sdd * Determine whether dk matches de on account of dr_pathptrn. 574100206Sdd */ 575100206Sddstatic int 576253677Savgdevfs_rule_matchpath(struct devfs_krule *dk, struct devfs_mount *dm, 577253677Savg struct devfs_dirent *de) 578100206Sdd{ 579100206Sdd struct devfs_rule *dr = &dk->dk_rule; 580130585Sphk struct cdev *dev; 581253677Savg int match; 582253677Savg char *pname, *specname; 583100206Sdd 584253677Savg specname = NULL; 585100206Sdd dev = devfs_rule_getdev(de); 586100206Sdd if (dev != NULL) 587100206Sdd pname = dev->si_name; 588124798Scperciva else if (de->de_dirent->d_type == DT_LNK || 589253677Savg (de->de_dirent->d_type == DT_DIR && de != dm->dm_rootdir && 590253677Savg (de->de_flags & (DE_DOT | DE_DOTDOT)) == 0)) { 591253677Savg specname = malloc(SPECNAMELEN + 1, M_TEMP, M_WAITOK); 592253677Savg pname = devfs_fqpn(specname, dm, de, NULL); 593253677Savg } else 594100206Sdd return (0); 595253677Savg 596100206Sdd KASSERT(pname != NULL, ("devfs_rule_matchpath: NULL pname")); 597253677Savg match = fnmatch(dr->dr_pathptrn, pname, FNM_PATHNAME) == 0; 598253677Savg free(specname, M_TEMP); 599253677Savg return (match); 600100206Sdd} 601100206Sdd 602100206Sdd/* 603100206Sdd * Run dk on de. 604100206Sdd */ 605100206Sddstatic void 606253677Savgdevfs_rule_run(struct devfs_krule *dk, struct devfs_mount *dm, 607253677Savg struct devfs_dirent *de, unsigned depth) 608100206Sdd{ 609100206Sdd struct devfs_rule *dr = &dk->dk_rule; 610100206Sdd struct devfs_ruleset *ds; 611100206Sdd 612253677Savg if (!devfs_rule_match(dk, dm, de)) 613150147Sphk return; 614100206Sdd if (dr->dr_iacts & DRA_BACTS) { 615100206Sdd if (dr->dr_bacts & DRB_HIDE) 616100206Sdd de->de_flags |= DE_WHITEOUT; 617100206Sdd if (dr->dr_bacts & DRB_UNHIDE) 618100206Sdd de->de_flags &= ~DE_WHITEOUT; 619100206Sdd } 620100206Sdd if (dr->dr_iacts & DRA_UID) 621100206Sdd de->de_uid = dr->dr_uid; 622100206Sdd if (dr->dr_iacts & DRA_GID) 623100206Sdd de->de_gid = dr->dr_gid; 624100206Sdd if (dr->dr_iacts & DRA_MODE) 625100206Sdd de->de_mode = dr->dr_mode; 626100206Sdd if (dr->dr_iacts & DRA_INCSET) { 627150147Sphk /* 628150147Sphk * XXX: we should tell the user if the depth is exceeded here 629150147Sphk * XXX: but it is not obvious how to. A return value will 630150147Sphk * XXX: not work as this is called when devices are created 631150147Sphk * XXX: long time after the rules were instantiated. 632150147Sphk * XXX: a printf() would probably give too much noise, or 633227489Seadler * XXX: DoS the machine. I guess a rate-limited message 634150147Sphk * XXX: might work. 635150147Sphk */ 636150147Sphk if (depth > 0) { 637150147Sphk ds = devfs_ruleset_bynum(dk->dk_rule.dr_incset); 638150147Sphk KASSERT(ds != NULL, ("DRA_INCSET but bad dr_incset")); 639253677Savg devfs_ruleset_applyde(ds, dm, de, depth - 1); 640150147Sphk } 641100206Sdd } 642100206Sdd} 643100206Sdd 644100206Sdd/* 645100206Sdd * Apply all the rules in ds to de. 646100206Sdd */ 647100206Sddstatic void 648253677Savgdevfs_ruleset_applyde(struct devfs_ruleset *ds, struct devfs_mount *dm, 649253677Savg struct devfs_dirent *de, unsigned depth) 650100206Sdd{ 651100206Sdd struct devfs_krule *dk; 652100206Sdd 653150501Sphk TAILQ_FOREACH(dk, &ds->ds_rules, dk_list) 654253677Savg devfs_rule_run(dk, dm, de, depth); 655100206Sdd} 656100206Sdd 657100206Sdd/* 658100206Sdd * Apply all the rules in ds to all the entires in dm. 659100206Sdd */ 660100206Sddstatic void 661100206Sdddevfs_ruleset_applydm(struct devfs_ruleset *ds, struct devfs_mount *dm) 662100206Sdd{ 663100206Sdd struct devfs_krule *dk; 664100206Sdd 665100206Sdd /* 666100206Sdd * XXX: Does it matter whether we do 667100206Sdd * 668100206Sdd * foreach(dk in ds) 669100206Sdd * foreach(de in dm) 670100206Sdd * apply(dk to de) 671100206Sdd * 672100206Sdd * as opposed to 673100206Sdd * 674100206Sdd * foreach(de in dm) 675100206Sdd * foreach(dk in ds) 676100206Sdd * apply(dk to de) 677100206Sdd * 678100206Sdd * The end result is obviously the same, but does the order 679100206Sdd * matter? 680100206Sdd */ 681150501Sphk TAILQ_FOREACH(dk, &ds->ds_rules, dk_list) 682100206Sdd devfs_rule_applydm(dk, dm); 683100206Sdd} 684100206Sdd 685100206Sdd/* 686100206Sdd * Find a ruleset by number. 687100206Sdd */ 688100206Sddstatic struct devfs_ruleset * 689100206Sdddevfs_ruleset_bynum(devfs_rsnum rsnum) 690100206Sdd{ 691100206Sdd struct devfs_ruleset *ds; 692100206Sdd 693150501Sphk TAILQ_FOREACH(ds, &devfs_rulesets, ds_list) { 694100206Sdd if (ds->ds_number == rsnum) 695100206Sdd return (ds); 696100206Sdd } 697100206Sdd return (NULL); 698100206Sdd} 699100206Sdd 700100206Sdd/* 701100206Sdd * Create a new ruleset. 702100206Sdd */ 703100206Sddstatic struct devfs_ruleset * 704100206Sdddevfs_ruleset_create(devfs_rsnum rsnum) 705100206Sdd{ 706150501Sphk struct devfs_ruleset *s1; 707100206Sdd struct devfs_ruleset *ds; 708100206Sdd 709150501Sphk KASSERT(rsnum != 0, ("creating ruleset zero")); 710150501Sphk 711100206Sdd KASSERT(devfs_ruleset_bynum(rsnum) == NULL, 712100206Sdd ("creating already existent ruleset %d", rsnum)); 713100206Sdd 714150501Sphk ds = malloc(sizeof(*ds), M_DEVFSRULE, M_WAITOK | M_ZERO); 715100206Sdd ds->ds_number = rsnum; 716150501Sphk TAILQ_INIT(&ds->ds_rules); 717100206Sdd 718150501Sphk TAILQ_FOREACH(s1, &devfs_rulesets, ds_list) { 719150501Sphk if (s1->ds_number > rsnum) { 720150501Sphk TAILQ_INSERT_BEFORE(s1, ds, ds_list); 721150501Sphk break; 722100206Sdd } 723100206Sdd } 724150501Sphk if (s1 == NULL) 725150501Sphk TAILQ_INSERT_TAIL(&devfs_rulesets, ds, ds_list); 726100206Sdd return (ds); 727100206Sdd} 728100206Sdd 729100206Sdd/* 730100206Sdd * Remove a ruleset from the system if it's empty and not used 731100206Sdd * anywhere. This should be called after every time a rule is deleted 732100206Sdd * from this ruleset or the reference count is decremented. 733100206Sdd */ 734100206Sddstatic void 735150501Sphkdevfs_ruleset_reap(struct devfs_ruleset *ds) 736100206Sdd{ 737100206Sdd 738150501Sphk KASSERT(ds->ds_number != 0, ("reaping ruleset zero ")); 739150501Sphk 740150501Sphk if (!TAILQ_EMPTY(&ds->ds_rules) || ds->ds_refcount != 0) 741150501Sphk return; 742150501Sphk 743150501Sphk TAILQ_REMOVE(&devfs_rulesets, ds, ds_list); 744150501Sphk free(ds, M_DEVFSRULE); 745100206Sdd} 746100206Sdd 747100206Sdd/* 748100206Sdd * Make rsnum the active ruleset for dm. 749100206Sdd */ 750100206Sddstatic int 751100206Sdddevfs_ruleset_use(devfs_rsnum rsnum, struct devfs_mount *dm) 752100206Sdd{ 753100206Sdd struct devfs_ruleset *cds, *ds; 754100206Sdd 755150501Sphk if (dm->dm_ruleset != 0) { 756150501Sphk cds = devfs_ruleset_bynum(dm->dm_ruleset); 757150501Sphk --cds->ds_refcount; 758150501Sphk devfs_ruleset_reap(cds); 759150501Sphk } 760100206Sdd 761216391Sjh if (rsnum == 0) { 762216391Sjh dm->dm_ruleset = 0; 763216391Sjh return (0); 764216391Sjh } 765216391Sjh 766179926Sgonzo ds = devfs_ruleset_bynum(rsnum); 767179926Sgonzo if (ds == NULL) 768179926Sgonzo ds = devfs_ruleset_create(rsnum); 769100206Sdd /* These should probably be made atomic somehow. */ 770100206Sdd ++ds->ds_refcount; 771100206Sdd dm->dm_ruleset = rsnum; 772100206Sdd 773100206Sdd return (0); 774100206Sdd} 775150501Sphk 776150501Sphkvoid 777150501Sphkdevfs_rules_cleanup(struct devfs_mount *dm) 778150501Sphk{ 779150501Sphk struct devfs_ruleset *ds; 780150501Sphk 781150501Sphk sx_assert(&dm->dm_lock, SX_XLOCKED); 782150501Sphk if (dm->dm_ruleset != 0) { 783150501Sphk ds = devfs_ruleset_bynum(dm->dm_ruleset); 784150501Sphk --ds->ds_refcount; 785150501Sphk devfs_ruleset_reap(ds); 786150501Sphk } 787150501Sphk} 788231265Smm 789231265Smm/* 790231265Smm * Make rsnum the active ruleset for dm (locked) 791231265Smm */ 792231265Smmvoid 793231265Smmdevfs_ruleset_set(devfs_rsnum rsnum, struct devfs_mount *dm) 794231265Smm{ 795231265Smm 796231265Smm sx_assert(&dm->dm_lock, SX_XLOCKED); 797231265Smm 798231265Smm sx_xlock(&sx_rules); 799231265Smm devfs_ruleset_use(rsnum, dm); 800231265Smm sx_xunlock(&sx_rules); 801231265Smm} 802231265Smm 803231265Smm/* 804231265Smm * Apply the current active ruleset on a mount 805231265Smm */ 806231265Smmvoid 807231265Smmdevfs_ruleset_apply(struct devfs_mount *dm) 808231265Smm{ 809231265Smm struct devfs_ruleset *ds; 810231265Smm 811231265Smm sx_assert(&dm->dm_lock, SX_XLOCKED); 812231265Smm 813231265Smm sx_xlock(&sx_rules); 814231265Smm if (dm->dm_ruleset == 0) { 815231265Smm sx_xunlock(&sx_rules); 816231265Smm return; 817231265Smm } 818231265Smm ds = devfs_ruleset_bynum(dm->dm_ruleset); 819231265Smm if (ds != NULL) 820231265Smm devfs_ruleset_applydm(ds, dm); 821231265Smm sx_xunlock(&sx_rules); 822231265Smm} 823