kern_conf.c revision 136947 
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
27#include <sys/cdefs.h>
28__FBSDID("$FreeBSD: head/sys/kern/kern_conf.c 136947 2004-10-25 13:12:06Z phk $");
29
30#include <sys/param.h>
31#include <sys/kernel.h>
32#include <sys/systm.h>
33#include <sys/bio.h>
34#include <sys/lock.h>
35#include <sys/mutex.h>
36#include <sys/sysctl.h>
37#include <sys/module.h>
38#include <sys/malloc.h>
39#include <sys/conf.h>
40#include <sys/vnode.h>
41#include <sys/queue.h>
42#include <sys/poll.h>
43#include <sys/ctype.h>
44#include <sys/tty.h>
45#include <machine/stdarg.h>
46
47static MALLOC_DEFINE(M_DEVT, "cdev", "cdev storage");
48
49/* Built at compile time from sys/conf/majors */
50extern unsigned char reserved_majors[256];
51
52/*
53 * This is the number of hash-buckets.  Experiments with 'real-life'
54 * dev_t's show that a prime halfway between two powers of two works
55 * best.
56 */
57#define DEVT_HASH 83
58
59static LIST_HEAD(, cdev) dev_hash[DEVT_HASH];
60
61static struct mtx devmtx;
62static void freedev(struct cdev *dev);
63static struct cdev *newdev(int x, int y);
64
65void
66dev_lock(void)
67{
68	if (!mtx_initialized(&devmtx))
69		mtx_init(&devmtx, "cdev", NULL, MTX_DEF);
70	mtx_lock(&devmtx);
71}
72
73void
74dev_unlock(void)
75{
76
77	mtx_unlock(&devmtx);
78}
79
80void
81dev_ref(struct cdev *dev)
82{
83
84	dev_lock();
85	dev->si_refcount++;
86	dev_unlock();
87}
88
89void
90dev_rel(struct vnode *vp)
91{
92	struct cdev *dev;
93	int flag;
94
95	dev = vp->v_rdev;
96	mtx_assert(&devmtx, MA_NOTOWNED);
97	dev_lock();
98	SLIST_REMOVE(&dev->si_hlist, vp, vnode, v_specnext);
99	dev->si_usecount -= vp->v_usecount;
100	vp->v_rdev = NULL;
101	dev->si_refcount--;
102	KASSERT(dev->si_refcount >= 0,
103	    ("dev_rel(%s) gave negative count", devtoname(dev)));
104	flag = 0;
105	if (dev->si_devsw == NULL && dev->si_refcount == 0) {
106		LIST_REMOVE(dev, si_list);
107		flag = 1;
108	}
109	dev_unlock();
110	if (flag)
111		freedev(dev);
112	return;
113}
114
115struct cdevsw *
116dev_refthread(struct cdev *dev)
117{
118	struct cdevsw *csw;
119
120	mtx_assert(&devmtx, MA_NOTOWNED);
121	dev_lock();
122	csw = dev->si_devsw;
123	if (csw != NULL)
124		dev->si_threadcount++;
125	dev_unlock();
126	return (csw);
127}
128
129void
130dev_relthread(struct cdev *dev)
131{
132
133	mtx_assert(&devmtx, MA_NOTOWNED);
134	dev_lock();
135	dev->si_threadcount--;
136	dev_unlock();
137}
138
139int
140nullop(void)
141{
142
143	return (0);
144}
145
146int
147eopnotsupp(void)
148{
149
150	return (EOPNOTSUPP);
151}
152
153static int
154enxio(void)
155{
156	return (ENXIO);
157}
158
159static int
160enodev(void)
161{
162	return (ENODEV);
163}
164
165/* Define a dead_cdevsw for use when devices leave unexpectedly. */
166
167#define dead_open	(d_open_t *)enxio
168#define dead_close	(d_close_t *)enxio
169#define dead_read	(d_read_t *)enxio
170#define dead_write	(d_write_t *)enxio
171#define dead_ioctl	(d_ioctl_t *)enxio
172#define dead_poll	(d_poll_t *)enodev
173#define dead_mmap	(d_mmap_t *)enodev
174
175static void
176dead_strategy(struct bio *bp)
177{
178
179	biofinish(bp, NULL, ENXIO);
180}
181
182#define dead_dump	(dumper_t *)enxio
183#define dead_kqfilter	(d_kqfilter_t *)enxio
184
185static struct cdevsw dead_cdevsw = {
186	.d_version =	D_VERSION,
187	.d_flags =	D_NEEDGIANT, /* XXX: does dead_strategy need this ? */
188	.d_open =	dead_open,
189	.d_close =	dead_close,
190	.d_read =	dead_read,
191	.d_write =	dead_write,
192	.d_ioctl =	dead_ioctl,
193	.d_poll =	dead_poll,
194	.d_mmap =	dead_mmap,
195	.d_strategy =	dead_strategy,
196	.d_name =	"dead",
197	.d_maj =	255,
198	.d_dump =	dead_dump,
199	.d_kqfilter =	dead_kqfilter
200};
201
202/* Default methods if driver does not specify method */
203
204#define null_open	(d_open_t *)nullop
205#define null_close	(d_close_t *)nullop
206#define no_read		(d_read_t *)enodev
207#define no_write	(d_write_t *)enodev
208#define no_ioctl	(d_ioctl_t *)enodev
209#define no_mmap		(d_mmap_t *)enodev
210#define no_kqfilter	(d_kqfilter_t *)enodev
211
212static void
213no_strategy(struct bio *bp)
214{
215
216	biofinish(bp, NULL, ENODEV);
217}
218
219static int
220no_poll(struct cdev *dev __unused, int events, struct thread *td __unused)
221{
222	/*
223	 * Return true for read/write.  If the user asked for something
224	 * special, return POLLNVAL, so that clients have a way of
225	 * determining reliably whether or not the extended
226	 * functionality is present without hard-coding knowledge
227	 * of specific filesystem implementations.
228	 * Stay in sync with vop_nopoll().
229	 */
230	if (events & ~POLLSTANDARD)
231		return (POLLNVAL);
232
233	return (events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM));
234}
235
236#define no_dump		(dumper_t *)enodev
237
238/*
239 * struct cdev * and u_dev_t primitives
240 */
241
242int
243major(struct cdev *x)
244{
245	if (x == NULL)
246		return NODEV;
247	return((x->si_udev >> 8) & 0xff);
248}
249
250int
251minor(struct cdev *x)
252{
253	if (x == NULL)
254		return NODEV;
255	return(x->si_udev & 0xffff00ff);
256}
257
258int
259dev2unit(struct cdev *x)
260{
261	int i;
262
263	if (x == NULL)
264		return NODEV;
265	i = minor(x);
266	return ((i & 0xff) | (i >> 8));
267}
268
269int
270unit2minor(int unit)
271{
272
273	KASSERT(unit <= 0xffffff, ("Invalid unit (%d) in unit2minor", unit));
274	return ((unit & 0xff) | ((unit << 8) & ~0xffff));
275}
276
277static struct cdev *
278allocdev(void)
279{
280	struct cdev *si;
281
282	si = malloc(sizeof *si, M_DEVT, M_USE_RESERVE | M_ZERO | M_WAITOK);
283	si->si_name = si->__si_namebuf;
284	LIST_INIT(&si->si_children);
285	return (si);
286}
287
288static struct cdev *
289newdev(int x, int y)
290{
291	struct cdev *si;
292	dev_t	udev;
293	int hash;
294
295	if (x == umajor(NODEV) && y == uminor(NODEV))
296		panic("newdev of NODEV");
297	udev = (x << 8) | y;
298	hash = udev % DEVT_HASH;
299	LIST_FOREACH(si, &dev_hash[hash], si_hash) {
300		if (si->si_udev == udev)
301			return (si);
302	}
303	si = allocdev();
304	si->si_udev = udev;
305	LIST_INSERT_HEAD(&dev_hash[hash], si, si_hash);
306	return (si);
307}
308
309static void
310freedev(struct cdev *dev)
311{
312
313	free(dev, M_DEVT);
314}
315
316dev_t
317dev2udev(struct cdev *x)
318{
319	if (x == NULL)
320		return (NODEV);
321	return (x->si_udev);
322}
323
324struct cdev *
325findcdev(dev_t udev)
326{
327	struct cdev *si;
328	int hash;
329
330	if (udev == NODEV)
331		return (NULL);
332	hash = udev % DEVT_HASH;
333	LIST_FOREACH(si, &dev_hash[hash], si_hash) {
334		if (si->si_udev == udev)
335			return (si);
336	}
337	return (NULL);
338}
339
340int
341uminor(dev_t dev)
342{
343	return (dev & 0xffff00ff);
344}
345
346int
347umajor(dev_t dev)
348{
349	return ((dev & 0xff00) >> 8);
350}
351
352static void
353find_major(struct cdevsw *devsw)
354{
355	int i;
356
357	for (i = NUMCDEVSW - 1; i > 0; i--)
358		if (reserved_majors[i] != i)
359			break;
360	KASSERT(i > 0, ("Out of major numbers (%s)", devsw->d_name));
361	devsw->d_maj = i;
362	reserved_majors[i] = i;
363	devsw->d_flags |= D_ALLOCMAJ;
364}
365
366static void
367fini_cdevsw(struct cdevsw *devsw)
368{
369	if (devsw->d_flags & D_ALLOCMAJ) {
370		reserved_majors[devsw->d_maj] = 0;
371		devsw->d_maj = MAJOR_AUTO;
372		devsw->d_flags &= ~D_ALLOCMAJ;
373	} else if (devsw->d_maj == 0)
374		devsw->d_maj = 256;
375	devsw->d_flags &= ~D_INIT;
376}
377
378static void
379prep_cdevsw(struct cdevsw *devsw)
380{
381
382	dev_lock();
383
384	if (devsw->d_version != D_VERSION_00) {
385		printf(
386		    "WARNING: Device driver \"%s\" has wrong version %s\n",
387		    devsw->d_name, "and is disabled.  Recompile KLD module.");
388		devsw->d_open = dead_open;
389		devsw->d_close = dead_close;
390		devsw->d_read = dead_read;
391		devsw->d_write = dead_write;
392		devsw->d_ioctl = dead_ioctl;
393		devsw->d_poll = dead_poll;
394		devsw->d_mmap = dead_mmap;
395		devsw->d_strategy = dead_strategy;
396		devsw->d_dump = dead_dump;
397		devsw->d_kqfilter = dead_kqfilter;
398	}
399
400	if (devsw->d_flags & D_TTY) {
401		if (devsw->d_ioctl == NULL)	devsw->d_ioctl = ttyioctl;
402		if (devsw->d_read == NULL)	devsw->d_read = ttyread;
403		if (devsw->d_write == NULL)	devsw->d_write = ttywrite;
404		if (devsw->d_kqfilter == NULL)	devsw->d_kqfilter = ttykqfilter;
405		if (devsw->d_poll == NULL)	devsw->d_poll = ttypoll;
406	}
407
408	if (devsw->d_open == NULL)	devsw->d_open = null_open;
409	if (devsw->d_close == NULL)	devsw->d_close = null_close;
410	if (devsw->d_read == NULL)	devsw->d_read = no_read;
411	if (devsw->d_write == NULL)	devsw->d_write = no_write;
412	if (devsw->d_ioctl == NULL)	devsw->d_ioctl = no_ioctl;
413	if (devsw->d_poll == NULL)	devsw->d_poll = no_poll;
414	if (devsw->d_mmap == NULL)	devsw->d_mmap = no_mmap;
415	if (devsw->d_strategy == NULL)	devsw->d_strategy = no_strategy;
416	if (devsw->d_dump == NULL)	devsw->d_dump = no_dump;
417	if (devsw->d_kqfilter == NULL)	devsw->d_kqfilter = no_kqfilter;
418
419	LIST_INIT(&devsw->d_devs);
420
421	devsw->d_flags |= D_INIT;
422
423	if (devsw->d_maj == MAJOR_AUTO) {
424		find_major(devsw);
425	} else {
426		if (devsw->d_maj == 256)	/* XXX: tty_cons.c is magic */
427			devsw->d_maj = 0;
428		KASSERT(devsw->d_maj >= 0 && devsw->d_maj < 256,
429		    ("Invalid major (%d) in make_dev", devsw->d_maj));
430		if (reserved_majors[devsw->d_maj] != devsw->d_maj) {
431			printf("WARNING: driver \"%s\" used %s %d\n",
432			    devsw->d_name, "unreserved major device number",
433			    devsw->d_maj);
434			reserved_majors[devsw->d_maj] = devsw->d_maj;
435		}
436	}
437	dev_unlock();
438}
439
440struct cdev *
441make_dev(struct cdevsw *devsw, int minornr, uid_t uid, gid_t gid, int perms, const char *fmt, ...)
442{
443	struct cdev *dev;
444	va_list ap;
445	int i;
446
447	KASSERT((minornr & ~0xffff00ff) == 0,
448	    ("Invalid minor (0x%x) in make_dev", minornr));
449
450	if (!(devsw->d_flags & D_INIT))
451		prep_cdevsw(devsw);
452	dev = newdev(devsw->d_maj, minornr);
453	if (dev->si_flags & SI_CHEAPCLONE &&
454	    dev->si_flags & SI_NAMED &&
455	    dev->si_devsw == devsw) {
456		/*
457		 * This is allowed as it removes races and generally
458		 * simplifies cloning devices.
459		 * XXX: still ??
460		 */
461		return (dev);
462	}
463	dev_lock();
464	KASSERT(!(dev->si_flags & SI_NAMED),
465	    ("make_dev() by driver %s on pre-existing device (maj=%d, min=%d, name=%s)",
466	    devsw->d_name, major(dev), minor(dev), devtoname(dev)));
467
468	va_start(ap, fmt);
469	i = vsnrprintf(dev->__si_namebuf, sizeof dev->__si_namebuf, 32, fmt, ap);
470	if (i > (sizeof dev->__si_namebuf - 1)) {
471		printf("WARNING: Device name truncated! (%s)\n",
472		    dev->__si_namebuf);
473	}
474	va_end(ap);
475
476	dev->si_devsw = devsw;
477	dev->si_uid = uid;
478	dev->si_gid = gid;
479	dev->si_mode = perms;
480	dev->si_flags |= SI_NAMED;
481
482	LIST_INSERT_HEAD(&devsw->d_devs, dev, si_list);
483	devfs_create(dev);
484	dev_unlock();
485	return (dev);
486}
487
488int
489dev_named(struct cdev *pdev, const char *name)
490{
491	struct cdev *cdev;
492
493	if (strcmp(devtoname(pdev), name) == 0)
494		return (1);
495	LIST_FOREACH(cdev, &pdev->si_children, si_siblings)
496		if (strcmp(devtoname(cdev), name) == 0)
497			return (1);
498	return (0);
499}
500
501void
502dev_depends(struct cdev *pdev, struct cdev *cdev)
503{
504
505	dev_lock();
506	cdev->si_parent = pdev;
507	cdev->si_flags |= SI_CHILD;
508	LIST_INSERT_HEAD(&pdev->si_children, cdev, si_siblings);
509	dev_unlock();
510}
511
512struct cdev *
513make_dev_alias(struct cdev *pdev, const char *fmt, ...)
514{
515	struct cdev *dev;
516	va_list ap;
517	int i;
518
519	dev = allocdev();
520	dev_lock();
521	dev->si_flags |= SI_ALIAS;
522	dev->si_flags |= SI_NAMED;
523	va_start(ap, fmt);
524	i = vsnrprintf(dev->__si_namebuf, sizeof dev->__si_namebuf, 32, fmt, ap);
525	if (i > (sizeof dev->__si_namebuf - 1)) {
526		printf("WARNING: Device name truncated! (%s)\n",
527		    dev->__si_namebuf);
528	}
529	va_end(ap);
530
531	devfs_create(dev);
532	dev_unlock();
533	dev_depends(pdev, dev);
534	return (dev);
535}
536
537static void
538idestroy_dev(struct cdev *dev)
539{
540	struct cdevsw *csw;
541
542	KASSERT(dev->si_flags & SI_NAMED,
543	    ("WARNING: Driver mistake: destroy_dev on %d/%d\n",
544	    major(dev), minor(dev)));
545
546	devfs_destroy(dev);
547
548	/* Remove name marking */
549	dev->si_flags &= ~SI_NAMED;
550
551	/* If we are a child, remove us from the parents list */
552	if (dev->si_flags & SI_CHILD) {
553		LIST_REMOVE(dev, si_siblings);
554		dev->si_flags &= ~SI_CHILD;
555	}
556
557	/* Kill our children */
558	while (!LIST_EMPTY(&dev->si_children))
559		idestroy_dev(LIST_FIRST(&dev->si_children));
560
561	/* Remove from clone list */
562	if (dev->si_flags & SI_CLONELIST) {
563		LIST_REMOVE(dev, si_clone);
564		dev->si_flags &= ~SI_CLONELIST;
565	}
566
567	csw = dev->si_devsw;
568	dev->si_devsw = NULL;	/* already NULL for SI_ALIAS */
569	while (csw != NULL && csw->d_purge != NULL && dev->si_threadcount) {
570		printf("Purging %lu threads from %s\n",
571		    dev->si_threadcount, devtoname(dev));
572		csw->d_purge(dev);
573		msleep(csw, &devmtx, PRIBIO, "devprg", hz/10);
574	}
575	if (csw != NULL && csw->d_purge != NULL)
576		printf("All threads purged from %s\n", devtoname(dev));
577
578	dev->si_drv1 = 0;
579	dev->si_drv2 = 0;
580	bzero(&dev->__si_u, sizeof(dev->__si_u));
581
582	if (!(dev->si_flags & SI_ALIAS)) {
583		/* Remove from cdevsw list */
584		LIST_REMOVE(dev, si_list);
585
586		/* If cdevsw has no struct cdev *'s, clean it */
587		if (LIST_EMPTY(&csw->d_devs))
588			fini_cdevsw(csw);
589
590		LIST_REMOVE(dev, si_hash);
591	}
592	dev->si_flags &= ~SI_ALIAS;
593
594	if (dev->si_refcount > 0) {
595		LIST_INSERT_HEAD(&dead_cdevsw.d_devs, dev, si_list);
596	} else {
597		freedev(dev);
598	}
599}
600
601void
602destroy_dev(struct cdev *dev)
603{
604
605	dev_lock();
606	idestroy_dev(dev);
607	dev_unlock();
608}
609
610const char *
611devtoname(struct cdev *dev)
612{
613	char *p;
614	struct cdevsw *csw;
615	int mynor;
616
617	if (dev->si_name[0] == '#' || dev->si_name[0] == '\0') {
618		p = dev->si_name;
619		sprintf(p, "#%d", major(dev));
620		p += strlen(p);
621		csw = dev_refthread(dev);
622		if (csw != NULL) {
623			sprintf(p, "(%s)", csw->d_name);
624			dev_relthread(dev);
625		}
626		p += strlen(p);
627		mynor = minor(dev);
628		if (mynor < 0 || mynor > 255)
629			sprintf(p, "/%#x", (u_int)mynor);
630		else
631			sprintf(p, "/%d", mynor);
632	}
633	return (dev->si_name);
634}
635
636int
637dev_stdclone(char *name, char **namep, const char *stem, int *unit)
638{
639	int u, i;
640
641	i = strlen(stem);
642	if (bcmp(stem, name, i) != 0)
643		return (0);
644	if (!isdigit(name[i]))
645		return (0);
646	u = 0;
647	if (name[i] == '0' && isdigit(name[i+1]))
648		return (0);
649	while (isdigit(name[i])) {
650		u *= 10;
651		u += name[i++] - '0';
652	}
653	if (u > 0xffffff)
654		return (0);
655	*unit = u;
656	if (namep)
657		*namep = &name[i];
658	if (name[i])
659		return (2);
660	return (1);
661}
662
663/*
664 * Helper functions for cloning device drivers.
665 *
666 * The objective here is to make it unnecessary for the device drivers to
667 * use rman or similar to manage their unit number space.  Due to the way
668 * we do "on-demand" devices, using rman or other "private" methods
669 * will be very tricky to lock down properly once we lock down this file.
670 *
671 * Instead we give the drivers these routines which puts the struct cdev *'s
672 * that are to be managed on their own list, and gives the driver the ability
673 * to ask for the first free unit number or a given specified unit number.
674 *
675 * In addition these routines support paired devices (pty, nmdm and similar)
676 * by respecting a number of "flag" bits in the minor number.
677 *
678 */
679
680struct clonedevs {
681	LIST_HEAD(,cdev)	head;
682};
683
684void
685clone_setup(struct clonedevs **cdp)
686{
687
688	*cdp = malloc(sizeof **cdp, M_DEVBUF, M_WAITOK | M_ZERO);
689	LIST_INIT(&(*cdp)->head);
690}
691
692int
693clone_create(struct clonedevs **cdp, struct cdevsw *csw, int *up, struct cdev **dp, u_int extra)
694{
695	struct clonedevs *cd;
696	struct cdev *dev, *dl, *de;
697	int unit, low, u;
698
699	KASSERT(*cdp != NULL,
700	    ("clone_setup() not called in driver \"%s\"", csw->d_name));
701	KASSERT(!(extra & CLONE_UNITMASK),
702	    ("Illegal extra bits (0x%x) in clone_create", extra));
703	KASSERT(*up <= CLONE_UNITMASK,
704	    ("Too high unit (0x%x) in clone_create", *up));
705
706	if (csw->d_maj == MAJOR_AUTO)
707		find_major(csw);
708
709	/*
710	 * Search the list for a lot of things in one go:
711	 *   A preexisting match is returned immediately.
712	 *   The lowest free unit number if we are passed -1, and the place
713	 *	 in the list where we should insert that new element.
714	 *   The place to insert a specified unit number, if applicable
715	 *       the end of the list.
716	 */
717	unit = *up;
718	low = extra;
719	de = dl = NULL;
720	cd = *cdp;
721	LIST_FOREACH(dev, &cd->head, si_clone) {
722		u = dev2unit(dev);
723		if (u == (unit | extra)) {
724			*dp = dev;
725			return (0);
726		}
727		if (unit == -1 && u == low) {
728			low++;
729			de = dev;
730			continue;
731		}
732		if (u > (unit | extra)) {
733			dl = dev;
734			break;
735		}
736		de = dev;
737	}
738	if (unit == -1)
739		unit = low & CLONE_UNITMASK;
740	dev = newdev(csw->d_maj, unit2minor(unit | extra));
741	KASSERT(!(dev->si_flags & SI_CLONELIST),
742	    ("Dev %p should not be on clonelist", dev));
743	if (dl != NULL)
744		LIST_INSERT_BEFORE(dl, dev, si_clone);
745	else if (de != NULL)
746		LIST_INSERT_AFTER(de, dev, si_clone);
747	else
748		LIST_INSERT_HEAD(&cd->head, dev, si_clone);
749	dev->si_flags |= SI_CLONELIST;
750	*up = unit;
751	return (1);
752}
753
754/*
755 * Kill everything still on the list.  The driver should already have
756 * disposed of any softc hung of the struct cdev *'s at this time.
757 */
758void
759clone_cleanup(struct clonedevs **cdp)
760{
761	struct cdev *dev, *tdev;
762	struct clonedevs *cd;
763
764	cd = *cdp;
765	if (cd == NULL)
766		return;
767	LIST_FOREACH_SAFE(dev, &cd->head, si_clone, tdev) {
768		KASSERT(dev->si_flags & SI_NAMED,
769		    ("Driver has goofed in cloning underways udev %x", dev->si_udev));
770		destroy_dev(dev);
771	}
772	free(cd, M_DEVBUF);
773	*cdp = NULL;
774}
775
776/*
777 * Helper sysctl for devname(3).  We're given a struct cdev * and return
778 * the name, if any, registered by the device driver.
779 */
780static int
781sysctl_devname(SYSCTL_HANDLER_ARGS)
782{
783	int error;
784	dev_t ud;
785	struct cdev *dev;
786
787	error = SYSCTL_IN(req, &ud, sizeof (ud));
788	if (error)
789		return (error);
790	if (ud == NODEV)
791		return(EINVAL);
792	dev = findcdev(ud);
793	if (dev == NULL)
794		error = ENOENT;
795	else
796		error = SYSCTL_OUT(req, dev->si_name, strlen(dev->si_name) + 1);
797	return (error);
798}
799
800SYSCTL_PROC(_kern, OID_AUTO, devname, CTLTYPE_OPAQUE|CTLFLAG_RW|CTLFLAG_ANYBODY,
801	NULL, 0, sysctl_devname, "", "devname(3) handler");
802