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