xref: /freebsd/sys/kern/kern_conf.c (revision 69c9999d0ca45b210e75706ab4952ad5a33ce6ec) 
1 /*-
2  * Copyright (c) 1999-2002 Poul-Henning Kamp
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 #include <sys/param.h>
30 #include <sys/kernel.h>
31 #include <sys/systm.h>
32 #include <sys/lock.h>
33 #include <sys/mutex.h>
34 #include <sys/sysctl.h>
35 #include <sys/module.h>
36 #include <sys/malloc.h>
37 #include <sys/conf.h>
38 #include <sys/vnode.h>
39 #include <sys/queue.h>
40 #include <sys/ctype.h>
41 #include <machine/stdarg.h>
42 
43 static struct cdevsw 	*cdevsw[NUMCDEVSW];
44 
45 static MALLOC_DEFINE(M_DEVT, "dev_t", "dev_t storage");
46 
47 /*
48  * This is the number of hash-buckets.  Experiements with 'real-life'
49  * udev_t's show that a prime halfway between two powers of two works
50  * best.
51  */
52 #define DEVT_HASH 83
53 
54 /* The number of dev_t's we can create before malloc(9) kick in.  */
55 #define DEVT_STASH 50
56 
57 static struct cdev devt_stash[DEVT_STASH];
58 
59 static LIST_HEAD(, cdev) dev_hash[DEVT_HASH];
60 
61 static LIST_HEAD(, cdev) dev_free;
62 
63 devfs_create_t *devfs_create_hook;
64 devfs_destroy_t *devfs_destroy_hook;
65 int devfs_present;
66 
67 static int ready_for_devs;
68 
69 static int free_devt;
70 SYSCTL_INT(_debug, OID_AUTO, free_devt, CTLFLAG_RW, &free_devt, 0, "");
71 
72 /* XXX: This is a hack */
73 void disk_dev_synth(dev_t dev);
74 
75 struct cdevsw *
76 devsw(dev_t dev)
77 {
78 	if (dev->si_devsw)
79 		return (dev->si_devsw);
80 	/* XXX: Hack around our backwards disk code */
81 	disk_dev_synth(dev);
82 	if (dev->si_devsw)
83 		return (dev->si_devsw);
84 	if (devfs_present)
85 		return (NULL);
86         return(cdevsw[major(dev)]);
87 }
88 
89 /*
90  *  Add a cdevsw entry
91  */
92 
93 int
94 cdevsw_add(struct cdevsw *newentry)
95 {
96 
97 	if (newentry->d_maj < 0 || newentry->d_maj >= NUMCDEVSW) {
98 		printf("%s: ERROR: driver has bogus cdevsw->d_maj = %d\n",
99 		    newentry->d_name, newentry->d_maj);
100 		return (EINVAL);
101 	}
102 
103 	if (cdevsw[newentry->d_maj]) {
104 		printf("WARNING: \"%s\" is usurping \"%s\"'s cdevsw[]\n",
105 		    newentry->d_name, cdevsw[newentry->d_maj]->d_name);
106 	}
107 
108 	cdevsw[newentry->d_maj] = newentry;
109 
110 	return (0);
111 }
112 
113 /*
114  *  Remove a cdevsw entry
115  */
116 
117 int
118 cdevsw_remove(struct cdevsw *oldentry)
119 {
120 	if (oldentry->d_maj < 0 || oldentry->d_maj >= NUMCDEVSW) {
121 		printf("%s: ERROR: driver has bogus cdevsw->d_maj = %d\n",
122 		    oldentry->d_name, oldentry->d_maj);
123 		return EINVAL;
124 	}
125 
126 	cdevsw[oldentry->d_maj] = NULL;
127 
128 	return 0;
129 }
130 
131 /*
132  * dev_t and u_dev_t primitives
133  */
134 
135 int
136 major(dev_t x)
137 {
138 	if (x == NODEV)
139 		return NOUDEV;
140 	return((x->si_udev >> 8) & 0xff);
141 }
142 
143 int
144 minor(dev_t x)
145 {
146 	if (x == NODEV)
147 		return NOUDEV;
148 	return(x->si_udev & 0xffff00ff);
149 }
150 
151 int
152 dev2unit(dev_t x)
153 {
154 	int i;
155 
156 	if (x == NODEV)
157 		return NOUDEV;
158 	i = minor(x);
159 	return ((i & 0xff) | (i >> 8));
160 }
161 
162 int
163 unit2minor(int unit)
164 {
165 
166 	KASSERT(unit <= 0xffffff, ("Invalid unit (%d) in unit2minor", unit));
167 	return ((unit & 0xff) | ((unit << 8) & ~0xffff));
168 }
169 
170 static dev_t
171 allocdev(void)
172 {
173 	static int stashed;
174 	struct cdev *si;
175 
176 	if (LIST_FIRST(&dev_free)) {
177 		si = LIST_FIRST(&dev_free);
178 		LIST_REMOVE(si, si_hash);
179 	} else if (stashed >= DEVT_STASH) {
180 		MALLOC(si, struct cdev *, sizeof(*si), M_DEVT,
181 		    M_USE_RESERVE | M_ZERO);
182 	} else {
183 		si = devt_stash + stashed++;
184 		bzero(si, sizeof *si);
185 		si->si_flags |= SI_STASHED;
186 	}
187 	LIST_INIT(&si->si_children);
188 	TAILQ_INIT(&si->si_snapshots);
189 	return (si);
190 }
191 
192 dev_t
193 makedev(int x, int y)
194 {
195 	struct cdev *si;
196 	udev_t	udev;
197 	int hash;
198 
199 	if (x == umajor(NOUDEV) && y == uminor(NOUDEV))
200 		panic("makedev of NOUDEV");
201 	udev = (x << 8) | y;
202 	hash = udev % DEVT_HASH;
203 	LIST_FOREACH(si, &dev_hash[hash], si_hash) {
204 		if (si->si_udev == udev)
205 			return (si);
206 	}
207 	si = allocdev();
208 	si->si_udev = udev;
209 	LIST_INSERT_HEAD(&dev_hash[hash], si, si_hash);
210         return (si);
211 }
212 
213 void
214 freedev(dev_t dev)
215 {
216 
217 	if (!free_devt)
218 		return;
219 	if (SLIST_FIRST(&dev->si_hlist))
220 		return;
221 	if (dev->si_devsw || dev->si_drv1 || dev->si_drv2)
222 		return;
223 	LIST_REMOVE(dev, si_hash);
224 	if (dev->si_flags & SI_STASHED) {
225 		bzero(dev, sizeof(*dev));
226 		dev->si_flags |= SI_STASHED;
227 		LIST_INSERT_HEAD(&dev_free, dev, si_hash);
228 	} else {
229 		FREE(dev, M_DEVT);
230 	}
231 }
232 
233 udev_t
234 dev2udev(dev_t x)
235 {
236 	if (x == NODEV)
237 		return NOUDEV;
238 	return (x->si_udev);
239 }
240 
241 dev_t
242 udev2dev(udev_t x, int b)
243 {
244 
245 	if (x == NOUDEV)
246 		return (NODEV);
247 	switch (b) {
248 		case 0:
249 			return makedev(umajor(x), uminor(x));
250 		case 1:
251 			return (NODEV);
252 		default:
253 			Debugger("udev2dev(...,X)");
254 			return NODEV;
255 	}
256 }
257 
258 int
259 uminor(udev_t dev)
260 {
261 	return(dev & 0xffff00ff);
262 }
263 
264 int
265 umajor(udev_t dev)
266 {
267 	return((dev & 0xff00) >> 8);
268 }
269 
270 udev_t
271 makeudev(int x, int y)
272 {
273         return ((x << 8) | y);
274 }
275 
276 dev_t
277 make_dev(struct cdevsw *devsw, int minor, uid_t uid, gid_t gid, int perms, const char *fmt, ...)
278 {
279 	dev_t	dev;
280 	va_list ap;
281 	int i;
282 
283 	KASSERT(umajor(makeudev(devsw->d_maj, minor)) == devsw->d_maj,
284 	    ("Invalid minor (%d) in make_dev", minor));
285 
286 	if (!ready_for_devs) {
287 		printf("WARNING: Driver mistake: make_dev(%s) called before SI_SUB_DRIVERS\n",
288 		       fmt);
289 		/* XXX panic here once drivers are cleaned up */
290 	}
291 
292 	dev = makedev(devsw->d_maj, minor);
293 	if (dev->si_flags & SI_NAMED) {
294 		printf( "WARNING: Driver mistake: repeat make_dev(\"%s\")\n",
295 		    dev->si_name);
296 		panic("don't do that");
297 		return (dev);
298 	}
299 	va_start(ap, fmt);
300 	i = kvprintf(fmt, NULL, dev->si_name, 32, ap);
301 	dev->si_name[i] = '\0';
302 	va_end(ap);
303 	dev->si_devsw = devsw;
304 	dev->si_uid = uid;
305 	dev->si_gid = gid;
306 	dev->si_mode = perms;
307 	dev->si_flags |= SI_NAMED;
308 
309 	if (devfs_create_hook)
310 		devfs_create_hook(dev);
311 	return (dev);
312 }
313 
314 int
315 dev_named(dev_t pdev, const char *name)
316 {
317 	dev_t cdev;
318 
319 	if (strcmp(devtoname(pdev), name) == 0)
320 		return (1);
321 	LIST_FOREACH(cdev, &pdev->si_children, si_siblings)
322 		if (strcmp(devtoname(cdev), name) == 0)
323 			return (1);
324 	return (0);
325 }
326 
327 void
328 dev_depends(dev_t pdev, dev_t cdev)
329 {
330 
331 	cdev->si_parent = pdev;
332 	cdev->si_flags |= SI_CHILD;
333 	LIST_INSERT_HEAD(&pdev->si_children, cdev, si_siblings);
334 }
335 
336 dev_t
337 make_dev_alias(dev_t pdev, const char *fmt, ...)
338 {
339 	dev_t	dev;
340 	va_list ap;
341 	int i;
342 
343 	dev = allocdev();
344 	dev->si_flags |= SI_ALIAS;
345 	dev->si_flags |= SI_NAMED;
346 	dev_depends(pdev, dev);
347 	va_start(ap, fmt);
348 	i = kvprintf(fmt, NULL, dev->si_name, 32, ap);
349 	dev->si_name[i] = '\0';
350 	va_end(ap);
351 
352 	if (devfs_create_hook)
353 		devfs_create_hook(dev);
354 	return (dev);
355 }
356 
357 void
358 revoke_and_destroy_dev(dev_t dev)
359 {
360 	struct vnode *vp;
361 
362 	GIANT_REQUIRED;
363 
364 	vp = SLIST_FIRST(&dev->si_hlist);
365 	if (vp != NULL)
366 		VOP_REVOKE(vp, REVOKEALL);
367 	destroy_dev(dev);
368 }
369 
370 void
371 destroy_dev(dev_t dev)
372 {
373 
374 	if (!(dev->si_flags & SI_NAMED)) {
375 		printf( "WARNING: Driver mistake: destroy_dev on %d/%d\n",
376 		    major(dev), minor(dev));
377 		panic("don't do that");
378 		return;
379 	}
380 
381 	if (devfs_destroy_hook)
382 		devfs_destroy_hook(dev);
383 	if (dev->si_flags & SI_CHILD) {
384 		LIST_REMOVE(dev, si_siblings);
385 		dev->si_flags &= ~SI_CHILD;
386 	}
387 	while (!LIST_EMPTY(&dev->si_children))
388 		destroy_dev(LIST_FIRST(&dev->si_children));
389 	dev->si_drv1 = 0;
390 	dev->si_drv2 = 0;
391 	dev->si_devsw = 0;
392 	bzero(&dev->__si_u, sizeof(dev->__si_u));
393 	dev->si_flags &= ~SI_NAMED;
394 	dev->si_flags &= ~SI_ALIAS;
395 	freedev(dev);
396 }
397 
398 const char *
399 devtoname(dev_t dev)
400 {
401 	char *p;
402 	int mynor;
403 
404 	if (dev->si_name[0] == '#' || dev->si_name[0] == '\0') {
405 		p = dev->si_name;
406 		if (devsw(dev))
407 			sprintf(p, "#%s/", devsw(dev)->d_name);
408 		else
409 			sprintf(p, "#%d/", major(dev));
410 		p += strlen(p);
411 		mynor = minor(dev);
412 		if (mynor < 0 || mynor > 255)
413 			sprintf(p, "%#x", (u_int)mynor);
414 		else
415 			sprintf(p, "%d", mynor);
416 	}
417 	return (dev->si_name);
418 }
419 
420 int
421 dev_stdclone(char *name, char **namep, const char *stem, int *unit)
422 {
423 	int u, i;
424 
425 	i = strlen(stem);
426 	if (bcmp(stem, name, i) != 0)
427 		return (0);
428 	if (!isdigit(name[i]))
429 		return (0);
430 	u = 0;
431 	if (name[i] == '0' && isdigit(name[i+1]))
432 		return (0);
433 	while (isdigit(name[i])) {
434 		u *= 10;
435 		u += name[i++] - '0';
436 	}
437 	if (u > 0xffffff)
438 		return (0);
439 	*unit = u;
440 	if (namep)
441 		*namep = &name[i];
442 	if (name[i])
443 		return (2);
444 	return (1);
445 }
446 
447 /*
448  * Helper sysctl for devname(3).  We're given a {u}dev_t and return
449  * the name, if any, registered by the device driver.
450  */
451 static int
452 sysctl_devname(SYSCTL_HANDLER_ARGS)
453 {
454 	int error;
455 	udev_t ud;
456 	dev_t dev;
457 
458 	error = SYSCTL_IN(req, &ud, sizeof (ud));
459 	if (error)
460 		return (error);
461 	if (ud == NOUDEV)
462 		return(EINVAL);
463 	dev = makedev(umajor(ud), uminor(ud));
464 	if (dev->si_name[0] == '\0')
465 		error = ENOENT;
466 	else
467 		error = SYSCTL_OUT(req, dev->si_name, strlen(dev->si_name) + 1);
468 	freedev(dev);
469 	return (error);
470 }
471 
472 SYSCTL_PROC(_kern, OID_AUTO, devname, CTLTYPE_OPAQUE|CTLFLAG_RW|CTLFLAG_ANYBODY,
473 	NULL, 0, sysctl_devname, "", "devname(3) handler");
474 
475 /*
476  * Set ready_for_devs; prior to this point, device creation is not allowed.
477  */
478 static void
479 dev_set_ready(void *junk)
480 {
481 	ready_for_devs = 1;
482 }
483 
484 SYSINIT(dev_ready, SI_SUB_DEVFS, SI_ORDER_FIRST, dev_set_ready, NULL);
485