devfs_rule.c revision 164033
1249259Sdim/*-
2249259Sdim * Copyright (c) 2002 Dima Dorfman.
3249259Sdim * All rights reserved.
4249259Sdim *
5249259Sdim * Redistribution and use in source and binary forms, with or without
6249259Sdim * modification, are permitted provided that the following conditions
7249259Sdim * are met:
8249259Sdim * 1. Redistributions of source code must retain the above copyright
9249259Sdim *    notice, this list of conditions and the following disclaimer.
10249259Sdim * 2. Redistributions in binary form must reproduce the above copyright
11249259Sdim *    notice, this list of conditions and the following disclaimer in the
12249259Sdim *    documentation and/or other materials provided with the distribution.
13249259Sdim *
14249259Sdim * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15249259Sdim * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16249259Sdim * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17249259Sdim * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18249259Sdim * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19249259Sdim * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20249259Sdim * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21249259Sdim * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22249259Sdim * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23249259Sdim * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24249259Sdim * SUCH DAMAGE.
25249259Sdim *
26249259Sdim * $FreeBSD: head/sys/fs/devfs/devfs_rule.c 164033 2006-11-06 13:42:10Z rwatson $
27249259Sdim */
28249259Sdim
29249259Sdim/*
30249259Sdim * DEVFS ruleset implementation.
31249259Sdim *
32249259Sdim * A note on terminology: To "run" a rule on a dirent is to take the
33249259Sdim * prescribed action; to "apply" a rule is to check whether it matches
34249259Sdim * a dirent and run if if it does.
35249259Sdim *
36249259Sdim * A note on locking: Only foreign entry points (non-static functions)
37249259Sdim * should deal with locking.  Everything else assumes we already hold
38249259Sdim * the required kind of lock.
39249259Sdim *
40249259Sdim * A note on namespace: devfs_rules_* are the non-static functions for
41249259Sdim * the entire "ruleset" subsystem, devfs_rule_* are the static
42249259Sdim * functions that operate on rules, and devfs_ruleset_* are the static
43249259Sdim * functions that operate on rulesets.  The line between the last two
44249259Sdim * isn't always clear, but the guideline is still useful.
45249259Sdim *
46249259Sdim * A note on "special" identifiers: Ruleset 0 is the NULL, or empty,
47249259Sdim * ruleset; it cannot be deleted or changed in any way.  This may be
48249259Sdim * assumed inside the code; e.g., a ruleset of 0 may be interpeted to
49249259Sdim * mean "no ruleset".  The interpretation of rule 0 is
50249259Sdim * command-dependent, but in no case is there a real rule with number
51249259Sdim * 0.
52249259Sdim *
53249259Sdim * A note on errno codes: To make it easier for the userland to tell
54249259Sdim * what went wrong, we sometimes use errno codes that are not entirely
55249259Sdim * appropriate for the error but that would be less ambiguous than the
56249259Sdim * appropriate "generic" code.  For example, when we can't find a
57249259Sdim * ruleset, we return ESRCH instead of ENOENT (except in
58249259Sdim * DEVFSIO_{R,S}GETNEXT, where a nonexistent ruleset means "end of
59249259Sdim * list", and the userland expects ENOENT to be this indicator); this
60249259Sdim * way, when an operation fails, it's clear that what couldn't be
61249259Sdim * found is a ruleset and not a rule (well, it's clear to those who
62249259Sdim * know the convention).
63249259Sdim */
64249259Sdim
65249259Sdim#include <sys/param.h>
66249259Sdim#include <sys/systm.h>
67249259Sdim#include <sys/conf.h>
68249259Sdim#include <sys/kernel.h>
69249259Sdim#include <sys/malloc.h>
70249259Sdim#include <sys/priv.h>
71249259Sdim#include <sys/dirent.h>
72249259Sdim#include <sys/ioccom.h>
73249259Sdim#include <sys/lock.h>
74249259Sdim#include <sys/sx.h>
75249259Sdim
76249259Sdim#include <fs/devfs/devfs.h>
77249259Sdim#include <fs/devfs/devfs_int.h>
78249259Sdim
79249259Sdim/*
80249259Sdim * Kernel version of devfs_rule.
81249259Sdim */
82249259Sdimstruct devfs_krule {
83249259Sdim	TAILQ_ENTRY(devfs_krule)	dk_list;
84249259Sdim	struct devfs_ruleset		*dk_ruleset;
85249259Sdim	struct devfs_rule		dk_rule;
86249259Sdim};
87249259Sdim
88249259SdimTAILQ_HEAD(rulehead, devfs_krule);
89249259Sdimstatic MALLOC_DEFINE(M_DEVFSRULE, "DEVFS_RULE", "DEVFS rule storage");
90249259Sdim
91249259Sdim/*
92249259Sdim * Structure to describe a ruleset.
93249259Sdim */
94249259Sdimstruct devfs_ruleset {
95249259Sdim	TAILQ_ENTRY(devfs_ruleset)	ds_list;
96249259Sdim	struct rulehead			ds_rules;
97249259Sdim	devfs_rsnum			ds_number;
98249259Sdim	int				ds_refcount;
99249259Sdim};
100249259Sdim
101249259Sdimstatic devfs_rid devfs_rid_input(devfs_rid rid, struct devfs_mount *dm);
102249259Sdim
103249259Sdimstatic void devfs_rule_applyde_recursive(struct devfs_krule *dk,
104249259Sdim		struct devfs_dirent *de);
105249259Sdimstatic void devfs_rule_applydm(struct devfs_krule *dk, struct devfs_mount *dm);
106249259Sdimstatic int  devfs_rule_autonumber(struct devfs_ruleset *ds, devfs_rnum *rnp);
107249259Sdimstatic struct devfs_krule *devfs_rule_byid(devfs_rid rid);
108249259Sdimstatic int  devfs_rule_delete(struct devfs_krule *dkp);
109249259Sdimstatic struct cdev *devfs_rule_getdev(struct devfs_dirent *de);
110249259Sdimstatic int  devfs_rule_input(struct devfs_rule *dr, struct devfs_mount *dm);
111249259Sdimstatic int  devfs_rule_insert(struct devfs_rule *dr);
112249259Sdimstatic int  devfs_rule_match(struct devfs_krule *dk, struct devfs_dirent *de);
113249259Sdimstatic int  devfs_rule_matchpath(struct devfs_krule *dk,
114249259Sdim		struct devfs_dirent *de);
115249259Sdimstatic void devfs_rule_run(struct devfs_krule *dk, struct devfs_dirent *de, unsigned depth);
116249259Sdim
117249259Sdimstatic void devfs_ruleset_applyde(struct devfs_ruleset *ds,
118249259Sdim		struct devfs_dirent *de, unsigned depth);
119static void devfs_ruleset_applydm(struct devfs_ruleset *ds,
120		struct devfs_mount *dm);
121static struct devfs_ruleset *devfs_ruleset_bynum(devfs_rsnum rsnum);
122static struct devfs_ruleset *devfs_ruleset_create(devfs_rsnum rsnum);
123static void devfs_ruleset_reap(struct devfs_ruleset *dsp);
124static int  devfs_ruleset_use(devfs_rsnum rsnum, struct devfs_mount *dm);
125
126static struct sx sx_rules;
127SX_SYSINIT(sx_rules, &sx_rules, "DEVFS ruleset lock");
128
129static 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 */
137void
138devfs_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 */
154int
155devfs_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 */
319static devfs_rid
320devfs_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 */
337static void
338devfs_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 */
350static void
351devfs_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 */
361static int
362devfs_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 */
384static struct devfs_krule *
385devfs_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 */
408static int
409devfs_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 */
433static struct cdev *
434devfs_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 */
450static int
451devfs_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 */
465static int
466devfs_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 */
525static int
526devfs_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 */
560static int
561devfs_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 */
583static void
584devfs_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 */
624static void
625devfs_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 */
636static void
637devfs_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 */
664static struct devfs_ruleset *
665devfs_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 */
679static struct devfs_ruleset *
680devfs_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 */
710static void
711devfs_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 */
726static int
727devfs_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
747void
748devfs_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