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 "opt_devfs.h"
66
67 #include <sys/param.h>
68 #include <sys/systm.h>
69 #include <sys/conf.h>
70 #include <sys/kernel.h>
71 #include <sys/malloc.h>
72 #include <sys/dirent.h>
73 #include <sys/ioccom.h>
74 #include <sys/lock.h>
75 #include <sys/sx.h>
76
77 #include <fs/devfs/devfs.h>
78 #include <fs/devfs/devfs_int.h>
79
80 /*
81 * Kernel version of devfs_rule.
82 */
83 struct devfs_krule {
84 TAILQ_ENTRY(devfs_krule) dk_list;
85 struct devfs_ruleset *dk_ruleset;
86 struct devfs_rule dk_rule;
87 };
88
89 TAILQ_HEAD(rulehead, devfs_krule);
90 static MALLOC_DEFINE(M_DEVFSRULE, "DEVFS_RULE", "DEVFS rule storage");
91
92 /*
93 * Structure to describe a ruleset.
94 */
95 struct devfs_ruleset {
96 TAILQ_ENTRY(devfs_ruleset) ds_list;
97 struct rulehead ds_rules;
98 devfs_rsnum ds_number;
99 int ds_refcount;
100 };
101
102 static devfs_rid devfs_rid_input(devfs_rid rid, struct devfs_mount *dm);
103
104 static void devfs_rule_applyde_recursive(struct devfs_krule *dk,
105 struct devfs_dirent *de);
106 static void devfs_rule_applydm(struct devfs_krule *dk, struct devfs_mount *dm);
107 static int devfs_rule_autonumber(struct devfs_ruleset *ds, devfs_rnum *rnp);
108 static struct devfs_krule *devfs_rule_byid(devfs_rid rid);
109 static int devfs_rule_delete(struct devfs_krule *dkp);
110 static struct cdev *devfs_rule_getdev(struct devfs_dirent *de);
111 static int devfs_rule_input(struct devfs_rule *dr, struct devfs_mount *dm);
112 static int devfs_rule_insert(struct devfs_rule *dr);
113 static int devfs_rule_match(struct devfs_krule *dk, struct devfs_dirent *de);
114 static int devfs_rule_matchpath(struct devfs_krule *dk,
115 struct devfs_dirent *de);
116 static void devfs_rule_run(struct devfs_krule *dk, struct devfs_dirent *de, unsigned depth);
117
118 static void devfs_ruleset_applyde(struct devfs_ruleset *ds,
119 struct devfs_dirent *de, unsigned depth);
120 static void devfs_ruleset_applydm(struct devfs_ruleset *ds,
121 struct devfs_mount *dm);
122 static struct devfs_ruleset *devfs_ruleset_bynum(devfs_rsnum rsnum);
123 static struct devfs_ruleset *devfs_ruleset_create(devfs_rsnum rsnum);
124 static void devfs_ruleset_reap(struct devfs_ruleset *dsp);
125 static int devfs_ruleset_use(devfs_rsnum rsnum, struct devfs_mount *dm);
126
127 static struct sx sx_rules;
128 SX_SYSINIT(sx_rules, &sx_rules, "DEVFS ruleset lock");
129
130 static TAILQ_HEAD(, devfs_ruleset) devfs_rulesets =
131 TAILQ_HEAD_INITIALIZER(devfs_rulesets);
132
133 /*
134 * Called to apply the proper rules for 'de' before it can be
135 * exposed to the userland. This should be called with an exclusive
136 * lock on dm in case we need to run anything.
137 */
138 void
139 devfs_rules_apply(struct devfs_mount *dm, struct devfs_dirent *de)
140 {
141 struct devfs_ruleset *ds;
142
143 if (dm->dm_ruleset == 0)
144 return;
145 sx_slock(&sx_rules);
146 ds = devfs_ruleset_bynum(dm->dm_ruleset);
147 KASSERT(ds != NULL, ("mount-point has NULL ruleset"));
148 devfs_ruleset_applyde(ds, de, devfs_rule_depth);
149 sx_sunlock(&sx_rules);
150 }
151
152 /*
153 * Rule subsystem ioctl hook.
154 */
155 int
156 devfs_rules_ioctl(struct devfs_mount *dm, u_long cmd, caddr_t data, struct thread *td)
157 {
158 struct devfs_ruleset *ds;
159 struct devfs_krule *dk;
160 struct devfs_rule *dr;
161 devfs_rsnum rsnum;
162 devfs_rnum rnum;
163 devfs_rid rid;
164 int error;
165
166 sx_assert(&dm->dm_lock, SX_XLOCKED);
167
168 /*
169 * XXX: This returns an error regardless of whether we
170 * actually support the cmd or not.
171 */
172 error = suser(td);
173 if (error != 0)
174 return (error);
175
176 sx_xlock(&sx_rules);
177
178 switch (cmd) {
179 case DEVFSIO_RADD:
180 dr = (struct devfs_rule *)data;
181 error = devfs_rule_input(dr, dm);
182 if (error != 0)
183 break;
184 dk = devfs_rule_byid(dr->dr_id);
185 if (dk != NULL) {
186 error = EEXIST;
187 break;
188 }
189 if (rid2rsn(dr->dr_id) == 0) {
190 error = EIO;
191 break;
192 }
193 error = devfs_rule_insert(dr);
194 break;
195 case DEVFSIO_RAPPLY:
196 dr = (struct devfs_rule *)data;
197 error = devfs_rule_input(dr, dm);
198 if (error != 0)
199 break;
200
201 /*
202 * This is one of many possible hackish
203 * implementations. The primary contender is an
204 * implementation where the rule we read in is
205 * temporarily inserted into some ruleset, perhaps
206 * with a hypothetical DRO_NOAUTO flag so that it
207 * doesn't get used where it isn't intended, and
208 * applied in the normal way. This can be done in the
209 * userland (DEVFSIO_ADD, DEVFSIO_APPLYID,
210 * DEVFSIO_DEL) or in the kernel; either way it breaks
211 * some corner case assumptions in other parts of the
212 * code (not that this implementation doesn't do
213 * that).
214 */
215 if (dr->dr_iacts & DRA_INCSET &&
216 devfs_ruleset_bynum(dr->dr_incset) == NULL) {
217 error = ESRCH;
218 break;
219 }
220 dk = malloc(sizeof(*dk), M_TEMP, M_WAITOK | M_ZERO);
221 memcpy(&dk->dk_rule, dr, sizeof(*dr));
222 devfs_rule_applydm(dk, dm);
223 free(dk, M_TEMP);
224 break;
225 case DEVFSIO_RAPPLYID:
226 rid = *(devfs_rid *)data;
227 rid = devfs_rid_input(rid, dm);
228 dk = devfs_rule_byid(rid);
229 if (dk == NULL) {
230 error = ENOENT;
231 break;
232 }
233 devfs_rule_applydm(dk, dm);
234 break;
235 case DEVFSIO_RDEL:
236 rid = *(devfs_rid *)data;
237 rid = devfs_rid_input(rid, dm);
238 dk = devfs_rule_byid(rid);
239 if (dk == NULL) {
240 error = ENOENT;
241 break;
242 }
243 ds = dk->dk_ruleset;
244 error = devfs_rule_delete(dk);
245 break;
246 case DEVFSIO_RGETNEXT:
247 dr = (struct devfs_rule *)data;
248 error = devfs_rule_input(dr, dm);
249 if (error != 0)
250 break;
251 /*
252 * We can't use devfs_rule_byid() here since that
253 * requires the rule specified to exist, but we want
254 * getnext(N) to work whether there is a rule N or not
255 * (specifically, getnext(0) must work, but we should
256 * never have a rule 0 since the add command
257 * interprets 0 to mean "auto-number").
258 */
259 ds = devfs_ruleset_bynum(rid2rsn(dr->dr_id));
260 if (ds == NULL) {
261 error = ENOENT;
262 break;
263 }
264 rnum = rid2rn(dr->dr_id);
265 TAILQ_FOREACH(dk, &ds->ds_rules, dk_list) {
266 if (rid2rn(dk->dk_rule.dr_id) > rnum)
267 break;
268 }
269 if (dk == NULL) {
270 error = ENOENT;
271 break;
272 }
273 memcpy(dr, &dk->dk_rule, sizeof(*dr));
274 break;
275 case DEVFSIO_SUSE:
276 rsnum = *(devfs_rsnum *)data;
277 error = devfs_ruleset_use(rsnum, dm);
278 break;
279 case DEVFSIO_SAPPLY:
280 rsnum = *(devfs_rsnum *)data;
281 rsnum = rid2rsn(devfs_rid_input(mkrid(rsnum, 0), dm));
282 ds = devfs_ruleset_bynum(rsnum);
283 if (ds == NULL) {
284 error = ESRCH;
285 break;
286 }
287 devfs_ruleset_applydm(ds, dm);
288 break;
289 case DEVFSIO_SGETNEXT:
290 rsnum = *(devfs_rsnum *)data;
291 TAILQ_FOREACH(ds, &devfs_rulesets, ds_list) {
292 if (ds->ds_number > rsnum)
293 break;
294 }
295 if (ds == NULL) {
296 error = ENOENT;
297 break;
298 }
299 *(devfs_rsnum *)data = ds->ds_number;
300 break;
301 default:
302 error = ENOIOCTL;
303 break;
304 }
305
306 sx_xunlock(&sx_rules);
307 return (error);
308 }
309
310 /*
311 * Adjust the rule identifier to use the ruleset of dm if one isn't
312 * explicitly specified.
313 *
314 * Note that after this operation, rid2rsn(rid) might still be 0, and
315 * that's okay; ruleset 0 is a valid ruleset, but when it's read in
316 * from the userland, it means "current ruleset for this mount-point".
317 */
318 static devfs_rid
319 devfs_rid_input(devfs_rid rid, struct devfs_mount *dm)
320 {
321
322 if (rid2rsn(rid) == 0)
323 return (mkrid(dm->dm_ruleset, rid2rn(rid)));
324 else
325 return (rid);
326 }
327
328 /*
329 * Apply dk to de and everything under de.
330 *
331 * XXX: This method needs a function call for every nested
332 * subdirectory in a devfs mount. If we plan to have many of these,
333 * we might eventually run out of kernel stack space.
334 * XXX: a linear search could be done through the cdev list instead.
335 */
336 static void
337 devfs_rule_applyde_recursive(struct devfs_krule *dk, struct devfs_dirent *de)
338 {
339 struct devfs_dirent *de2;
340
341 TAILQ_FOREACH(de2, &de->de_dlist, de_list)
342 devfs_rule_applyde_recursive(dk, de2);
343 devfs_rule_run(dk, de, devfs_rule_depth);
344 }
345
346 /*
347 * Apply dk to all entires in dm.
348 */
349 static void
350 devfs_rule_applydm(struct devfs_krule *dk, struct devfs_mount *dm)
351 {
352
353 devfs_rule_applyde_recursive(dk, dm->dm_rootdir);
354 }
355
356 /*
357 * Automatically select a number for a new rule in ds, and write the
358 * result into rnump.
359 */
360 static int
361 devfs_rule_autonumber(struct devfs_ruleset *ds, devfs_rnum *rnump)
362 {
363 struct devfs_krule *dk;
364
365 /* Find the last rule. */
366 dk = TAILQ_LAST(&ds->ds_rules, rulehead);
367 if (dk == NULL)
368 *rnump = 100;
369 else {
370 *rnump = rid2rn(dk->dk_rule.dr_id) + 100;
371 /* Detect overflow. */
372 if (*rnump < rid2rn(dk->dk_rule.dr_id))
373 return (ERANGE);
374 }
375 KASSERT(devfs_rule_byid(mkrid(ds->ds_number, *rnump)) == NULL,
376 ("autonumbering resulted in an already existing rule"));
377 return (0);
378 }
379
380 /*
381 * Find a krule by id.
382 */
383 static struct devfs_krule *
384 devfs_rule_byid(devfs_rid rid)
385 {
386 struct devfs_ruleset *ds;
387 struct devfs_krule *dk;
388 devfs_rnum rn;
389
390 rn = rid2rn(rid);
391 ds = devfs_ruleset_bynum(rid2rsn(rid));
392 if (ds == NULL)
393 return (NULL);
394 TAILQ_FOREACH(dk, &ds->ds_rules, dk_list) {
395 if (rid2rn(dk->dk_rule.dr_id) == rn)
396 return (dk);
397 else if (rid2rn(dk->dk_rule.dr_id) > rn)
398 break;
399 }
400 return (NULL);
401 }
402
403 /*
404 * Remove dkp from any lists it may be on and remove memory associated
405 * with it.
406 */
407 static int
408 devfs_rule_delete(struct devfs_krule *dk)
409 {
410 struct devfs_ruleset *ds;
411
412 if (dk->dk_rule.dr_iacts & DRA_INCSET) {
413 ds = devfs_ruleset_bynum(dk->dk_rule.dr_incset);
414 KASSERT(ds != NULL, ("DRA_INCSET but bad dr_incset"));
415 --ds->ds_refcount;
416 devfs_ruleset_reap(ds);
417 }
418 ds = dk->dk_ruleset;
419 TAILQ_REMOVE(&ds->ds_rules, dk, dk_list);
420 devfs_ruleset_reap(ds);
421 free(dk, M_DEVFSRULE);
422 return (0);
423 }
424
425 /*
426 * Get a struct cdev *corresponding to de so we can try to match rules based
427 * on it. If this routine returns NULL, there is no struct cdev *associated
428 * with the dirent (symlinks and directories don't have dev_ts), and
429 * the caller should assume that any critera dependent on a dev_t
430 * don't match.
431 */
432 static struct cdev *
433 devfs_rule_getdev(struct devfs_dirent *de)
434 {
435
436 if (de->de_cdp == NULL)
437 return (NULL);
438 if (de->de_cdp->cdp_flags & CDP_ACTIVE)
439 return (&de->de_cdp->cdp_c);
440 else
441 return (NULL);
442 }
443
444 /*
445 * Do what we need to do to a rule that we just loaded from the
446 * userland. In particular, we need to check the magic, and adjust
447 * the ruleset appropriate if desired.
448 */
449 static int
450 devfs_rule_input(struct devfs_rule *dr, struct devfs_mount *dm)
451 {
452
453 if (dr->dr_magic != DEVFS_MAGIC)
454 return (ERPCMISMATCH);
455 dr->dr_id = devfs_rid_input(dr->dr_id, dm);
456 return (0);
457 }
458
459 /*
460 * Import dr into the appropriate place in the kernel (i.e., make a
461 * krule). The value of dr is copied, so the pointer may be destroyed
462 * after this call completes.
463 */
464 static int
465 devfs_rule_insert(struct devfs_rule *dr)
466 {
467 struct devfs_ruleset *ds, *dsi;
468 struct devfs_krule *k1;
469 struct devfs_krule *dk;
470 devfs_rsnum rsnum;
471 devfs_rnum dkrn;
472 int error;
473
474 /*
475 * This stuff seems out of place here, but we want to do it as
476 * soon as possible so that if it fails, we don't have to roll
477 * back any changes we already made (e.g., ruleset creation).
478 */
479 if (dr->dr_iacts & DRA_INCSET) {
480 dsi = devfs_ruleset_bynum(dr->dr_incset);
481 if (dsi == NULL)
482 return (ESRCH);
483 } else
484 dsi = NULL;
485
486 rsnum = rid2rsn(dr->dr_id);
487 KASSERT(rsnum != 0, ("Inserting into ruleset zero"));
488
489 ds = devfs_ruleset_bynum(rsnum);
490 if (ds == NULL)
491 ds = devfs_ruleset_create(rsnum);
492 dkrn = rid2rn(dr->dr_id);
493 if (dkrn == 0) {
494 error = devfs_rule_autonumber(ds, &dkrn);
495 if (error != 0) {
496 devfs_ruleset_reap(ds);
497 return (error);
498 }
499 }
500
501 dk = malloc(sizeof(*dk), M_DEVFSRULE, M_WAITOK | M_ZERO);
502 dk->dk_ruleset = ds;
503 if (dsi != NULL)
504 ++dsi->ds_refcount;
505 /* XXX: Inspect dr? */
506 memcpy(&dk->dk_rule, dr, sizeof(*dr));
507 dk->dk_rule.dr_id = mkrid(rid2rsn(dk->dk_rule.dr_id), dkrn);
508
509 TAILQ_FOREACH(k1, &ds->ds_rules, dk_list) {
510 if (rid2rn(k1->dk_rule.dr_id) > dkrn) {
511 TAILQ_INSERT_BEFORE(k1, dk, dk_list);
512 break;
513 }
514 }
515 if (k1 == NULL)
516 TAILQ_INSERT_TAIL(&ds->ds_rules, dk, dk_list);
517 return (0);
518 }
519
520 /*
521 * Determine whether dk matches de. Returns 1 if dk should be run on
522 * de; 0, otherwise.
523 */
524 static int
525 devfs_rule_match(struct devfs_krule *dk, struct devfs_dirent *de)
526 {
527 struct devfs_rule *dr = &dk->dk_rule;
528 struct cdev *dev;
529 struct cdevsw *dsw;
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 if (dr->dr_icond & DRC_DSWFLAGS) {
545 if (dev == NULL)
546 return (0);
547 dsw = dev_refthread(dev);
548 if (dsw == NULL)
549 return (0);
550 if ((dsw->d_flags & dr->dr_dswflags) == 0) {
551 dev_relthread(dev);
552 return (0);
553 }
554 dev_relthread(dev);
555 }
556 if (dr->dr_icond & DRC_PATHPTRN)
557 if (!devfs_rule_matchpath(dk, de))
558 return (0);
559
560 return (1);
561 }
562
563 /*
564 * Determine whether dk matches de on account of dr_pathptrn.
565 */
566 static int
567 devfs_rule_matchpath(struct devfs_krule *dk, struct devfs_dirent *de)
568 {
569 struct devfs_rule *dr = &dk->dk_rule;
570 char *pname;
571 struct cdev *dev;
572
573 dev = devfs_rule_getdev(de);
574 if (dev != NULL)
575 pname = dev->si_name;
576 else if (de->de_dirent->d_type == DT_LNK ||
577 de->de_dirent->d_type == DT_DIR)
578 pname = de->de_dirent->d_name;
579 else
580 return (0);
581 KASSERT(pname != NULL, ("devfs_rule_matchpath: NULL pname"));
582
583 return (fnmatch(dr->dr_pathptrn, pname, 0) == 0);
584 }
585
586 /*
587 * Run dk on de.
588 */
589 static void
590 devfs_rule_run(struct devfs_krule *dk, struct devfs_dirent *de, unsigned depth)
591 {
592 struct devfs_rule *dr = &dk->dk_rule;
593 struct devfs_ruleset *ds;
594
595 if (!devfs_rule_match(dk, de))
596 return;
597 if (dr->dr_iacts & DRA_BACTS) {
598 if (dr->dr_bacts & DRB_HIDE)
599 de->de_flags |= DE_WHITEOUT;
600 if (dr->dr_bacts & DRB_UNHIDE)
601 de->de_flags &= ~DE_WHITEOUT;
602 }
603 if (dr->dr_iacts & DRA_UID)
604 de->de_uid = dr->dr_uid;
605 if (dr->dr_iacts & DRA_GID)
606 de->de_gid = dr->dr_gid;
607 if (dr->dr_iacts & DRA_MODE)
608 de->de_mode = dr->dr_mode;
609 if (dr->dr_iacts & DRA_INCSET) {
610 /*
611 * XXX: we should tell the user if the depth is exceeded here
612 * XXX: but it is not obvious how to. A return value will
613 * XXX: not work as this is called when devices are created
614 * XXX: long time after the rules were instantiated.
615 * XXX: a printf() would probably give too much noise, or
616 * XXX: DoS the machine. I guess a a rate-limited message
617 * XXX: might work.
618 */
619 if (depth > 0) {
620 ds = devfs_ruleset_bynum(dk->dk_rule.dr_incset);
621 KASSERT(ds != NULL, ("DRA_INCSET but bad dr_incset"));
622 devfs_ruleset_applyde(ds, de, depth - 1);
623 }
624 }
625 }
626
627 /*
628 * Apply all the rules in ds to de.
629 */
630 static void
631 devfs_ruleset_applyde(struct devfs_ruleset *ds, struct devfs_dirent *de, unsigned depth)
632 {
633 struct devfs_krule *dk;
634
635 TAILQ_FOREACH(dk, &ds->ds_rules, dk_list)
636 devfs_rule_run(dk, de, depth);
637 }
638
639 /*
640 * Apply all the rules in ds to all the entires in dm.
641 */
642 static void
643 devfs_ruleset_applydm(struct devfs_ruleset *ds, struct devfs_mount *dm)
644 {
645 struct devfs_krule *dk;
646
647 /*
648 * XXX: Does it matter whether we do
649 *
650 * foreach(dk in ds)
651 * foreach(de in dm)
652 * apply(dk to de)
653 *
654 * as opposed to
655 *
656 * foreach(de in dm)
657 * foreach(dk in ds)
658 * apply(dk to de)
659 *
660 * The end result is obviously the same, but does the order
661 * matter?
662 */
663 TAILQ_FOREACH(dk, &ds->ds_rules, dk_list)
664 devfs_rule_applydm(dk, dm);
665 }
666
667 /*
668 * Find a ruleset by number.
669 */
670 static struct devfs_ruleset *
671 devfs_ruleset_bynum(devfs_rsnum rsnum)
672 {
673 struct devfs_ruleset *ds;
674
675 TAILQ_FOREACH(ds, &devfs_rulesets, ds_list) {
676 if (ds->ds_number == rsnum)
677 return (ds);
678 }
679 return (NULL);
680 }
681
682 /*
683 * Create a new ruleset.
684 */
685 static struct devfs_ruleset *
686 devfs_ruleset_create(devfs_rsnum rsnum)
687 {
688 struct devfs_ruleset *s1;
689 struct devfs_ruleset *ds;
690
691 KASSERT(rsnum != 0, ("creating ruleset zero"));
692
693 KASSERT(devfs_ruleset_bynum(rsnum) == NULL,
694 ("creating already existent ruleset %d", rsnum));
695
696 ds = malloc(sizeof(*ds), M_DEVFSRULE, M_WAITOK | M_ZERO);
697 ds->ds_number = rsnum;
698 TAILQ_INIT(&ds->ds_rules);
699
700 TAILQ_FOREACH(s1, &devfs_rulesets, ds_list) {
701 if (s1->ds_number > rsnum) {
702 TAILQ_INSERT_BEFORE(s1, ds, ds_list);
703 break;
704 }
705 }
706 if (s1 == NULL)
707 TAILQ_INSERT_TAIL(&devfs_rulesets, ds, ds_list);
708 return (ds);
709 }
710
711 /*
712 * Remove a ruleset from the system if it's empty and not used
713 * anywhere. This should be called after every time a rule is deleted
714 * from this ruleset or the reference count is decremented.
715 */
716 static void
717 devfs_ruleset_reap(struct devfs_ruleset *ds)
718 {
719
720 KASSERT(ds->ds_number != 0, ("reaping ruleset zero "));
721
722 if (!TAILQ_EMPTY(&ds->ds_rules) || ds->ds_refcount != 0)
723 return;
724
725 TAILQ_REMOVE(&devfs_rulesets, ds, ds_list);
726 free(ds, M_DEVFSRULE);
727 }
728
729 /*
730 * Make rsnum the active ruleset for dm.
731 */
732 static int
733 devfs_ruleset_use(devfs_rsnum rsnum, struct devfs_mount *dm)
734 {
735 struct devfs_ruleset *cds, *ds;
736
737 ds = devfs_ruleset_bynum(rsnum);
738 if (ds == NULL)
739 ds = devfs_ruleset_create(rsnum);
740 if (dm->dm_ruleset != 0) {
741 cds = devfs_ruleset_bynum(dm->dm_ruleset);
742 --cds->ds_refcount;
743 devfs_ruleset_reap(cds);
744 }
745
746 /* These should probably be made atomic somehow. */
747 ++ds->ds_refcount;
748 dm->dm_ruleset = rsnum;
749
750 return (0);
751 }
752
753 void
754 devfs_rules_cleanup(struct devfs_mount *dm)
755 {
756 struct devfs_ruleset *ds;
757
758 sx_assert(&dm->dm_lock, SX_XLOCKED);
759 if (dm->dm_ruleset != 0) {
760 ds = devfs_ruleset_bynum(dm->dm_ruleset);
761 --ds->ds_refcount;
762 devfs_ruleset_reap(ds);
763 }
764 }
Cache object: b2b02ab4c0ca7df1a3fffa8ee5ad3b56
|