xref: /freebsd/sys/fs/devfs/devfs_rule.c (revision 1e413cf93298b5b97441a21d9a50fdcd0ee9945e)
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 
531 	dev = devfs_rule_getdev(de);
532 	/*
533 	 * At this point, if dev is NULL, we should assume that any
534 	 * criteria that depend on it don't match.  We should *not*
535 	 * just ignore them (i.e., act like they weren't specified),
536 	 * since that makes a rule that only has criteria dependent on
537 	 * the struct cdev *match all symlinks and directories.
538 	 *
539 	 * Note also that the following tests are somewhat reversed:
540 	 * They're actually testing to see whether the condition does
541 	 * *not* match, since the default is to assume the rule should
542 	 * be run (such as if there are no conditions).
543 	 *
544 	 * XXX: lacks threadref on dev
545 	 */
546 	if (dr->dr_icond & DRC_DSWFLAGS)
547 		if (dev == NULL ||
548 		    (dev->si_devsw->d_flags & dr->dr_dswflags) == 0)
549 			return (0);
550 	if (dr->dr_icond & DRC_PATHPTRN)
551 		if (!devfs_rule_matchpath(dk, de))
552 			return (0);
553 
554 	return (1);
555 }
556 
557 /*
558  * Determine whether dk matches de on account of dr_pathptrn.
559  */
560 static int
561 devfs_rule_matchpath(struct devfs_krule *dk, struct devfs_dirent *de)
562 {
563 	struct devfs_rule *dr = &dk->dk_rule;
564 	char *pname;
565 	struct cdev *dev;
566 
567 	dev = devfs_rule_getdev(de);
568 	if (dev != NULL)
569 		pname = dev->si_name;
570 	else if (de->de_dirent->d_type == DT_LNK ||
571 	    de->de_dirent->d_type == DT_DIR)
572 		pname = de->de_dirent->d_name;
573 	else
574 		return (0);
575 	KASSERT(pname != NULL, ("devfs_rule_matchpath: NULL pname"));
576 
577 	return (fnmatch(dr->dr_pathptrn, pname, 0) == 0);
578 }
579 
580 /*
581  * Run dk on de.
582  */
583 static void
584 devfs_rule_run(struct devfs_krule *dk, struct devfs_dirent *de, unsigned depth)
585 {
586 	struct devfs_rule *dr = &dk->dk_rule;
587 	struct devfs_ruleset *ds;
588 
589 	if (!devfs_rule_match(dk, de))
590 		return;
591 	if (dr->dr_iacts & DRA_BACTS) {
592 		if (dr->dr_bacts & DRB_HIDE)
593 			de->de_flags |= DE_WHITEOUT;
594 		if (dr->dr_bacts & DRB_UNHIDE)
595 			de->de_flags &= ~DE_WHITEOUT;
596 	}
597 	if (dr->dr_iacts & DRA_UID)
598 		de->de_uid = dr->dr_uid;
599 	if (dr->dr_iacts & DRA_GID)
600 		de->de_gid = dr->dr_gid;
601 	if (dr->dr_iacts & DRA_MODE)
602 		de->de_mode = dr->dr_mode;
603 	if (dr->dr_iacts & DRA_INCSET) {
604 		/*
605 		 * XXX: we should tell the user if the depth is exceeded here
606 		 * XXX: but it is not obvious how to.  A return value will
607 		 * XXX: not work as this is called when devices are created
608 		 * XXX: long time after the rules were instantiated.
609 		 * XXX: a printf() would probably give too much noise, or
610 		 * XXX: DoS the machine.  I guess a a rate-limited message
611 		 * XXX: might work.
612 		 */
613 		if (depth > 0) {
614 			ds = devfs_ruleset_bynum(dk->dk_rule.dr_incset);
615 			KASSERT(ds != NULL, ("DRA_INCSET but bad dr_incset"));
616 			devfs_ruleset_applyde(ds, de, depth - 1);
617 		}
618 	}
619 }
620 
621 /*
622  * Apply all the rules in ds to de.
623  */
624 static void
625 devfs_ruleset_applyde(struct devfs_ruleset *ds, struct devfs_dirent *de, unsigned depth)
626 {
627 	struct devfs_krule *dk;
628 
629 	TAILQ_FOREACH(dk, &ds->ds_rules, dk_list)
630 		devfs_rule_run(dk, de, depth);
631 }
632 
633 /*
634  * Apply all the rules in ds to all the entires in dm.
635  */
636 static void
637 devfs_ruleset_applydm(struct devfs_ruleset *ds, struct devfs_mount *dm)
638 {
639 	struct devfs_krule *dk;
640 
641 	/*
642 	 * XXX: Does it matter whether we do
643 	 *
644 	 *	foreach(dk in ds)
645 	 *		foreach(de in dm)
646 	 *			apply(dk to de)
647 	 *
648 	 * as opposed to
649 	 *
650 	 *	foreach(de in dm)
651 	 *		foreach(dk in ds)
652 	 *			apply(dk to de)
653 	 *
654 	 * The end result is obviously the same, but does the order
655 	 * matter?
656 	 */
657 	TAILQ_FOREACH(dk, &ds->ds_rules, dk_list)
658 		devfs_rule_applydm(dk, dm);
659 }
660 
661 /*
662  * Find a ruleset by number.
663  */
664 static struct devfs_ruleset *
665 devfs_ruleset_bynum(devfs_rsnum rsnum)
666 {
667 	struct devfs_ruleset *ds;
668 
669 	TAILQ_FOREACH(ds, &devfs_rulesets, ds_list) {
670 		if (ds->ds_number == rsnum)
671 			return (ds);
672 	}
673 	return (NULL);
674 }
675 
676 /*
677  * Create a new ruleset.
678  */
679 static struct devfs_ruleset *
680 devfs_ruleset_create(devfs_rsnum rsnum)
681 {
682 	struct devfs_ruleset *s1;
683 	struct devfs_ruleset *ds;
684 
685 	KASSERT(rsnum != 0, ("creating ruleset zero"));
686 
687 	KASSERT(devfs_ruleset_bynum(rsnum) == NULL,
688 	    ("creating already existent ruleset %d", rsnum));
689 
690 	ds = malloc(sizeof(*ds), M_DEVFSRULE, M_WAITOK | M_ZERO);
691 	ds->ds_number = rsnum;
692 	TAILQ_INIT(&ds->ds_rules);
693 
694 	TAILQ_FOREACH(s1, &devfs_rulesets, ds_list) {
695 		if (s1->ds_number > rsnum) {
696 			TAILQ_INSERT_BEFORE(s1, ds, ds_list);
697 			break;
698 		}
699 	}
700 	if (s1 == NULL)
701 		TAILQ_INSERT_TAIL(&devfs_rulesets, ds, ds_list);
702 	return (ds);
703 }
704 
705 /*
706  * Remove a ruleset from the system if it's empty and not used
707  * anywhere.  This should be called after every time a rule is deleted
708  * from this ruleset or the reference count is decremented.
709  */
710 static void
711 devfs_ruleset_reap(struct devfs_ruleset *ds)
712 {
713 
714 	KASSERT(ds->ds_number != 0, ("reaping ruleset zero "));
715 
716 	if (!TAILQ_EMPTY(&ds->ds_rules) || ds->ds_refcount != 0)
717 		return;
718 
719 	TAILQ_REMOVE(&devfs_rulesets, ds, ds_list);
720 	free(ds, M_DEVFSRULE);
721 }
722 
723 /*
724  * Make rsnum the active ruleset for dm.
725  */
726 static int
727 devfs_ruleset_use(devfs_rsnum rsnum, struct devfs_mount *dm)
728 {
729 	struct devfs_ruleset *cds, *ds;
730 
731 	ds = devfs_ruleset_bynum(rsnum);
732 	if (ds == NULL)
733 		ds = devfs_ruleset_create(rsnum);
734 	if (dm->dm_ruleset != 0) {
735 		cds = devfs_ruleset_bynum(dm->dm_ruleset);
736 		--cds->ds_refcount;
737 		devfs_ruleset_reap(cds);
738 	}
739 
740 	/* These should probably be made atomic somehow. */
741 	++ds->ds_refcount;
742 	dm->dm_ruleset = rsnum;
743 
744 	return (0);
745 }
746 
747 void
748 devfs_rules_cleanup(struct devfs_mount *dm)
749 {
750 	struct devfs_ruleset *ds;
751 
752 	sx_assert(&dm->dm_lock, SX_XLOCKED);
753 	if (dm->dm_ruleset != 0) {
754 		ds = devfs_ruleset_bynum(dm->dm_ruleset);
755 		--ds->ds_refcount;
756 		devfs_ruleset_reap(ds);
757 	}
758 }
759