xref: /dragonfly/sys/vfs/devfs/devfs_rules.c (revision 92fc8b5c) 
1 /*
2  * Copyright (c) 2009 The DragonFly Project.  All rights reserved.
3  *
4  * This code is derived from software contributed to The DragonFly Project
5  * by Alex Hornung <ahornung@gmail.com>
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in
15  *    the documentation and/or other materials provided with the
16  *    distribution.
17  * 3. Neither the name of The DragonFly Project nor the names of its
18  *    contributors may be used to endorse or promote products derived
19  *    from this software without specific, prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  */
34 #include <sys/param.h>
35 #include <sys/systm.h>
36 #include <sys/kernel.h>
37 #include <sys/types.h>
38 #include <sys/param.h>
39 #include <sys/ioccom.h>
40 #include <sys/lock.h>
41 #include <sys/spinlock2.h>
42 #include <sys/fcntl.h>
43 #include <sys/device.h>
44 #include <sys/mount.h>
45 #include <sys/devfs.h>
46 #include <sys/devfs_rules.h>
47 
48 MALLOC_DECLARE(M_DEVFS);
49 
50 static d_open_t      devfs_dev_open;
51 static d_close_t     devfs_dev_close;
52 static d_ioctl_t     devfs_dev_ioctl;
53 
54 static struct devfs_rule *devfs_rule_alloc(struct devfs_rule_ioctl *);
55 static void devfs_rule_free(struct devfs_rule *);
56 static int devfs_rule_insert(struct devfs_rule_ioctl *);
57 static void devfs_rule_remove(struct devfs_rule *);
58 static int devfs_rule_clear(struct devfs_rule_ioctl *);
59 static void devfs_rule_create_link(struct devfs_node *, struct devfs_rule *);
60 static int devfs_rule_checkname(struct devfs_rule *, struct devfs_node *);
61 
62 static struct objcache	*devfs_rule_cache;
63 static struct lock 		devfs_rule_lock;
64 
65 static struct objcache_malloc_args devfs_rule_malloc_args = {
66 	sizeof(struct devfs_rule), M_DEVFS };
67 
68 static cdev_t devfs_dev;
69 static struct devfs_rule_head devfs_rule_list =
70 		TAILQ_HEAD_INITIALIZER(devfs_rule_list);
71 
72 static struct dev_ops devfs_dev_ops = {
73 	{ "devfs", 0, 0 },
74 	.d_open = devfs_dev_open,
75 	.d_close = devfs_dev_close,
76 	.d_ioctl = devfs_dev_ioctl
77 };
78 
79 
80 static struct devfs_rule *
81 devfs_rule_alloc(struct devfs_rule_ioctl *templ)
82 {
83 	struct devfs_rule *rule;
84 	size_t len;
85 
86 	rule = objcache_get(devfs_rule_cache, M_WAITOK);
87 	memset(rule, 0, sizeof(struct devfs_rule));
88 
89 	if (templ->mntpoint == NULL)
90 		goto error_out;
91 		/* NOTREACHED */
92 
93 	len = strlen(templ->mntpoint);
94 	if (len == 0)
95 		goto error_out;
96 		/* NOTREACHED */
97 
98 	rule->mntpoint = kstrdup(templ->mntpoint, M_DEVFS);
99 	rule->mntpointlen = len;
100 
101 	if (templ->rule_type & DEVFS_RULE_NAME) {
102 		if (templ->name == NULL)
103 			goto error_out;
104 			/* NOTREACHED */
105 
106 		len = strlen(templ->name);
107 		if (len == 0)
108 			goto error_out;
109 			/* NOTREACHED */
110 
111 		rule->name = kstrdup(templ->name, M_DEVFS);
112 		rule->namlen = len;
113 	}
114 
115 	if (templ->rule_cmd & DEVFS_RULE_LINK) {
116 		if (templ->linkname == NULL)
117 			goto error_out;
118 			/* NOTREACHED */
119 
120 		len = strlen(templ->linkname);
121 		if (len == 0)
122 			goto error_out;
123 			/* NOTREACHED */
124 
125 		rule->linkname = kstrdup(templ->linkname, M_DEVFS);
126 		rule->linknamlen = len;
127 	}
128 
129 	rule->rule_type = templ->rule_type;
130 	rule->rule_cmd = templ->rule_cmd;
131 	rule->dev_type = templ->dev_type;
132 	rule->mode = templ->mode;
133 	rule->uid = templ->uid;
134 	rule->gid = templ->gid;
135 
136 	return rule;
137 
138 error_out:
139 	devfs_rule_free(rule);
140 	return NULL;
141 }
142 
143 
144 static void
145 devfs_rule_free(struct devfs_rule *rule)
146 {
147 	if (rule->mntpoint != NULL) {
148 		kfree(rule->mntpoint, M_DEVFS);
149 	}
150 
151 	if (rule->name != NULL) {
152 		kfree(rule->name, M_DEVFS);
153 	}
154 
155 	if (rule->linkname != NULL) {
156 		kfree(rule->linkname, M_DEVFS);
157 	}
158 	objcache_put(devfs_rule_cache, rule);
159 }
160 
161 
162 static int
163 devfs_rule_insert(struct devfs_rule_ioctl *templ)
164 {
165 	struct devfs_rule *rule;
166 
167 	rule = devfs_rule_alloc(templ);
168 	if (rule == NULL)
169 		return EINVAL;
170 
171 	lockmgr(&devfs_rule_lock, LK_EXCLUSIVE);
172 	TAILQ_INSERT_TAIL(&devfs_rule_list, rule, link);
173 	lockmgr(&devfs_rule_lock, LK_RELEASE);
174 
175 	return 0;
176 }
177 
178 
179 static void
180 devfs_rule_remove(struct devfs_rule *rule)
181 {
182 	TAILQ_REMOVE(&devfs_rule_list, rule, link);
183 	devfs_rule_free(rule);
184 }
185 
186 
187 static int
188 devfs_rule_clear(struct devfs_rule_ioctl *templ)
189 {
190 	struct devfs_rule *rule1, *rule2;
191 	size_t mntpointlen;
192 
193 	if (templ->mntpoint == NULL)
194 		return EINVAL;
195 
196 	mntpointlen = strlen(templ->mntpoint);
197 	if (mntpointlen == 0)
198 		return EINVAL;
199 
200 	lockmgr(&devfs_rule_lock, LK_EXCLUSIVE);
201 	TAILQ_FOREACH_MUTABLE(rule1, &devfs_rule_list, link, rule2) {
202 		if ((templ->mntpoint[0] == '*') ||
203 			( (mntpointlen == rule1->mntpointlen) &&
204 			  (!memcmp(templ->mntpoint, rule1->mntpoint, mntpointlen)) )) {
205 			devfs_rule_remove(rule1);
206 		}
207 	}
208 	lockmgr(&devfs_rule_lock, LK_RELEASE);
209 
210 	return 0;
211 }
212 
213 
214 void *
215 devfs_rule_reset_node(struct devfs_node *node, void *unused)
216 {
217 	/*
218 	 * Don't blindly unhide all devices, some, like unix98 pty masters,
219 	 * haven't been hidden by a rule.
220 	 */
221 	if (node->flags & DEVFS_RULE_HIDDEN)
222 		node->flags &= ~(DEVFS_HIDDEN | DEVFS_RULE_HIDDEN);
223 
224 	if ((node->node_type == Plink) && (node->flags & DEVFS_RULE_CREATED)) {
225 		KKASSERT(node->link_target);
226 		node->flags &= ~DEVFS_RULE_CREATED;
227 		--node->link_target->nlinks;
228 		devfs_gc(node);
229 	} else if ((node->node_type == Pdev) && (node->d_dev)) {
230 		node->uid = node->d_dev->si_uid;
231 		node->gid = node->d_dev->si_gid;
232 		node->mode = node->d_dev->si_perms;
233 	}
234 
235 	return NULL;
236 }
237 
238 static void
239 devfs_rule_create_link(struct devfs_node *node, struct devfs_rule *rule)
240 {
241 	size_t len = 0;
242 	char *path = NULL;
243 	char *name, name_buf[PATH_MAX], buf[PATH_MAX];
244 
245 	if (rule->name[rule->namlen-1] == '*') {
246 		devfs_resolve_name_path(rule->name, name_buf, &path, &name);
247 		len = strlen(name);
248 		--len;
249 		ksnprintf(buf, sizeof(buf), "%s%s",
250 		    rule->linkname, node->d_dir.d_name+len);
251 		devfs_alias_create(buf, node, 1);
252 	} else {
253 		devfs_alias_create(rule->linkname, node, 1);
254 	}
255 }
256 
257 void *
258 devfs_rule_check_apply(struct devfs_node *node, void *unused)
259 {
260 	struct devfs_rule *rule;
261 	struct mount *mp = node->mp;
262 	int locked = 0;
263 
264 	/* Check if it is locked already. if not, we acquire the devfs lock */
265 	if (!(lockstatus(&devfs_rule_lock, curthread)) == LK_EXCLUSIVE) {
266 		lockmgr(&devfs_rule_lock, LK_EXCLUSIVE);
267 		locked = 1;
268 	}
269 
270 	TAILQ_FOREACH(rule, &devfs_rule_list, link) {
271 		/*
272 		 * Skip this rule if it is only intended for jailed mount points
273 		 * and the current mount point isn't jailed
274 		 */
275 		if ((rule->rule_type & DEVFS_RULE_JAIL) &&
276 			(!(DEVFS_MNTDATA(mp)->jailed)) )
277 			continue;
278 
279 		/*
280 		 * Skip this rule if it is not intended for jailed mount points
281 		 * and the current mount point is jailed.
282 		 */
283 		if (!(rule->rule_type & DEVFS_RULE_JAIL) &&
284 			(DEVFS_MNTDATA(mp)->jailed))
285 		    continue;
286 
287 		/*
288 		 * Skip this rule if the mount point specified in the rule doesn't
289 		 * match the mount point of the node
290 		 */
291 		if ((rule->mntpoint[0] != '*') &&
292 			(strcmp(rule->mntpoint, mp->mnt_stat.f_mntonname)))
293 			continue;
294 
295 		/*
296 		 * Skip this rule if this is a by-type rule and the device flags
297 		 * don't match the specified device type in the rule
298 		 */
299 		if ((rule->rule_type & DEVFS_RULE_TYPE) &&
300 			( (rule->dev_type == 0) || (!dev_is_good(node->d_dev)) ||
301 			  (!(dev_dflags(node->d_dev) & rule->dev_type))) )
302 			continue;
303 
304 		/*
305 		 * Skip this rule if this is a by-name rule and the node name
306 		 * doesn't match the wildcard string in the rule
307 		 */
308 		if ((rule->rule_type & DEVFS_RULE_NAME) &&
309 			(!devfs_rule_checkname(rule, node)) )
310 			continue;
311 
312 		if (rule->rule_cmd & DEVFS_RULE_HIDE) {
313 			/*
314 			 * If we should hide the device, we just apply the relevant
315 			 * hide flag to the node and let devfs do the rest in the
316 			 * vnops
317 			 */
318 			if ((node->d_dir.d_namlen == 5) &&
319 				(!memcmp(node->d_dir.d_name, "devfs", 5))) {
320 				/*
321 				 * Magically avoid /dev/devfs from being hidden, so that one
322 				 * can still use the rule system even after a "* hide".
323 				 */
324 				 continue;
325 			}
326 			node->flags |= (DEVFS_HIDDEN | DEVFS_RULE_HIDDEN);
327 		} else if (rule->rule_cmd & DEVFS_RULE_SHOW) {
328 			/*
329 			 * Show rule just means that the node should not be hidden, so
330 			 * what we do is clear the hide flag from the node.
331 			 */
332 			node->flags &= ~DEVFS_HIDDEN;
333 		} else if (rule->rule_cmd & DEVFS_RULE_LINK) {
334 			/*
335 			 * This is a LINK rule, so we tell devfs to create
336 			 * a link with the correct name to this node.
337 			 */
338 			devfs_rule_create_link(node, rule);
339 #if 0
340 			devfs_alias_create(rule->linkname, node, 1);
341 #endif
342 		} else if (rule->rule_cmd & DEVFS_RULE_PERM) {
343 			/*
344 			 * This is a normal ownership/permission rule. We
345 			 * just apply the permissions and ownership and
346 			 * we are done.
347 			 */
348 			node->mode = rule->mode;
349 			node->uid = rule->uid;
350 			node->gid = rule->gid;
351 		}
352 	}
353 
354 	/* If we acquired the lock, we also get rid of it */
355 	if (locked)
356 		lockmgr(&devfs_rule_lock, LK_RELEASE);
357 
358 	return NULL;
359 }
360 
361 
362 static int
363 devfs_rule_checkname(struct devfs_rule *rule, struct devfs_node *node)
364 {
365 	struct devfs_node *parent = DEVFS_MNTDATA(node->mp)->root_node;
366 	char *path = NULL;
367 	char *name, name_buf[PATH_MAX];
368 	int no_match = 0;
369 
370 	devfs_resolve_name_path(rule->name, name_buf, &path, &name);
371 	parent = devfs_resolve_or_create_path(parent, path, 0);
372 
373 	if (parent == NULL)
374 		return 0; /* no match */
375 
376 	/* Check if node is a child of the parent we found */
377 	if (node->parent != parent)
378 		return 0; /* no match */
379 
380 #if 0
381 	if (rule->rule_type & DEVFS_RULE_LINK)
382 		no_match = memcmp(name, node->d_dir.d_name, strlen(name));
383 	else
384 #endif
385 	no_match = devfs_WildCaseCmp(name, node->d_dir.d_name);
386 
387 	return !no_match;
388 }
389 
390 
391 static int
392 devfs_dev_open(struct dev_open_args *ap)
393 {
394 	/*
395 	 * Only allow read-write access.
396 	 */
397 	if (((ap->a_oflags & FWRITE) == 0) || ((ap->a_oflags & FREAD) == 0))
398 		return(EPERM);
399 
400 	/*
401 	 * We don't allow nonblocking access.
402 	 */
403 	if ((ap->a_oflags & O_NONBLOCK) != 0) {
404 		devfs_debug(DEVFS_DEBUG_SHOW, "devfs_dev: can't do nonblocking access\n");
405 		return(ENODEV);
406 	}
407 
408 	return 0;
409 }
410 
411 
412 static int
413 devfs_dev_close(struct dev_close_args *ap)
414 {
415 	return 0;
416 }
417 
418 
419 static int
420 devfs_dev_ioctl(struct dev_ioctl_args *ap)
421 {
422 	int error;
423 	struct devfs_rule_ioctl *rule;
424 
425 	error = 0;
426 	rule = (struct devfs_rule_ioctl *)ap->a_data;
427 
428 	switch(ap->a_cmd) {
429 	case DEVFS_RULE_ADD:
430 		error = devfs_rule_insert(rule);
431 		break;
432 
433 	case DEVFS_RULE_APPLY:
434 		if (rule->mntpoint == NULL)
435 			error = EINVAL;
436 		else
437 			devfs_apply_rules(rule->mntpoint);
438 		break;
439 
440 	case DEVFS_RULE_CLEAR:
441 		error = devfs_rule_clear(rule);
442 		break;
443 
444 	case DEVFS_RULE_RESET:
445 		if (rule->mntpoint == NULL)
446 			error = EINVAL;
447 		else
448 			devfs_reset_rules(rule->mntpoint);
449 		break;
450 
451 	default:
452 		error = ENOTTY; /* Inappropriate ioctl for device */
453 		break;
454 	}
455 
456 	return(error);
457 }
458 
459 
460 static void
461 devfs_dev_init(void *unused)
462 {
463 	lockinit(&devfs_rule_lock, "devfs_rule lock", 0, 0);
464 
465     devfs_rule_cache = objcache_create("devfs-rule-cache", 0, 0,
466 			NULL, NULL, NULL,
467 			objcache_malloc_alloc,
468 			objcache_malloc_free,
469 			&devfs_rule_malloc_args );
470 
471     devfs_dev = make_dev(&devfs_dev_ops,
472             0,
473             UID_ROOT,
474             GID_WHEEL,
475             0600,
476             "devfs");
477 }
478 
479 
480 static void
481 devfs_dev_uninit(void *unused)
482 {
483 	/* XXX: destroy all rules first */
484     destroy_dev(devfs_dev);
485 	objcache_destroy(devfs_rule_cache);
486 }
487 
488 
489 SYSINIT(devfsdev,SI_SUB_DRIVERS,SI_ORDER_FIRST,devfs_dev_init,NULL)
490 SYSUNINIT(devfsdev, SI_SUB_DRIVERS,SI_ORDER_FIRST,devfs_dev_uninit, NULL);
491 
492