xref: /freebsd/sys/kern/kern_conf.c (revision 6bfa9a2d66dd0e00182017d6741d44e54d0b2cca)
126453f35SJulian Elischer /*-
266cdbc28SPoul-Henning Kamp  * Copyright (c) 1999-2002 Poul-Henning Kamp
326453f35SJulian Elischer  * All rights reserved.
426453f35SJulian Elischer  *
526453f35SJulian Elischer  * Redistribution and use in source and binary forms, with or without
626453f35SJulian Elischer  * modification, are permitted provided that the following conditions
726453f35SJulian Elischer  * are met:
826453f35SJulian Elischer  * 1. Redistributions of source code must retain the above copyright
926453f35SJulian Elischer  *    notice, this list of conditions and the following disclaimer.
1026453f35SJulian Elischer  * 2. Redistributions in binary form must reproduce the above copyright
1126453f35SJulian Elischer  *    notice, this list of conditions and the following disclaimer in the
1226453f35SJulian Elischer  *    documentation and/or other materials provided with the distribution.
1326453f35SJulian Elischer  *
1466cdbc28SPoul-Henning Kamp  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
1566cdbc28SPoul-Henning Kamp  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
1626453f35SJulian Elischer  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
1766cdbc28SPoul-Henning Kamp  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
1826453f35SJulian Elischer  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
1926453f35SJulian Elischer  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
2026453f35SJulian Elischer  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
2126453f35SJulian Elischer  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
2226453f35SJulian Elischer  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
2326453f35SJulian Elischer  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
2426453f35SJulian Elischer  * SUCH DAMAGE.
2526453f35SJulian Elischer  */
2626453f35SJulian Elischer 
27677b542eSDavid E. O'Brien #include <sys/cdefs.h>
28677b542eSDavid E. O'Brien __FBSDID("$FreeBSD$");
29677b542eSDavid E. O'Brien 
3026453f35SJulian Elischer #include <sys/param.h>
31698bfad7SPoul-Henning Kamp #include <sys/kernel.h>
32f8a760b3SJulian Elischer #include <sys/systm.h>
3348504cc2SKonstantin Belousov #include <sys/bus.h>
3402574b19SPoul-Henning Kamp #include <sys/bio.h>
351b567820SBrian Feldman #include <sys/lock.h>
361b567820SBrian Feldman #include <sys/mutex.h>
37ecbb00a2SDoug Rabson #include <sys/module.h>
38698bfad7SPoul-Henning Kamp #include <sys/malloc.h>
3926453f35SJulian Elischer #include <sys/conf.h>
401dfcbb0cSJulian Elischer #include <sys/vnode.h>
41698bfad7SPoul-Henning Kamp #include <sys/queue.h>
42b2941431SPoul-Henning Kamp #include <sys/poll.h>
43de10ffa5SKonstantin Belousov #include <sys/sx.h>
44db901281SPoul-Henning Kamp #include <sys/ctype.h>
45d26dd2d9SRobert Watson #include <sys/ucred.h>
46de10ffa5SKonstantin Belousov #include <sys/taskqueue.h>
470ef1c826SPoul-Henning Kamp #include <machine/stdarg.h>
481dfcbb0cSJulian Elischer 
499c0af131SPoul-Henning Kamp #include <fs/devfs/devfs_int.h>
509c0af131SPoul-Henning Kamp 
519ef295b7SPoul-Henning Kamp static MALLOC_DEFINE(M_DEVT, "cdev", "cdev storage");
52698bfad7SPoul-Henning Kamp 
53e606a3c6SPoul-Henning Kamp struct mtx devmtx;
54aa2f6ddcSPoul-Henning Kamp static void destroy_devl(struct cdev *dev);
559d53363bSKonstantin Belousov static int destroy_dev_sched_cbl(struct cdev *dev,
569d53363bSKonstantin Belousov     void (*cb)(void *), void *arg);
57de10ffa5SKonstantin Belousov static struct cdev *make_dev_credv(int flags,
58edde8745SEd Schouten     struct cdevsw *devsw, int unit,
59d26dd2d9SRobert Watson     struct ucred *cr, uid_t uid, gid_t gid, int mode, const char *fmt,
60d26dd2d9SRobert Watson     va_list ap);
61f3732fd1SPoul-Henning Kamp 
629bc911d4SKonstantin Belousov static struct cdev_priv_list cdevp_free_list =
639bc911d4SKonstantin Belousov     TAILQ_HEAD_INITIALIZER(cdevp_free_list);
64aeeb4202SKonstantin Belousov static SLIST_HEAD(free_cdevsw, cdevsw) cdevsw_gt_post_list =
65aeeb4202SKonstantin Belousov     SLIST_HEAD_INITIALIZER();
669bc911d4SKonstantin Belousov 
67a0e78d2eSPoul-Henning Kamp void
68a0e78d2eSPoul-Henning Kamp dev_lock(void)
69cd690b60SPoul-Henning Kamp {
708c4b6380SJohn Baldwin 
71cd690b60SPoul-Henning Kamp 	mtx_lock(&devmtx);
72cd690b60SPoul-Henning Kamp }
73cd690b60SPoul-Henning Kamp 
74aeeb4202SKonstantin Belousov /*
75aeeb4202SKonstantin Belousov  * Free all the memory collected while the cdev mutex was
76aeeb4202SKonstantin Belousov  * locked. Since devmtx is after the system map mutex, free() cannot
77aeeb4202SKonstantin Belousov  * be called immediately and is postponed until cdev mutex can be
78aeeb4202SKonstantin Belousov  * dropped.
79aeeb4202SKonstantin Belousov  */
809bc911d4SKonstantin Belousov static void
819bc911d4SKonstantin Belousov dev_unlock_and_free(void)
829bc911d4SKonstantin Belousov {
83aeeb4202SKonstantin Belousov 	struct cdev_priv_list cdp_free;
84aeeb4202SKonstantin Belousov 	struct free_cdevsw csw_free;
859bc911d4SKonstantin Belousov 	struct cdev_priv *cdp;
86aeeb4202SKonstantin Belousov 	struct cdevsw *csw;
879bc911d4SKonstantin Belousov 
889bc911d4SKonstantin Belousov 	mtx_assert(&devmtx, MA_OWNED);
89aeeb4202SKonstantin Belousov 
90aeeb4202SKonstantin Belousov 	/*
91aeeb4202SKonstantin Belousov 	 * Make the local copy of the list heads while the dev_mtx is
92aeeb4202SKonstantin Belousov 	 * held. Free it later.
93aeeb4202SKonstantin Belousov 	 */
94aeeb4202SKonstantin Belousov 	TAILQ_INIT(&cdp_free);
95aeeb4202SKonstantin Belousov 	TAILQ_CONCAT(&cdp_free, &cdevp_free_list, cdp_list);
96aeeb4202SKonstantin Belousov 	csw_free = cdevsw_gt_post_list;
97aeeb4202SKonstantin Belousov 	SLIST_INIT(&cdevsw_gt_post_list);
98aeeb4202SKonstantin Belousov 
999bc911d4SKonstantin Belousov 	mtx_unlock(&devmtx);
100aeeb4202SKonstantin Belousov 
101aeeb4202SKonstantin Belousov 	while ((cdp = TAILQ_FIRST(&cdp_free)) != NULL) {
102aeeb4202SKonstantin Belousov 		TAILQ_REMOVE(&cdp_free, cdp, cdp_list);
1039bc911d4SKonstantin Belousov 		devfs_free(&cdp->cdp_c);
1049bc911d4SKonstantin Belousov 	}
105aeeb4202SKonstantin Belousov 	while ((csw = SLIST_FIRST(&csw_free)) != NULL) {
106aeeb4202SKonstantin Belousov 		SLIST_REMOVE_HEAD(&csw_free, d_postfree_list);
107aeeb4202SKonstantin Belousov 		free(csw, M_DEVT);
108aeeb4202SKonstantin Belousov 	}
1099bc911d4SKonstantin Belousov }
1109bc911d4SKonstantin Belousov 
1119bc911d4SKonstantin Belousov static void
1129bc911d4SKonstantin Belousov dev_free_devlocked(struct cdev *cdev)
1139bc911d4SKonstantin Belousov {
1149bc911d4SKonstantin Belousov 	struct cdev_priv *cdp;
1159bc911d4SKonstantin Belousov 
1169bc911d4SKonstantin Belousov 	mtx_assert(&devmtx, MA_OWNED);
11705427aafSKonstantin Belousov 	cdp = cdev2priv(cdev);
1189bc911d4SKonstantin Belousov 	TAILQ_INSERT_HEAD(&cdevp_free_list, cdp, cdp_list);
1199bc911d4SKonstantin Belousov }
1209bc911d4SKonstantin Belousov 
121aeeb4202SKonstantin Belousov static void
122aeeb4202SKonstantin Belousov cdevsw_free_devlocked(struct cdevsw *csw)
123aeeb4202SKonstantin Belousov {
124aeeb4202SKonstantin Belousov 
125aeeb4202SKonstantin Belousov 	mtx_assert(&devmtx, MA_OWNED);
126aeeb4202SKonstantin Belousov 	SLIST_INSERT_HEAD(&cdevsw_gt_post_list, csw, d_postfree_list);
127aeeb4202SKonstantin Belousov }
128aeeb4202SKonstantin Belousov 
129a0e78d2eSPoul-Henning Kamp void
130a0e78d2eSPoul-Henning Kamp dev_unlock(void)
131cd690b60SPoul-Henning Kamp {
1322c15afd8SPoul-Henning Kamp 
133cd690b60SPoul-Henning Kamp 	mtx_unlock(&devmtx);
134cd690b60SPoul-Henning Kamp }
135cd690b60SPoul-Henning Kamp 
136cd690b60SPoul-Henning Kamp void
1379477d73eSPoul-Henning Kamp dev_ref(struct cdev *dev)
1389477d73eSPoul-Henning Kamp {
1399477d73eSPoul-Henning Kamp 
1409477d73eSPoul-Henning Kamp 	mtx_assert(&devmtx, MA_NOTOWNED);
1419477d73eSPoul-Henning Kamp 	mtx_lock(&devmtx);
1429477d73eSPoul-Henning Kamp 	dev->si_refcount++;
1439477d73eSPoul-Henning Kamp 	mtx_unlock(&devmtx);
1449477d73eSPoul-Henning Kamp }
1459477d73eSPoul-Henning Kamp 
1469477d73eSPoul-Henning Kamp void
147eb151cb9SPoul-Henning Kamp dev_refl(struct cdev *dev)
148cd690b60SPoul-Henning Kamp {
1492c15afd8SPoul-Henning Kamp 
1501a1457d4SPoul-Henning Kamp 	mtx_assert(&devmtx, MA_OWNED);
151cd690b60SPoul-Henning Kamp 	dev->si_refcount++;
152cd690b60SPoul-Henning Kamp }
153cd690b60SPoul-Henning Kamp 
154cd690b60SPoul-Henning Kamp void
155aa2f6ddcSPoul-Henning Kamp dev_rel(struct cdev *dev)
156cd690b60SPoul-Henning Kamp {
157aa2f6ddcSPoul-Henning Kamp 	int flag = 0;
158a0e78d2eSPoul-Henning Kamp 
159ba285125SPoul-Henning Kamp 	mtx_assert(&devmtx, MA_NOTOWNED);
160ba285125SPoul-Henning Kamp 	dev_lock();
161cd690b60SPoul-Henning Kamp 	dev->si_refcount--;
162cd690b60SPoul-Henning Kamp 	KASSERT(dev->si_refcount >= 0,
163cd690b60SPoul-Henning Kamp 	    ("dev_rel(%s) gave negative count", devtoname(dev)));
164e606a3c6SPoul-Henning Kamp #if 0
165aa2f6ddcSPoul-Henning Kamp 	if (dev->si_usecount == 0 &&
166aa2f6ddcSPoul-Henning Kamp 	    (dev->si_flags & SI_CHEAPCLONE) && (dev->si_flags & SI_NAMED))
167e606a3c6SPoul-Henning Kamp 		;
168e606a3c6SPoul-Henning Kamp 	else
169e606a3c6SPoul-Henning Kamp #endif
170cd690b60SPoul-Henning Kamp 	if (dev->si_devsw == NULL && dev->si_refcount == 0) {
171cd690b60SPoul-Henning Kamp 		LIST_REMOVE(dev, si_list);
172ba285125SPoul-Henning Kamp 		flag = 1;
173ba285125SPoul-Henning Kamp 	}
174ba285125SPoul-Henning Kamp 	dev_unlock();
175ba285125SPoul-Henning Kamp 	if (flag)
176e606a3c6SPoul-Henning Kamp 		devfs_free(dev);
177cd690b60SPoul-Henning Kamp }
178ba285125SPoul-Henning Kamp 
1792c15afd8SPoul-Henning Kamp struct cdevsw *
1802c15afd8SPoul-Henning Kamp dev_refthread(struct cdev *dev)
1812c15afd8SPoul-Henning Kamp {
1822c15afd8SPoul-Henning Kamp 	struct cdevsw *csw;
183de10ffa5SKonstantin Belousov 	struct cdev_priv *cdp;
1842c15afd8SPoul-Henning Kamp 
1852c15afd8SPoul-Henning Kamp 	mtx_assert(&devmtx, MA_NOTOWNED);
1862c15afd8SPoul-Henning Kamp 	dev_lock();
1872c15afd8SPoul-Henning Kamp 	csw = dev->si_devsw;
188de10ffa5SKonstantin Belousov 	if (csw != NULL) {
18905427aafSKonstantin Belousov 		cdp = cdev2priv(dev);
190de10ffa5SKonstantin Belousov 		if ((cdp->cdp_flags & CDP_SCHED_DTR) == 0)
1912c15afd8SPoul-Henning Kamp 			dev->si_threadcount++;
192de10ffa5SKonstantin Belousov 		else
193de10ffa5SKonstantin Belousov 			csw = NULL;
194de10ffa5SKonstantin Belousov 	}
1952c15afd8SPoul-Henning Kamp 	dev_unlock();
1962c15afd8SPoul-Henning Kamp 	return (csw);
1972c15afd8SPoul-Henning Kamp }
1982c15afd8SPoul-Henning Kamp 
1991663075cSKonstantin Belousov struct cdevsw *
2001663075cSKonstantin Belousov devvn_refthread(struct vnode *vp, struct cdev **devp)
2011663075cSKonstantin Belousov {
2021663075cSKonstantin Belousov 	struct cdevsw *csw;
203de10ffa5SKonstantin Belousov 	struct cdev_priv *cdp;
2041663075cSKonstantin Belousov 
2051663075cSKonstantin Belousov 	mtx_assert(&devmtx, MA_NOTOWNED);
2061663075cSKonstantin Belousov 	csw = NULL;
2071663075cSKonstantin Belousov 	dev_lock();
2081663075cSKonstantin Belousov 	*devp = vp->v_rdev;
2091663075cSKonstantin Belousov 	if (*devp != NULL) {
21005427aafSKonstantin Belousov 		cdp = cdev2priv(*devp);
211de10ffa5SKonstantin Belousov 		if ((cdp->cdp_flags & CDP_SCHED_DTR) == 0) {
2121663075cSKonstantin Belousov 			csw = (*devp)->si_devsw;
2131663075cSKonstantin Belousov 			if (csw != NULL)
2141663075cSKonstantin Belousov 				(*devp)->si_threadcount++;
2151663075cSKonstantin Belousov 		}
216de10ffa5SKonstantin Belousov 	}
2171663075cSKonstantin Belousov 	dev_unlock();
2181663075cSKonstantin Belousov 	return (csw);
2191663075cSKonstantin Belousov }
2201663075cSKonstantin Belousov 
2212c15afd8SPoul-Henning Kamp void
2222c15afd8SPoul-Henning Kamp dev_relthread(struct cdev *dev)
2232c15afd8SPoul-Henning Kamp {
2242c15afd8SPoul-Henning Kamp 
2252c15afd8SPoul-Henning Kamp 	mtx_assert(&devmtx, MA_NOTOWNED);
2262c15afd8SPoul-Henning Kamp 	dev_lock();
22706fe1129SKonstantin Belousov 	KASSERT(dev->si_threadcount > 0,
22806fe1129SKonstantin Belousov 	    ("%s threadcount is wrong", dev->si_name));
2292c15afd8SPoul-Henning Kamp 	dev->si_threadcount--;
2302c15afd8SPoul-Henning Kamp 	dev_unlock();
2312c15afd8SPoul-Henning Kamp }
232cd690b60SPoul-Henning Kamp 
233b2941431SPoul-Henning Kamp int
234b2941431SPoul-Henning Kamp nullop(void)
235b2941431SPoul-Henning Kamp {
236b2941431SPoul-Henning Kamp 
237b2941431SPoul-Henning Kamp 	return (0);
238b2941431SPoul-Henning Kamp }
239b2941431SPoul-Henning Kamp 
240b2941431SPoul-Henning Kamp int
241b2941431SPoul-Henning Kamp eopnotsupp(void)
242b2941431SPoul-Henning Kamp {
243b2941431SPoul-Henning Kamp 
244b2941431SPoul-Henning Kamp 	return (EOPNOTSUPP);
245b2941431SPoul-Henning Kamp }
24602574b19SPoul-Henning Kamp 
24702574b19SPoul-Henning Kamp static int
24802574b19SPoul-Henning Kamp enxio(void)
24902574b19SPoul-Henning Kamp {
25002574b19SPoul-Henning Kamp 	return (ENXIO);
25102574b19SPoul-Henning Kamp }
25202574b19SPoul-Henning Kamp 
253b2941431SPoul-Henning Kamp static int
254b2941431SPoul-Henning Kamp enodev(void)
255b2941431SPoul-Henning Kamp {
256b2941431SPoul-Henning Kamp 	return (ENODEV);
257b2941431SPoul-Henning Kamp }
258b2941431SPoul-Henning Kamp 
259b2941431SPoul-Henning Kamp /* Define a dead_cdevsw for use when devices leave unexpectedly. */
260b2941431SPoul-Henning Kamp 
26102574b19SPoul-Henning Kamp #define dead_open	(d_open_t *)enxio
26202574b19SPoul-Henning Kamp #define dead_close	(d_close_t *)enxio
26302574b19SPoul-Henning Kamp #define dead_read	(d_read_t *)enxio
26402574b19SPoul-Henning Kamp #define dead_write	(d_write_t *)enxio
26502574b19SPoul-Henning Kamp #define dead_ioctl	(d_ioctl_t *)enxio
266b2941431SPoul-Henning Kamp #define dead_poll	(d_poll_t *)enodev
267b2941431SPoul-Henning Kamp #define dead_mmap	(d_mmap_t *)enodev
26802574b19SPoul-Henning Kamp 
26902574b19SPoul-Henning Kamp static void
27002574b19SPoul-Henning Kamp dead_strategy(struct bio *bp)
27102574b19SPoul-Henning Kamp {
27202574b19SPoul-Henning Kamp 
27302574b19SPoul-Henning Kamp 	biofinish(bp, NULL, ENXIO);
27402574b19SPoul-Henning Kamp }
27502574b19SPoul-Henning Kamp 
2762c6b49f6SPoul-Henning Kamp #define dead_dump	(dumper_t *)enxio
27702574b19SPoul-Henning Kamp #define dead_kqfilter	(d_kqfilter_t *)enxio
27802574b19SPoul-Henning Kamp 
27902574b19SPoul-Henning Kamp static struct cdevsw dead_cdevsw = {
280dc08ffecSPoul-Henning Kamp 	.d_version =	D_VERSION,
281dc08ffecSPoul-Henning Kamp 	.d_flags =	D_NEEDGIANT, /* XXX: does dead_strategy need this ? */
2827ac40f5fSPoul-Henning Kamp 	.d_open =	dead_open,
2837ac40f5fSPoul-Henning Kamp 	.d_close =	dead_close,
2847ac40f5fSPoul-Henning Kamp 	.d_read =	dead_read,
2857ac40f5fSPoul-Henning Kamp 	.d_write =	dead_write,
2867ac40f5fSPoul-Henning Kamp 	.d_ioctl =	dead_ioctl,
2877ac40f5fSPoul-Henning Kamp 	.d_poll =	dead_poll,
2887ac40f5fSPoul-Henning Kamp 	.d_mmap =	dead_mmap,
2897ac40f5fSPoul-Henning Kamp 	.d_strategy =	dead_strategy,
2907ac40f5fSPoul-Henning Kamp 	.d_name =	"dead",
2917ac40f5fSPoul-Henning Kamp 	.d_dump =	dead_dump,
2927ac40f5fSPoul-Henning Kamp 	.d_kqfilter =	dead_kqfilter
29302574b19SPoul-Henning Kamp };
29402574b19SPoul-Henning Kamp 
295b2941431SPoul-Henning Kamp /* Default methods if driver does not specify method */
296b2941431SPoul-Henning Kamp 
297b2941431SPoul-Henning Kamp #define null_open	(d_open_t *)nullop
298b2941431SPoul-Henning Kamp #define null_close	(d_close_t *)nullop
299b2941431SPoul-Henning Kamp #define no_read		(d_read_t *)enodev
300b2941431SPoul-Henning Kamp #define no_write	(d_write_t *)enodev
301b2941431SPoul-Henning Kamp #define no_ioctl	(d_ioctl_t *)enodev
302b2941431SPoul-Henning Kamp #define no_mmap		(d_mmap_t *)enodev
303ad3b9257SJohn-Mark Gurney #define no_kqfilter	(d_kqfilter_t *)enodev
304b2941431SPoul-Henning Kamp 
305b2941431SPoul-Henning Kamp static void
306b2941431SPoul-Henning Kamp no_strategy(struct bio *bp)
307b2941431SPoul-Henning Kamp {
308b2941431SPoul-Henning Kamp 
309b2941431SPoul-Henning Kamp 	biofinish(bp, NULL, ENODEV);
310b2941431SPoul-Henning Kamp }
311b2941431SPoul-Henning Kamp 
312b2941431SPoul-Henning Kamp static int
31389c9c53dSPoul-Henning Kamp no_poll(struct cdev *dev __unused, int events, struct thread *td __unused)
314b2941431SPoul-Henning Kamp {
315b2941431SPoul-Henning Kamp 	/*
316b2941431SPoul-Henning Kamp 	 * Return true for read/write.  If the user asked for something
317b2941431SPoul-Henning Kamp 	 * special, return POLLNVAL, so that clients have a way of
318b2941431SPoul-Henning Kamp 	 * determining reliably whether or not the extended
319b2941431SPoul-Henning Kamp 	 * functionality is present without hard-coding knowledge
320b2941431SPoul-Henning Kamp 	 * of specific filesystem implementations.
321b2941431SPoul-Henning Kamp 	 * Stay in sync with vop_nopoll().
322b2941431SPoul-Henning Kamp 	 */
323b2941431SPoul-Henning Kamp 	if (events & ~POLLSTANDARD)
324b2941431SPoul-Henning Kamp 		return (POLLNVAL);
325b2941431SPoul-Henning Kamp 
326b2941431SPoul-Henning Kamp 	return (events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM));
327b2941431SPoul-Henning Kamp }
328b2941431SPoul-Henning Kamp 
329b2941431SPoul-Henning Kamp #define no_dump		(dumper_t *)enodev
3304e4a7663SPoul-Henning Kamp 
331516ad423SPoul-Henning Kamp static int
332516ad423SPoul-Henning Kamp giant_open(struct cdev *dev, int oflags, int devtype, struct thread *td)
333516ad423SPoul-Henning Kamp {
334aeeb4202SKonstantin Belousov 	struct cdevsw *dsw;
335516ad423SPoul-Henning Kamp 	int retval;
336516ad423SPoul-Henning Kamp 
337aeeb4202SKonstantin Belousov 	dsw = dev_refthread(dev);
338aeeb4202SKonstantin Belousov 	if (dsw == NULL)
339aeeb4202SKonstantin Belousov 		return (ENXIO);
340516ad423SPoul-Henning Kamp 	mtx_lock(&Giant);
341aeeb4202SKonstantin Belousov 	retval = dsw->d_gianttrick->d_open(dev, oflags, devtype, td);
342516ad423SPoul-Henning Kamp 	mtx_unlock(&Giant);
343aeeb4202SKonstantin Belousov 	dev_relthread(dev);
344516ad423SPoul-Henning Kamp 	return (retval);
345516ad423SPoul-Henning Kamp }
346516ad423SPoul-Henning Kamp 
347516ad423SPoul-Henning Kamp static int
3489e223287SKonstantin Belousov giant_fdopen(struct cdev *dev, int oflags, struct thread *td, struct file *fp)
349516ad423SPoul-Henning Kamp {
350aeeb4202SKonstantin Belousov 	struct cdevsw *dsw;
351516ad423SPoul-Henning Kamp 	int retval;
352516ad423SPoul-Henning Kamp 
353aeeb4202SKonstantin Belousov 	dsw = dev_refthread(dev);
354aeeb4202SKonstantin Belousov 	if (dsw == NULL)
355aeeb4202SKonstantin Belousov 		return (ENXIO);
356516ad423SPoul-Henning Kamp 	mtx_lock(&Giant);
357aeeb4202SKonstantin Belousov 	retval = dsw->d_gianttrick->d_fdopen(dev, oflags, td, fp);
358516ad423SPoul-Henning Kamp 	mtx_unlock(&Giant);
359aeeb4202SKonstantin Belousov 	dev_relthread(dev);
360516ad423SPoul-Henning Kamp 	return (retval);
361516ad423SPoul-Henning Kamp }
362516ad423SPoul-Henning Kamp 
363516ad423SPoul-Henning Kamp static int
364516ad423SPoul-Henning Kamp giant_close(struct cdev *dev, int fflag, int devtype, struct thread *td)
365516ad423SPoul-Henning Kamp {
366aeeb4202SKonstantin Belousov 	struct cdevsw *dsw;
367516ad423SPoul-Henning Kamp 	int retval;
368516ad423SPoul-Henning Kamp 
369aeeb4202SKonstantin Belousov 	dsw = dev_refthread(dev);
370aeeb4202SKonstantin Belousov 	if (dsw == NULL)
371aeeb4202SKonstantin Belousov 		return (ENXIO);
372516ad423SPoul-Henning Kamp 	mtx_lock(&Giant);
373aeeb4202SKonstantin Belousov 	retval = dsw->d_gianttrick->d_close(dev, fflag, devtype, td);
374516ad423SPoul-Henning Kamp 	mtx_unlock(&Giant);
375aeeb4202SKonstantin Belousov 	dev_relthread(dev);
376516ad423SPoul-Henning Kamp 	return (retval);
377516ad423SPoul-Henning Kamp }
378516ad423SPoul-Henning Kamp 
379516ad423SPoul-Henning Kamp static void
380516ad423SPoul-Henning Kamp giant_strategy(struct bio *bp)
381516ad423SPoul-Henning Kamp {
382aeeb4202SKonstantin Belousov 	struct cdevsw *dsw;
383aeeb4202SKonstantin Belousov 	struct cdev *dev;
384516ad423SPoul-Henning Kamp 
385aeeb4202SKonstantin Belousov 	dev = bp->bio_dev;
386aeeb4202SKonstantin Belousov 	dsw = dev_refthread(dev);
387aeeb4202SKonstantin Belousov 	if (dsw == NULL) {
388aeeb4202SKonstantin Belousov 		biofinish(bp, NULL, ENXIO);
389aeeb4202SKonstantin Belousov 		return;
390aeeb4202SKonstantin Belousov 	}
391516ad423SPoul-Henning Kamp 	mtx_lock(&Giant);
392aeeb4202SKonstantin Belousov 	dsw->d_gianttrick->d_strategy(bp);
393516ad423SPoul-Henning Kamp 	mtx_unlock(&Giant);
394aeeb4202SKonstantin Belousov 	dev_relthread(dev);
395516ad423SPoul-Henning Kamp }
396516ad423SPoul-Henning Kamp 
397516ad423SPoul-Henning Kamp static int
398516ad423SPoul-Henning Kamp giant_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, struct thread *td)
399516ad423SPoul-Henning Kamp {
400aeeb4202SKonstantin Belousov 	struct cdevsw *dsw;
401516ad423SPoul-Henning Kamp 	int retval;
402516ad423SPoul-Henning Kamp 
403aeeb4202SKonstantin Belousov 	dsw = dev_refthread(dev);
404aeeb4202SKonstantin Belousov 	if (dsw == NULL)
405aeeb4202SKonstantin Belousov 		return (ENXIO);
406516ad423SPoul-Henning Kamp 	mtx_lock(&Giant);
40735b45029SKonstantin Belousov 	retval = dsw->d_gianttrick->d_ioctl(dev, cmd, data, fflag, td);
408516ad423SPoul-Henning Kamp 	mtx_unlock(&Giant);
409aeeb4202SKonstantin Belousov 	dev_relthread(dev);
410516ad423SPoul-Henning Kamp 	return (retval);
411516ad423SPoul-Henning Kamp }
412516ad423SPoul-Henning Kamp 
413516ad423SPoul-Henning Kamp static int
414516ad423SPoul-Henning Kamp giant_read(struct cdev *dev, struct uio *uio, int ioflag)
415516ad423SPoul-Henning Kamp {
416aeeb4202SKonstantin Belousov 	struct cdevsw *dsw;
417516ad423SPoul-Henning Kamp 	int retval;
418516ad423SPoul-Henning Kamp 
419aeeb4202SKonstantin Belousov 	dsw = dev_refthread(dev);
420aeeb4202SKonstantin Belousov 	if (dsw == NULL)
421aeeb4202SKonstantin Belousov 		return (ENXIO);
422516ad423SPoul-Henning Kamp 	mtx_lock(&Giant);
42335b45029SKonstantin Belousov 	retval = dsw->d_gianttrick->d_read(dev, uio, ioflag);
424516ad423SPoul-Henning Kamp 	mtx_unlock(&Giant);
425aeeb4202SKonstantin Belousov 	dev_relthread(dev);
426516ad423SPoul-Henning Kamp 	return (retval);
427516ad423SPoul-Henning Kamp }
428516ad423SPoul-Henning Kamp 
429516ad423SPoul-Henning Kamp static int
430516ad423SPoul-Henning Kamp giant_write(struct cdev *dev, struct uio *uio, int ioflag)
431516ad423SPoul-Henning Kamp {
432aeeb4202SKonstantin Belousov 	struct cdevsw *dsw;
433516ad423SPoul-Henning Kamp 	int retval;
434516ad423SPoul-Henning Kamp 
435aeeb4202SKonstantin Belousov 	dsw = dev_refthread(dev);
436aeeb4202SKonstantin Belousov 	if (dsw == NULL)
437aeeb4202SKonstantin Belousov 		return (ENXIO);
438516ad423SPoul-Henning Kamp 	mtx_lock(&Giant);
439aeeb4202SKonstantin Belousov 	retval = dsw->d_gianttrick->d_write(dev, uio, ioflag);
440516ad423SPoul-Henning Kamp 	mtx_unlock(&Giant);
441aeeb4202SKonstantin Belousov 	dev_relthread(dev);
442516ad423SPoul-Henning Kamp 	return (retval);
443516ad423SPoul-Henning Kamp }
444516ad423SPoul-Henning Kamp 
445516ad423SPoul-Henning Kamp static int
446516ad423SPoul-Henning Kamp giant_poll(struct cdev *dev, int events, struct thread *td)
447516ad423SPoul-Henning Kamp {
448aeeb4202SKonstantin Belousov 	struct cdevsw *dsw;
449516ad423SPoul-Henning Kamp 	int retval;
450516ad423SPoul-Henning Kamp 
451aeeb4202SKonstantin Belousov 	dsw = dev_refthread(dev);
452aeeb4202SKonstantin Belousov 	if (dsw == NULL)
453aeeb4202SKonstantin Belousov 		return (ENXIO);
454516ad423SPoul-Henning Kamp 	mtx_lock(&Giant);
455aeeb4202SKonstantin Belousov 	retval = dsw->d_gianttrick->d_poll(dev, events, td);
456516ad423SPoul-Henning Kamp 	mtx_unlock(&Giant);
457aeeb4202SKonstantin Belousov 	dev_relthread(dev);
458516ad423SPoul-Henning Kamp 	return (retval);
459516ad423SPoul-Henning Kamp }
460516ad423SPoul-Henning Kamp 
461516ad423SPoul-Henning Kamp static int
462516ad423SPoul-Henning Kamp giant_kqfilter(struct cdev *dev, struct knote *kn)
463516ad423SPoul-Henning Kamp {
464aeeb4202SKonstantin Belousov 	struct cdevsw *dsw;
465516ad423SPoul-Henning Kamp 	int retval;
466516ad423SPoul-Henning Kamp 
467aeeb4202SKonstantin Belousov 	dsw = dev_refthread(dev);
468aeeb4202SKonstantin Belousov 	if (dsw == NULL)
469aeeb4202SKonstantin Belousov 		return (ENXIO);
470516ad423SPoul-Henning Kamp 	mtx_lock(&Giant);
471aeeb4202SKonstantin Belousov 	retval = dsw->d_gianttrick->d_kqfilter(dev, kn);
472516ad423SPoul-Henning Kamp 	mtx_unlock(&Giant);
473aeeb4202SKonstantin Belousov 	dev_relthread(dev);
474516ad423SPoul-Henning Kamp 	return (retval);
475516ad423SPoul-Henning Kamp }
476516ad423SPoul-Henning Kamp 
477516ad423SPoul-Henning Kamp static int
478516ad423SPoul-Henning Kamp giant_mmap(struct cdev *dev, vm_offset_t offset, vm_paddr_t *paddr, int nprot)
479516ad423SPoul-Henning Kamp {
480aeeb4202SKonstantin Belousov 	struct cdevsw *dsw;
481516ad423SPoul-Henning Kamp 	int retval;
482516ad423SPoul-Henning Kamp 
483aeeb4202SKonstantin Belousov 	dsw = dev_refthread(dev);
484aeeb4202SKonstantin Belousov 	if (dsw == NULL)
485aeeb4202SKonstantin Belousov 		return (ENXIO);
486516ad423SPoul-Henning Kamp 	mtx_lock(&Giant);
487aeeb4202SKonstantin Belousov 	retval = dsw->d_gianttrick->d_mmap(dev, offset, paddr, nprot);
488516ad423SPoul-Henning Kamp 	mtx_unlock(&Giant);
489aeeb4202SKonstantin Belousov 	dev_relthread(dev);
490516ad423SPoul-Henning Kamp 	return (retval);
491516ad423SPoul-Henning Kamp }
492516ad423SPoul-Henning Kamp 
493516ad423SPoul-Henning Kamp 
49448504cc2SKonstantin Belousov static void
49548504cc2SKonstantin Belousov notify(struct cdev *dev, const char *ev)
49648504cc2SKonstantin Belousov {
49748504cc2SKonstantin Belousov 	static const char prefix[] = "cdev=";
49848504cc2SKonstantin Belousov 	char *data;
49948504cc2SKonstantin Belousov 	int namelen;
50048504cc2SKonstantin Belousov 
50148504cc2SKonstantin Belousov 	if (cold)
50248504cc2SKonstantin Belousov 		return;
50348504cc2SKonstantin Belousov 	namelen = strlen(dev->si_name);
50448504cc2SKonstantin Belousov 	data = malloc(namelen + sizeof(prefix), M_TEMP, M_WAITOK);
50548504cc2SKonstantin Belousov 	memcpy(data, prefix, sizeof(prefix) - 1);
50648504cc2SKonstantin Belousov 	memcpy(data + sizeof(prefix) - 1, dev->si_name, namelen + 1);
50748504cc2SKonstantin Belousov 	devctl_notify("DEVFS", "CDEV", ev, data);
50848504cc2SKonstantin Belousov 	free(data, M_TEMP);
50948504cc2SKonstantin Belousov }
51048504cc2SKonstantin Belousov 
51148504cc2SKonstantin Belousov static void
51248504cc2SKonstantin Belousov notify_create(struct cdev *dev)
51348504cc2SKonstantin Belousov {
51448504cc2SKonstantin Belousov 
51548504cc2SKonstantin Belousov 	notify(dev, "CREATE");
51648504cc2SKonstantin Belousov }
51748504cc2SKonstantin Belousov 
51848504cc2SKonstantin Belousov static void
51948504cc2SKonstantin Belousov notify_destroy(struct cdev *dev)
52048504cc2SKonstantin Belousov {
52148504cc2SKonstantin Belousov 
52248504cc2SKonstantin Belousov 	notify(dev, "DESTROY");
52348504cc2SKonstantin Belousov }
52448504cc2SKonstantin Belousov 
52589c9c53dSPoul-Henning Kamp static struct cdev *
526ff7284eeSPoul-Henning Kamp newdev(struct cdevsw *csw, int y, struct cdev *si)
5273f54a085SPoul-Henning Kamp {
528027b1f71SPoul-Henning Kamp 	struct cdev *si2;
529f3732fd1SPoul-Henning Kamp 	dev_t	udev;
5303f54a085SPoul-Henning Kamp 
531027b1f71SPoul-Henning Kamp 	mtx_assert(&devmtx, MA_OWNED);
532b3d82c03SPoul-Henning Kamp 	udev = y;
53329d4cb24SEd Schouten 	if (csw->d_flags & D_NEEDMINOR) {
53429d4cb24SEd Schouten 		/* We may want to return an existing device */
535ff7284eeSPoul-Henning Kamp 		LIST_FOREACH(si2, &csw->d_devs, si_list) {
5360a2e49f1SPoul-Henning Kamp 			if (si2->si_drv0 == udev) {
5379bc911d4SKonstantin Belousov 				dev_free_devlocked(si);
538027b1f71SPoul-Henning Kamp 				return (si2);
5393f54a085SPoul-Henning Kamp 			}
540027b1f71SPoul-Henning Kamp 		}
54129d4cb24SEd Schouten 	}
5420a2e49f1SPoul-Henning Kamp 	si->si_drv0 = udev;
543e606a3c6SPoul-Henning Kamp 	si->si_devsw = csw;
544ff7284eeSPoul-Henning Kamp 	LIST_INSERT_HEAD(&csw->d_devs, si, si_list);
545698bfad7SPoul-Henning Kamp 	return (si);
546bfbb9ce6SPoul-Henning Kamp }
547bfbb9ce6SPoul-Henning Kamp 
54806d425f9SEd Schouten #define UMINORMASK	0xffff00ffU
54906d425f9SEd Schouten 
550bfbb9ce6SPoul-Henning Kamp int
551f3732fd1SPoul-Henning Kamp uminor(dev_t dev)
552bfbb9ce6SPoul-Henning Kamp {
55306d425f9SEd Schouten 	return (dev & UMINORMASK);
554bfbb9ce6SPoul-Henning Kamp }
555bfbb9ce6SPoul-Henning Kamp 
556bfbb9ce6SPoul-Henning Kamp int
557f3732fd1SPoul-Henning Kamp umajor(dev_t dev)
558bfbb9ce6SPoul-Henning Kamp {
55906d425f9SEd Schouten 	return ((dev & ~UMINORMASK) >> 8);
560bfbb9ce6SPoul-Henning Kamp }
561bfbb9ce6SPoul-Henning Kamp 
5622a3faf2fSPoul-Henning Kamp static void
563cd690b60SPoul-Henning Kamp fini_cdevsw(struct cdevsw *devsw)
564cd690b60SPoul-Henning Kamp {
5651d45c50eSPoul-Henning Kamp 	struct cdevsw *gt;
566b3d82c03SPoul-Henning Kamp 
5671d45c50eSPoul-Henning Kamp 	if (devsw->d_gianttrick != NULL) {
5681d45c50eSPoul-Henning Kamp 		gt = devsw->d_gianttrick;
5691d45c50eSPoul-Henning Kamp 		memcpy(devsw, gt, sizeof *devsw);
570aeeb4202SKonstantin Belousov 		cdevsw_free_devlocked(gt);
571516ad423SPoul-Henning Kamp 		devsw->d_gianttrick = NULL;
5721d45c50eSPoul-Henning Kamp 	}
573652d0472SPoul-Henning Kamp 	devsw->d_flags &= ~D_INIT;
574b0b03348SPoul-Henning Kamp }
575b0b03348SPoul-Henning Kamp 
576b0b03348SPoul-Henning Kamp static void
577b0b03348SPoul-Henning Kamp prep_cdevsw(struct cdevsw *devsw)
578b0b03348SPoul-Henning Kamp {
579516ad423SPoul-Henning Kamp 	struct cdevsw *dsw2;
580b0b03348SPoul-Henning Kamp 
581aeeb4202SKonstantin Belousov 	mtx_assert(&devmtx, MA_OWNED);
582aeeb4202SKonstantin Belousov 	if (devsw->d_flags & D_INIT)
583aeeb4202SKonstantin Belousov 		return;
584aeeb4202SKonstantin Belousov 	if (devsw->d_flags & D_NEEDGIANT) {
585aeeb4202SKonstantin Belousov 		dev_unlock();
586516ad423SPoul-Henning Kamp 		dsw2 = malloc(sizeof *dsw2, M_DEVT, M_WAITOK);
587a0e78d2eSPoul-Henning Kamp 		dev_lock();
588aeeb4202SKonstantin Belousov 	} else
589aeeb4202SKonstantin Belousov 		dsw2 = NULL;
590aeeb4202SKonstantin Belousov 	if (devsw->d_flags & D_INIT) {
591aeeb4202SKonstantin Belousov 		if (dsw2 != NULL)
592aeeb4202SKonstantin Belousov 			cdevsw_free_devlocked(dsw2);
593aeeb4202SKonstantin Belousov 		return;
594aeeb4202SKonstantin Belousov 	}
595cd690b60SPoul-Henning Kamp 
596800b42bdSPoul-Henning Kamp 	if (devsw->d_version != D_VERSION_01) {
597cd690b60SPoul-Henning Kamp 		printf(
598cd690b60SPoul-Henning Kamp 		    "WARNING: Device driver \"%s\" has wrong version %s\n",
5997d7e053cSAlfred Perlstein 		    devsw->d_name == NULL ? "???" : devsw->d_name,
6007d7e053cSAlfred Perlstein 		    "and is disabled.  Recompile KLD module.");
601cd690b60SPoul-Henning Kamp 		devsw->d_open = dead_open;
602cd690b60SPoul-Henning Kamp 		devsw->d_close = dead_close;
603cd690b60SPoul-Henning Kamp 		devsw->d_read = dead_read;
604cd690b60SPoul-Henning Kamp 		devsw->d_write = dead_write;
605cd690b60SPoul-Henning Kamp 		devsw->d_ioctl = dead_ioctl;
606cd690b60SPoul-Henning Kamp 		devsw->d_poll = dead_poll;
607cd690b60SPoul-Henning Kamp 		devsw->d_mmap = dead_mmap;
608cd690b60SPoul-Henning Kamp 		devsw->d_strategy = dead_strategy;
609cd690b60SPoul-Henning Kamp 		devsw->d_dump = dead_dump;
610cd690b60SPoul-Henning Kamp 		devsw->d_kqfilter = dead_kqfilter;
611cd690b60SPoul-Henning Kamp 	}
612cd690b60SPoul-Henning Kamp 
613516ad423SPoul-Henning Kamp 	if (devsw->d_flags & D_NEEDGIANT) {
614516ad423SPoul-Henning Kamp 		if (devsw->d_gianttrick == NULL) {
615516ad423SPoul-Henning Kamp 			memcpy(dsw2, devsw, sizeof *dsw2);
616516ad423SPoul-Henning Kamp 			devsw->d_gianttrick = dsw2;
617aeeb4202SKonstantin Belousov 			dsw2 = NULL;
618aeeb4202SKonstantin Belousov 		}
619516ad423SPoul-Henning Kamp 	}
620516ad423SPoul-Henning Kamp 
621516ad423SPoul-Henning Kamp #define FIXUP(member, noop, giant) 				\
622516ad423SPoul-Henning Kamp 	do {							\
623516ad423SPoul-Henning Kamp 		if (devsw->member == NULL) {			\
624516ad423SPoul-Henning Kamp 			devsw->member = noop;			\
625516ad423SPoul-Henning Kamp 		} else if (devsw->d_flags & D_NEEDGIANT)	\
626516ad423SPoul-Henning Kamp 			devsw->member = giant;			\
627516ad423SPoul-Henning Kamp 		}						\
628516ad423SPoul-Henning Kamp 	while (0)
629516ad423SPoul-Henning Kamp 
630516ad423SPoul-Henning Kamp 	FIXUP(d_open,		null_open,	giant_open);
631516ad423SPoul-Henning Kamp 	FIXUP(d_fdopen,		NULL,		giant_fdopen);
632516ad423SPoul-Henning Kamp 	FIXUP(d_close,		null_close,	giant_close);
633516ad423SPoul-Henning Kamp 	FIXUP(d_read,		no_read,	giant_read);
634516ad423SPoul-Henning Kamp 	FIXUP(d_write,		no_write,	giant_write);
635516ad423SPoul-Henning Kamp 	FIXUP(d_ioctl,		no_ioctl,	giant_ioctl);
636516ad423SPoul-Henning Kamp 	FIXUP(d_poll,		no_poll,	giant_poll);
637516ad423SPoul-Henning Kamp 	FIXUP(d_mmap,		no_mmap,	giant_mmap);
638516ad423SPoul-Henning Kamp 	FIXUP(d_strategy,	no_strategy,	giant_strategy);
639516ad423SPoul-Henning Kamp 	FIXUP(d_kqfilter,	no_kqfilter,	giant_kqfilter);
640516ad423SPoul-Henning Kamp 
641b2941431SPoul-Henning Kamp 	if (devsw->d_dump == NULL)	devsw->d_dump = no_dump;
642cd690b60SPoul-Henning Kamp 
643cd690b60SPoul-Henning Kamp 	LIST_INIT(&devsw->d_devs);
644cd690b60SPoul-Henning Kamp 
645cd690b60SPoul-Henning Kamp 	devsw->d_flags |= D_INIT;
646cd690b60SPoul-Henning Kamp 
647aeeb4202SKonstantin Belousov 	if (dsw2 != NULL)
648aeeb4202SKonstantin Belousov 		cdevsw_free_devlocked(dsw2);
6492a3faf2fSPoul-Henning Kamp }
65011586717SBrian Somers 
651de10ffa5SKonstantin Belousov struct cdev *
652edde8745SEd Schouten make_dev_credv(int flags, struct cdevsw *devsw, int unit,
653de10ffa5SKonstantin Belousov     struct ucred *cr, uid_t uid,
654d26dd2d9SRobert Watson     gid_t gid, int mode, const char *fmt, va_list ap)
6552a3faf2fSPoul-Henning Kamp {
65689c9c53dSPoul-Henning Kamp 	struct cdev *dev;
6572a3faf2fSPoul-Henning Kamp 	int i;
6582a3faf2fSPoul-Henning Kamp 
659e606a3c6SPoul-Henning Kamp 	dev = devfs_alloc();
660027b1f71SPoul-Henning Kamp 	dev_lock();
661aeeb4202SKonstantin Belousov 	prep_cdevsw(devsw);
662edde8745SEd Schouten 	dev = newdev(devsw, unit, dev);
663de10ffa5SKonstantin Belousov 	if (flags & MAKEDEV_REF)
664de10ffa5SKonstantin Belousov 		dev_refl(dev);
66598c469d4SPoul-Henning Kamp 	if (dev->si_flags & SI_CHEAPCLONE &&
666e606a3c6SPoul-Henning Kamp 	    dev->si_flags & SI_NAMED) {
66798c469d4SPoul-Henning Kamp 		/*
66898c469d4SPoul-Henning Kamp 		 * This is allowed as it removes races and generally
66998c469d4SPoul-Henning Kamp 		 * simplifies cloning devices.
670cd690b60SPoul-Henning Kamp 		 * XXX: still ??
67198c469d4SPoul-Henning Kamp 		 */
6729bc911d4SKonstantin Belousov 		dev_unlock_and_free();
67398c469d4SPoul-Henning Kamp 		return (dev);
67498c469d4SPoul-Henning Kamp 	}
675cd690b60SPoul-Henning Kamp 	KASSERT(!(dev->si_flags & SI_NAMED),
676ff7284eeSPoul-Henning Kamp 	    ("make_dev() by driver %s on pre-existing device (min=%x, name=%s)",
6776bfa9a2dSEd Schouten 	    devsw->d_name, dev2unit(dev), devtoname(dev)));
678cd690b60SPoul-Henning Kamp 
6796334a663SPoul-Henning Kamp 	i = vsnrprintf(dev->__si_namebuf, sizeof dev->__si_namebuf, 32, fmt, ap);
6806334a663SPoul-Henning Kamp 	if (i > (sizeof dev->__si_namebuf - 1)) {
6812e4db7cfSPawel Jakub Dawidek 		printf("WARNING: Device name truncated! (%s)\n",
6826334a663SPoul-Henning Kamp 		    dev->__si_namebuf);
6836334a663SPoul-Henning Kamp 	}
6841a1b2800SPoul-Henning Kamp 
6855ef2707eSPoul-Henning Kamp 	dev->si_flags |= SI_NAMED;
686d26dd2d9SRobert Watson 	if (cr != NULL)
687d26dd2d9SRobert Watson 		dev->si_cred = crhold(cr);
688d26dd2d9SRobert Watson 	else
689d26dd2d9SRobert Watson 		dev->si_cred = NULL;
6909477d73eSPoul-Henning Kamp 	dev->si_uid = uid;
6919477d73eSPoul-Henning Kamp 	dev->si_gid = gid;
6929477d73eSPoul-Henning Kamp 	dev->si_mode = mode;
6931744fcd0SJulian Elischer 
6949285a87eSPoul-Henning Kamp 	devfs_create(dev);
69509828ba9SKonstantin Belousov 	clean_unrhdrl(devfs_inos);
696aeeb4202SKonstantin Belousov 	dev_unlock_and_free();
69748504cc2SKonstantin Belousov 
69848504cc2SKonstantin Belousov 	notify_create(dev);
69948504cc2SKonstantin Belousov 
7003f54a085SPoul-Henning Kamp 	return (dev);
7013f54a085SPoul-Henning Kamp }
7023f54a085SPoul-Henning Kamp 
703d26dd2d9SRobert Watson struct cdev *
704edde8745SEd Schouten make_dev(struct cdevsw *devsw, int unit, uid_t uid, gid_t gid, int mode,
705d26dd2d9SRobert Watson     const char *fmt, ...)
706d26dd2d9SRobert Watson {
707d26dd2d9SRobert Watson 	struct cdev *dev;
708d26dd2d9SRobert Watson 	va_list ap;
709d26dd2d9SRobert Watson 
710d26dd2d9SRobert Watson 	va_start(ap, fmt);
711edde8745SEd Schouten 	dev = make_dev_credv(0, devsw, unit, NULL, uid, gid, mode, fmt, ap);
712d26dd2d9SRobert Watson 	va_end(ap);
713d26dd2d9SRobert Watson 	return (dev);
714d26dd2d9SRobert Watson }
715d26dd2d9SRobert Watson 
716d26dd2d9SRobert Watson struct cdev *
717edde8745SEd Schouten make_dev_cred(struct cdevsw *devsw, int unit, struct ucred *cr, uid_t uid,
718d26dd2d9SRobert Watson     gid_t gid, int mode, const char *fmt, ...)
719d26dd2d9SRobert Watson {
720d26dd2d9SRobert Watson 	struct cdev *dev;
721d26dd2d9SRobert Watson 	va_list ap;
722d26dd2d9SRobert Watson 
723d26dd2d9SRobert Watson 	va_start(ap, fmt);
724edde8745SEd Schouten 	dev = make_dev_credv(0, devsw, unit, cr, uid, gid, mode, fmt, ap);
725de10ffa5SKonstantin Belousov 	va_end(ap);
726de10ffa5SKonstantin Belousov 
727de10ffa5SKonstantin Belousov 	return (dev);
728de10ffa5SKonstantin Belousov }
729de10ffa5SKonstantin Belousov 
730de10ffa5SKonstantin Belousov struct cdev *
731edde8745SEd Schouten make_dev_credf(int flags, struct cdevsw *devsw, int unit,
732de10ffa5SKonstantin Belousov     struct ucred *cr, uid_t uid,
733de10ffa5SKonstantin Belousov     gid_t gid, int mode, const char *fmt, ...)
734de10ffa5SKonstantin Belousov {
735de10ffa5SKonstantin Belousov 	struct cdev *dev;
736de10ffa5SKonstantin Belousov 	va_list ap;
737de10ffa5SKonstantin Belousov 
738de10ffa5SKonstantin Belousov 	va_start(ap, fmt);
739edde8745SEd Schouten 	dev = make_dev_credv(flags, devsw, unit, cr, uid, gid, mode,
740de10ffa5SKonstantin Belousov 	    fmt, ap);
741d26dd2d9SRobert Watson 	va_end(ap);
742d26dd2d9SRobert Watson 
743d26dd2d9SRobert Watson 	return (dev);
744d26dd2d9SRobert Watson }
745d26dd2d9SRobert Watson 
746e606a3c6SPoul-Henning Kamp static void
747e606a3c6SPoul-Henning Kamp dev_dependsl(struct cdev *pdev, struct cdev *cdev)
748e606a3c6SPoul-Henning Kamp {
749e606a3c6SPoul-Henning Kamp 
750e606a3c6SPoul-Henning Kamp 	cdev->si_parent = pdev;
751e606a3c6SPoul-Henning Kamp 	cdev->si_flags |= SI_CHILD;
752e606a3c6SPoul-Henning Kamp 	LIST_INSERT_HEAD(&pdev->si_children, cdev, si_siblings);
753e606a3c6SPoul-Henning Kamp }
754e606a3c6SPoul-Henning Kamp 
755e606a3c6SPoul-Henning Kamp 
7563344c5a1SPoul-Henning Kamp void
75789c9c53dSPoul-Henning Kamp dev_depends(struct cdev *pdev, struct cdev *cdev)
7583344c5a1SPoul-Henning Kamp {
7593344c5a1SPoul-Henning Kamp 
760a0e78d2eSPoul-Henning Kamp 	dev_lock();
761e606a3c6SPoul-Henning Kamp 	dev_dependsl(pdev, cdev);
762a0e78d2eSPoul-Henning Kamp 	dev_unlock();
7633344c5a1SPoul-Henning Kamp }
7643344c5a1SPoul-Henning Kamp 
76589c9c53dSPoul-Henning Kamp struct cdev *
76689c9c53dSPoul-Henning Kamp make_dev_alias(struct cdev *pdev, const char *fmt, ...)
7673f54a085SPoul-Henning Kamp {
76889c9c53dSPoul-Henning Kamp 	struct cdev *dev;
7693f54a085SPoul-Henning Kamp 	va_list ap;
7703f54a085SPoul-Henning Kamp 	int i;
7713f54a085SPoul-Henning Kamp 
772ae95dc62SKonstantin Belousov 	KASSERT(pdev != NULL, ("NULL pdev"));
773e606a3c6SPoul-Henning Kamp 	dev = devfs_alloc();
774a0e78d2eSPoul-Henning Kamp 	dev_lock();
7753f54a085SPoul-Henning Kamp 	dev->si_flags |= SI_ALIAS;
7765ef2707eSPoul-Henning Kamp 	dev->si_flags |= SI_NAMED;
7773f54a085SPoul-Henning Kamp 	va_start(ap, fmt);
7786334a663SPoul-Henning Kamp 	i = vsnrprintf(dev->__si_namebuf, sizeof dev->__si_namebuf, 32, fmt, ap);
7796334a663SPoul-Henning Kamp 	if (i > (sizeof dev->__si_namebuf - 1)) {
7802e4db7cfSPawel Jakub Dawidek 		printf("WARNING: Device name truncated! (%s)\n",
7816334a663SPoul-Henning Kamp 		    dev->__si_namebuf);
7826334a663SPoul-Henning Kamp 	}
7833f54a085SPoul-Henning Kamp 	va_end(ap);
7843f54a085SPoul-Henning Kamp 
7859285a87eSPoul-Henning Kamp 	devfs_create(dev);
786ae95dc62SKonstantin Belousov 	dev_dependsl(pdev, dev);
78709828ba9SKonstantin Belousov 	clean_unrhdrl(devfs_inos);
788a0e78d2eSPoul-Henning Kamp 	dev_unlock();
78948504cc2SKonstantin Belousov 
79048504cc2SKonstantin Belousov 	notify_create(dev);
79148504cc2SKonstantin Belousov 
7920ef1c826SPoul-Henning Kamp 	return (dev);
7930ef1c826SPoul-Henning Kamp }
7940ef1c826SPoul-Henning Kamp 
795cd690b60SPoul-Henning Kamp static void
796aa2f6ddcSPoul-Henning Kamp destroy_devl(struct cdev *dev)
797d137acccSPoul-Henning Kamp {
798743cd76aSPoul-Henning Kamp 	struct cdevsw *csw;
79982f4d640SKonstantin Belousov 	struct cdev_privdata *p, *p1;
800743cd76aSPoul-Henning Kamp 
801aa2f6ddcSPoul-Henning Kamp 	mtx_assert(&devmtx, MA_OWNED);
802743cd76aSPoul-Henning Kamp 	KASSERT(dev->si_flags & SI_NAMED,
8036bfa9a2dSEd Schouten 	    ("WARNING: Driver mistake: destroy_dev on %d\n", dev2unit(dev)));
8045ef2707eSPoul-Henning Kamp 
8059285a87eSPoul-Henning Kamp 	devfs_destroy(dev);
806cd690b60SPoul-Henning Kamp 
807cd690b60SPoul-Henning Kamp 	/* Remove name marking */
808b0b03348SPoul-Henning Kamp 	dev->si_flags &= ~SI_NAMED;
809b0b03348SPoul-Henning Kamp 
810cd690b60SPoul-Henning Kamp 	/* If we are a child, remove us from the parents list */
8113344c5a1SPoul-Henning Kamp 	if (dev->si_flags & SI_CHILD) {
8123344c5a1SPoul-Henning Kamp 		LIST_REMOVE(dev, si_siblings);
8133344c5a1SPoul-Henning Kamp 		dev->si_flags &= ~SI_CHILD;
8143344c5a1SPoul-Henning Kamp 	}
815cd690b60SPoul-Henning Kamp 
816cd690b60SPoul-Henning Kamp 	/* Kill our children */
8173344c5a1SPoul-Henning Kamp 	while (!LIST_EMPTY(&dev->si_children))
818aa2f6ddcSPoul-Henning Kamp 		destroy_devl(LIST_FIRST(&dev->si_children));
819cd690b60SPoul-Henning Kamp 
820cd690b60SPoul-Henning Kamp 	/* Remove from clone list */
821b0b03348SPoul-Henning Kamp 	if (dev->si_flags & SI_CLONELIST) {
822b0b03348SPoul-Henning Kamp 		LIST_REMOVE(dev, si_clone);
823b0b03348SPoul-Henning Kamp 		dev->si_flags &= ~SI_CLONELIST;
824b0b03348SPoul-Henning Kamp 	}
825cd690b60SPoul-Henning Kamp 
826e0c33ad5STor Egge 	dev->si_refcount++;	/* Avoid race with dev_rel() */
827743cd76aSPoul-Henning Kamp 	csw = dev->si_devsw;
8281abf2c36SBrian Feldman 	dev->si_devsw = NULL;	/* already NULL for SI_ALIAS */
8291abf2c36SBrian Feldman 	while (csw != NULL && csw->d_purge != NULL && dev->si_threadcount) {
830743cd76aSPoul-Henning Kamp 		csw->d_purge(dev);
831743cd76aSPoul-Henning Kamp 		msleep(csw, &devmtx, PRIBIO, "devprg", hz/10);
832d595182fSPoul-Henning Kamp 		if (dev->si_threadcount)
833d595182fSPoul-Henning Kamp 			printf("Still %lu threads in %s\n",
834d595182fSPoul-Henning Kamp 			    dev->si_threadcount, devtoname(dev));
835743cd76aSPoul-Henning Kamp 	}
836e0c33ad5STor Egge 	while (dev->si_threadcount != 0) {
837e0c33ad5STor Egge 		/* Use unique dummy wait ident */
838e0c33ad5STor Egge 		msleep(&csw, &devmtx, PRIBIO, "devdrn", hz / 10);
839e0c33ad5STor Egge 	}
840743cd76aSPoul-Henning Kamp 
84182f4d640SKonstantin Belousov 	dev_unlock();
84248504cc2SKonstantin Belousov 	notify_destroy(dev);
84382f4d640SKonstantin Belousov 	mtx_lock(&cdevpriv_mtx);
84405427aafSKonstantin Belousov 	LIST_FOREACH_SAFE(p, &cdev2priv(dev)->cdp_fdpriv, cdpd_list, p1) {
84582f4d640SKonstantin Belousov 		devfs_destroy_cdevpriv(p);
84682f4d640SKonstantin Belousov 		mtx_lock(&cdevpriv_mtx);
84782f4d640SKonstantin Belousov 	}
84882f4d640SKonstantin Belousov 	mtx_unlock(&cdevpriv_mtx);
84982f4d640SKonstantin Belousov 	dev_lock();
85048504cc2SKonstantin Belousov 
851743cd76aSPoul-Henning Kamp 	dev->si_drv1 = 0;
852743cd76aSPoul-Henning Kamp 	dev->si_drv2 = 0;
853743cd76aSPoul-Henning Kamp 	bzero(&dev->__si_u, sizeof(dev->__si_u));
854743cd76aSPoul-Henning Kamp 
855cd690b60SPoul-Henning Kamp 	if (!(dev->si_flags & SI_ALIAS)) {
856cd690b60SPoul-Henning Kamp 		/* Remove from cdevsw list */
857cd690b60SPoul-Henning Kamp 		LIST_REMOVE(dev, si_list);
858cd690b60SPoul-Henning Kamp 
859e606a3c6SPoul-Henning Kamp 		/* If cdevsw has no more struct cdev *'s, clean it */
860de10ffa5SKonstantin Belousov 		if (LIST_EMPTY(&csw->d_devs)) {
861a5993c33SPoul-Henning Kamp 			fini_cdevsw(csw);
862de10ffa5SKonstantin Belousov 			wakeup(&csw->d_devs);
863de10ffa5SKonstantin Belousov 		}
864cd690b60SPoul-Henning Kamp 	}
8655ef2707eSPoul-Henning Kamp 	dev->si_flags &= ~SI_ALIAS;
866e0c33ad5STor Egge 	dev->si_refcount--;	/* Avoid race with dev_rel() */
867743cd76aSPoul-Henning Kamp 
868cd690b60SPoul-Henning Kamp 	if (dev->si_refcount > 0) {
869cd690b60SPoul-Henning Kamp 		LIST_INSERT_HEAD(&dead_cdevsw.d_devs, dev, si_list);
870cd690b60SPoul-Henning Kamp 	} else {
8719bc911d4SKonstantin Belousov 		dev_free_devlocked(dev);
872d137acccSPoul-Henning Kamp 	}
873cd690b60SPoul-Henning Kamp }
874cd690b60SPoul-Henning Kamp 
875cd690b60SPoul-Henning Kamp void
87689c9c53dSPoul-Henning Kamp destroy_dev(struct cdev *dev)
877cd690b60SPoul-Henning Kamp {
878cd690b60SPoul-Henning Kamp 
879a0e78d2eSPoul-Henning Kamp 	dev_lock();
880aa2f6ddcSPoul-Henning Kamp 	destroy_devl(dev);
8819bc911d4SKonstantin Belousov 	dev_unlock_and_free();
882cd690b60SPoul-Henning Kamp }
883d137acccSPoul-Henning Kamp 
884c32cc149SBruce Evans const char *
88589c9c53dSPoul-Henning Kamp devtoname(struct cdev *dev)
886b8e49f68SBill Fumerola {
887d137acccSPoul-Henning Kamp 	char *p;
8888ff33adbSPoul-Henning Kamp 	struct cdevsw *csw;
889c32cc149SBruce Evans 	int mynor;
890b8e49f68SBill Fumerola 
891d137acccSPoul-Henning Kamp 	if (dev->si_name[0] == '#' || dev->si_name[0] == '\0') {
892d137acccSPoul-Henning Kamp 		p = dev->si_name;
8938ff33adbSPoul-Henning Kamp 		csw = dev_refthread(dev);
8948ff33adbSPoul-Henning Kamp 		if (csw != NULL) {
8958ff33adbSPoul-Henning Kamp 			sprintf(p, "(%s)", csw->d_name);
8968ff33adbSPoul-Henning Kamp 			dev_relthread(dev);
8978ff33adbSPoul-Henning Kamp 		}
898d137acccSPoul-Henning Kamp 		p += strlen(p);
8996bfa9a2dSEd Schouten 		mynor = dev2unit(dev);
900c32cc149SBruce Evans 		if (mynor < 0 || mynor > 255)
9018ff33adbSPoul-Henning Kamp 			sprintf(p, "/%#x", (u_int)mynor);
902c32cc149SBruce Evans 		else
9038ff33adbSPoul-Henning Kamp 			sprintf(p, "/%d", mynor);
904d137acccSPoul-Henning Kamp 	}
905b8e49f68SBill Fumerola 	return (dev->si_name);
906b8e49f68SBill Fumerola }
907db901281SPoul-Henning Kamp 
908db901281SPoul-Henning Kamp int
90901de1b13SPoul-Henning Kamp dev_stdclone(char *name, char **namep, const char *stem, int *unit)
910db901281SPoul-Henning Kamp {
911db901281SPoul-Henning Kamp 	int u, i;
912db901281SPoul-Henning Kamp 
913db901281SPoul-Henning Kamp 	i = strlen(stem);
91456700d46SBrian Somers 	if (bcmp(stem, name, i) != 0)
91556700d46SBrian Somers 		return (0);
916db901281SPoul-Henning Kamp 	if (!isdigit(name[i]))
917db901281SPoul-Henning Kamp 		return (0);
918db901281SPoul-Henning Kamp 	u = 0;
91910786074SPoul-Henning Kamp 	if (name[i] == '0' && isdigit(name[i+1]))
92010786074SPoul-Henning Kamp 		return (0);
921db901281SPoul-Henning Kamp 	while (isdigit(name[i])) {
922db901281SPoul-Henning Kamp 		u *= 10;
923db901281SPoul-Henning Kamp 		u += name[i++] - '0';
924db901281SPoul-Henning Kamp 	}
925dab3d85fSBrian Feldman 	if (u > 0xffffff)
926dab3d85fSBrian Feldman 		return (0);
927db901281SPoul-Henning Kamp 	*unit = u;
928db901281SPoul-Henning Kamp 	if (namep)
929db901281SPoul-Henning Kamp 		*namep = &name[i];
930db901281SPoul-Henning Kamp 	if (name[i])
931db901281SPoul-Henning Kamp 		return (2);
932db901281SPoul-Henning Kamp 	return (1);
933db901281SPoul-Henning Kamp }
9348d25eb2cSPoul-Henning Kamp 
9358d25eb2cSPoul-Henning Kamp /*
936b0b03348SPoul-Henning Kamp  * Helper functions for cloning device drivers.
937b0b03348SPoul-Henning Kamp  *
938b0b03348SPoul-Henning Kamp  * The objective here is to make it unnecessary for the device drivers to
939b0b03348SPoul-Henning Kamp  * use rman or similar to manage their unit number space.  Due to the way
940b0b03348SPoul-Henning Kamp  * we do "on-demand" devices, using rman or other "private" methods
941b0b03348SPoul-Henning Kamp  * will be very tricky to lock down properly once we lock down this file.
942b0b03348SPoul-Henning Kamp  *
9439a98ae94SLukas Ertl  * Instead we give the drivers these routines which puts the struct cdev *'s
9449a98ae94SLukas Ertl  * that are to be managed on their own list, and gives the driver the ability
945b0b03348SPoul-Henning Kamp  * to ask for the first free unit number or a given specified unit number.
946b0b03348SPoul-Henning Kamp  *
947b0b03348SPoul-Henning Kamp  * In addition these routines support paired devices (pty, nmdm and similar)
948b0b03348SPoul-Henning Kamp  * by respecting a number of "flag" bits in the minor number.
949b0b03348SPoul-Henning Kamp  *
950b0b03348SPoul-Henning Kamp  */
951b0b03348SPoul-Henning Kamp 
952b0b03348SPoul-Henning Kamp struct clonedevs {
953b0b03348SPoul-Henning Kamp 	LIST_HEAD(,cdev)	head;
954b0b03348SPoul-Henning Kamp };
955b0b03348SPoul-Henning Kamp 
9569397290eSPoul-Henning Kamp void
9579397290eSPoul-Henning Kamp clone_setup(struct clonedevs **cdp)
9589397290eSPoul-Henning Kamp {
9599397290eSPoul-Henning Kamp 
9609397290eSPoul-Henning Kamp 	*cdp = malloc(sizeof **cdp, M_DEVBUF, M_WAITOK | M_ZERO);
9619397290eSPoul-Henning Kamp 	LIST_INIT(&(*cdp)->head);
9629397290eSPoul-Henning Kamp }
9639397290eSPoul-Henning Kamp 
964b0b03348SPoul-Henning Kamp int
965217f71d8SBruce M Simpson clone_create(struct clonedevs **cdp, struct cdevsw *csw, int *up, struct cdev **dp, int extra)
966b0b03348SPoul-Henning Kamp {
967b0b03348SPoul-Henning Kamp 	struct clonedevs *cd;
968027b1f71SPoul-Henning Kamp 	struct cdev *dev, *ndev, *dl, *de;
969b0b03348SPoul-Henning Kamp 	int unit, low, u;
970b0b03348SPoul-Henning Kamp 
9719397290eSPoul-Henning Kamp 	KASSERT(*cdp != NULL,
9729397290eSPoul-Henning Kamp 	    ("clone_setup() not called in driver \"%s\"", csw->d_name));
973b0b03348SPoul-Henning Kamp 	KASSERT(!(extra & CLONE_UNITMASK),
974b0b03348SPoul-Henning Kamp 	    ("Illegal extra bits (0x%x) in clone_create", extra));
975b0b03348SPoul-Henning Kamp 	KASSERT(*up <= CLONE_UNITMASK,
976b0b03348SPoul-Henning Kamp 	    ("Too high unit (0x%x) in clone_create", *up));
97729d4cb24SEd Schouten 	KASSERT(csw->d_flags & D_NEEDMINOR,
97829d4cb24SEd Schouten 	    ("clone_create() on cdevsw without minor numbers"));
979b0b03348SPoul-Henning Kamp 
980b0b03348SPoul-Henning Kamp 
981b0b03348SPoul-Henning Kamp 	/*
982b0b03348SPoul-Henning Kamp 	 * Search the list for a lot of things in one go:
983b0b03348SPoul-Henning Kamp 	 *   A preexisting match is returned immediately.
984b0b03348SPoul-Henning Kamp 	 *   The lowest free unit number if we are passed -1, and the place
985b0b03348SPoul-Henning Kamp 	 *	 in the list where we should insert that new element.
986b0b03348SPoul-Henning Kamp 	 *   The place to insert a specified unit number, if applicable
987b0b03348SPoul-Henning Kamp 	 *       the end of the list.
988b0b03348SPoul-Henning Kamp 	 */
989b0b03348SPoul-Henning Kamp 	unit = *up;
990e606a3c6SPoul-Henning Kamp 	ndev = devfs_alloc();
991027b1f71SPoul-Henning Kamp 	dev_lock();
992aeeb4202SKonstantin Belousov 	prep_cdevsw(csw);
9938666b655SPoul-Henning Kamp 	low = extra;
994b0b03348SPoul-Henning Kamp 	de = dl = NULL;
9959397290eSPoul-Henning Kamp 	cd = *cdp;
996b0b03348SPoul-Henning Kamp 	LIST_FOREACH(dev, &cd->head, si_clone) {
997027b1f71SPoul-Henning Kamp 		KASSERT(dev->si_flags & SI_CLONELIST,
998027b1f71SPoul-Henning Kamp 		    ("Dev %p(%s) should be on clonelist", dev, dev->si_name));
999b0b03348SPoul-Henning Kamp 		u = dev2unit(dev);
1000b0b03348SPoul-Henning Kamp 		if (u == (unit | extra)) {
1001b0b03348SPoul-Henning Kamp 			*dp = dev;
1002027b1f71SPoul-Henning Kamp 			dev_unlock();
10039bc911d4SKonstantin Belousov 			devfs_free(ndev);
1004b0b03348SPoul-Henning Kamp 			return (0);
1005b0b03348SPoul-Henning Kamp 		}
1006b0b03348SPoul-Henning Kamp 		if (unit == -1 && u == low) {
1007b0b03348SPoul-Henning Kamp 			low++;
1008b0b03348SPoul-Henning Kamp 			de = dev;
1009b0b03348SPoul-Henning Kamp 			continue;
10107bbb3a26SPoul-Henning Kamp 		} else if (u < (unit | extra)) {
10117bbb3a26SPoul-Henning Kamp 			de = dev;
10127bbb3a26SPoul-Henning Kamp 			continue;
10137bbb3a26SPoul-Henning Kamp 		} else if (u > (unit | extra)) {
1014b0b03348SPoul-Henning Kamp 			dl = dev;
1015b0b03348SPoul-Henning Kamp 			break;
1016b0b03348SPoul-Henning Kamp 		}
1017b0b03348SPoul-Henning Kamp 	}
1018b0b03348SPoul-Henning Kamp 	if (unit == -1)
10198666b655SPoul-Henning Kamp 		unit = low & CLONE_UNITMASK;
1020d3ce8327SEd Schouten 	dev = newdev(csw, unit | extra, ndev);
1021027b1f71SPoul-Henning Kamp 	if (dev->si_flags & SI_CLONELIST) {
1022027b1f71SPoul-Henning Kamp 		printf("dev %p (%s) is on clonelist\n", dev, dev->si_name);
10237bbb3a26SPoul-Henning Kamp 		printf("unit=%d, low=%d, extra=0x%x\n", unit, low, extra);
1024027b1f71SPoul-Henning Kamp 		LIST_FOREACH(dev, &cd->head, si_clone) {
1025027b1f71SPoul-Henning Kamp 			printf("\t%p %s\n", dev, dev->si_name);
1026027b1f71SPoul-Henning Kamp 		}
1027027b1f71SPoul-Henning Kamp 		panic("foo");
1028027b1f71SPoul-Henning Kamp 	}
1029b0b03348SPoul-Henning Kamp 	KASSERT(!(dev->si_flags & SI_CLONELIST),
1030027b1f71SPoul-Henning Kamp 	    ("Dev %p(%s) should not be on clonelist", dev, dev->si_name));
1031b0b03348SPoul-Henning Kamp 	if (dl != NULL)
1032b0b03348SPoul-Henning Kamp 		LIST_INSERT_BEFORE(dl, dev, si_clone);
1033b0b03348SPoul-Henning Kamp 	else if (de != NULL)
1034b0b03348SPoul-Henning Kamp 		LIST_INSERT_AFTER(de, dev, si_clone);
1035b0b03348SPoul-Henning Kamp 	else
1036b0b03348SPoul-Henning Kamp 		LIST_INSERT_HEAD(&cd->head, dev, si_clone);
1037b0b03348SPoul-Henning Kamp 	dev->si_flags |= SI_CLONELIST;
1038b0b03348SPoul-Henning Kamp 	*up = unit;
10399bc911d4SKonstantin Belousov 	dev_unlock_and_free();
1040b0b03348SPoul-Henning Kamp 	return (1);
1041b0b03348SPoul-Henning Kamp }
1042b0b03348SPoul-Henning Kamp 
1043b0b03348SPoul-Henning Kamp /*
1044b0b03348SPoul-Henning Kamp  * Kill everything still on the list.  The driver should already have
104589c9c53dSPoul-Henning Kamp  * disposed of any softc hung of the struct cdev *'s at this time.
1046b0b03348SPoul-Henning Kamp  */
1047b0b03348SPoul-Henning Kamp void
1048b0b03348SPoul-Henning Kamp clone_cleanup(struct clonedevs **cdp)
1049b0b03348SPoul-Henning Kamp {
1050de10ffa5SKonstantin Belousov 	struct cdev *dev;
1051de10ffa5SKonstantin Belousov 	struct cdev_priv *cp;
1052b0b03348SPoul-Henning Kamp 	struct clonedevs *cd;
1053b0b03348SPoul-Henning Kamp 
1054b0b03348SPoul-Henning Kamp 	cd = *cdp;
1055b0b03348SPoul-Henning Kamp 	if (cd == NULL)
1056b0b03348SPoul-Henning Kamp 		return;
1057027b1f71SPoul-Henning Kamp 	dev_lock();
1058de10ffa5SKonstantin Belousov 	while (!LIST_EMPTY(&cd->head)) {
1059de10ffa5SKonstantin Belousov 		dev = LIST_FIRST(&cd->head);
1060de10ffa5SKonstantin Belousov 		LIST_REMOVE(dev, si_clone);
1061027b1f71SPoul-Henning Kamp 		KASSERT(dev->si_flags & SI_CLONELIST,
1062027b1f71SPoul-Henning Kamp 		    ("Dev %p(%s) should be on clonelist", dev, dev->si_name));
1063de10ffa5SKonstantin Belousov 		dev->si_flags &= ~SI_CLONELIST;
106405427aafSKonstantin Belousov 		cp = cdev2priv(dev);
1065de10ffa5SKonstantin Belousov 		if (!(cp->cdp_flags & CDP_SCHED_DTR)) {
1066de10ffa5SKonstantin Belousov 			cp->cdp_flags |= CDP_SCHED_DTR;
1067b0b03348SPoul-Henning Kamp 			KASSERT(dev->si_flags & SI_NAMED,
10680a2e49f1SPoul-Henning Kamp 				("Driver has goofed in cloning underways udev %x", dev->si_drv0));
1069aa2f6ddcSPoul-Henning Kamp 			destroy_devl(dev);
1070b0b03348SPoul-Henning Kamp 		}
1071de10ffa5SKonstantin Belousov 	}
1072aeeb4202SKonstantin Belousov 	dev_unlock_and_free();
1073b0b03348SPoul-Henning Kamp 	free(cd, M_DEVBUF);
1074b0b03348SPoul-Henning Kamp 	*cdp = NULL;
1075b0b03348SPoul-Henning Kamp }
1076de10ffa5SKonstantin Belousov 
1077de10ffa5SKonstantin Belousov static TAILQ_HEAD(, cdev_priv) dev_ddtr =
1078de10ffa5SKonstantin Belousov 	TAILQ_HEAD_INITIALIZER(dev_ddtr);
1079de10ffa5SKonstantin Belousov static struct task dev_dtr_task;
1080de10ffa5SKonstantin Belousov 
1081de10ffa5SKonstantin Belousov static void
1082de10ffa5SKonstantin Belousov destroy_dev_tq(void *ctx, int pending)
1083de10ffa5SKonstantin Belousov {
1084de10ffa5SKonstantin Belousov 	struct cdev_priv *cp;
1085de10ffa5SKonstantin Belousov 	struct cdev *dev;
1086de10ffa5SKonstantin Belousov 	void (*cb)(void *);
1087de10ffa5SKonstantin Belousov 	void *cb_arg;
1088de10ffa5SKonstantin Belousov 
1089de10ffa5SKonstantin Belousov 	dev_lock();
1090de10ffa5SKonstantin Belousov 	while (!TAILQ_EMPTY(&dev_ddtr)) {
1091de10ffa5SKonstantin Belousov 		cp = TAILQ_FIRST(&dev_ddtr);
1092de10ffa5SKonstantin Belousov 		dev = &cp->cdp_c;
1093de10ffa5SKonstantin Belousov 		KASSERT(cp->cdp_flags & CDP_SCHED_DTR,
1094de10ffa5SKonstantin Belousov 		    ("cdev %p in dev_destroy_tq without CDP_SCHED_DTR", cp));
1095de10ffa5SKonstantin Belousov 		TAILQ_REMOVE(&dev_ddtr, cp, cdp_dtr_list);
1096de10ffa5SKonstantin Belousov 		cb = cp->cdp_dtr_cb;
1097de10ffa5SKonstantin Belousov 		cb_arg = cp->cdp_dtr_cb_arg;
1098de10ffa5SKonstantin Belousov 		destroy_devl(dev);
1099aeeb4202SKonstantin Belousov 		dev_unlock_and_free();
1100de10ffa5SKonstantin Belousov 		dev_rel(dev);
1101de10ffa5SKonstantin Belousov 		if (cb != NULL)
1102de10ffa5SKonstantin Belousov 			cb(cb_arg);
1103de10ffa5SKonstantin Belousov 		dev_lock();
1104de10ffa5SKonstantin Belousov 	}
1105de10ffa5SKonstantin Belousov 	dev_unlock();
1106de10ffa5SKonstantin Belousov }
1107de10ffa5SKonstantin Belousov 
11089d53363bSKonstantin Belousov /*
11099d53363bSKonstantin Belousov  * devmtx shall be locked on entry. devmtx will be unlocked after
11109d53363bSKonstantin Belousov  * function return.
11119d53363bSKonstantin Belousov  */
11129d53363bSKonstantin Belousov static int
11139d53363bSKonstantin Belousov destroy_dev_sched_cbl(struct cdev *dev, void (*cb)(void *), void *arg)
1114de10ffa5SKonstantin Belousov {
1115de10ffa5SKonstantin Belousov 	struct cdev_priv *cp;
1116de10ffa5SKonstantin Belousov 
11179d53363bSKonstantin Belousov 	mtx_assert(&devmtx, MA_OWNED);
111805427aafSKonstantin Belousov 	cp = cdev2priv(dev);
1119de10ffa5SKonstantin Belousov 	if (cp->cdp_flags & CDP_SCHED_DTR) {
1120de10ffa5SKonstantin Belousov 		dev_unlock();
1121de10ffa5SKonstantin Belousov 		return (0);
1122de10ffa5SKonstantin Belousov 	}
1123de10ffa5SKonstantin Belousov 	dev_refl(dev);
1124de10ffa5SKonstantin Belousov 	cp->cdp_flags |= CDP_SCHED_DTR;
1125de10ffa5SKonstantin Belousov 	cp->cdp_dtr_cb = cb;
1126de10ffa5SKonstantin Belousov 	cp->cdp_dtr_cb_arg = arg;
1127de10ffa5SKonstantin Belousov 	TAILQ_INSERT_TAIL(&dev_ddtr, cp, cdp_dtr_list);
1128de10ffa5SKonstantin Belousov 	dev_unlock();
1129de10ffa5SKonstantin Belousov 	taskqueue_enqueue(taskqueue_swi_giant, &dev_dtr_task);
1130de10ffa5SKonstantin Belousov 	return (1);
1131de10ffa5SKonstantin Belousov }
1132de10ffa5SKonstantin Belousov 
1133de10ffa5SKonstantin Belousov int
11349d53363bSKonstantin Belousov destroy_dev_sched_cb(struct cdev *dev, void (*cb)(void *), void *arg)
11359d53363bSKonstantin Belousov {
11369d53363bSKonstantin Belousov 	dev_lock();
11379d53363bSKonstantin Belousov 	return (destroy_dev_sched_cbl(dev, cb, arg));
11389d53363bSKonstantin Belousov }
11399d53363bSKonstantin Belousov 
11409d53363bSKonstantin Belousov int
1141de10ffa5SKonstantin Belousov destroy_dev_sched(struct cdev *dev)
1142de10ffa5SKonstantin Belousov {
1143de10ffa5SKonstantin Belousov 	return (destroy_dev_sched_cb(dev, NULL, NULL));
1144de10ffa5SKonstantin Belousov }
1145de10ffa5SKonstantin Belousov 
1146de10ffa5SKonstantin Belousov void
1147de10ffa5SKonstantin Belousov destroy_dev_drain(struct cdevsw *csw)
1148de10ffa5SKonstantin Belousov {
1149de10ffa5SKonstantin Belousov 
1150de10ffa5SKonstantin Belousov 	dev_lock();
1151de10ffa5SKonstantin Belousov 	while (!LIST_EMPTY(&csw->d_devs)) {
1152de10ffa5SKonstantin Belousov 		msleep(&csw->d_devs, &devmtx, PRIBIO, "devscd", hz/10);
1153de10ffa5SKonstantin Belousov 	}
1154de10ffa5SKonstantin Belousov 	dev_unlock();
1155de10ffa5SKonstantin Belousov }
1156de10ffa5SKonstantin Belousov 
1157de10ffa5SKonstantin Belousov void
1158de10ffa5SKonstantin Belousov drain_dev_clone_events(void)
1159de10ffa5SKonstantin Belousov {
1160de10ffa5SKonstantin Belousov 
1161de10ffa5SKonstantin Belousov 	sx_xlock(&clone_drain_lock);
1162de10ffa5SKonstantin Belousov 	sx_xunlock(&clone_drain_lock);
1163de10ffa5SKonstantin Belousov }
1164de10ffa5SKonstantin Belousov 
1165de10ffa5SKonstantin Belousov static void
1166de10ffa5SKonstantin Belousov devdtr_init(void *dummy __unused)
1167de10ffa5SKonstantin Belousov {
1168de10ffa5SKonstantin Belousov 
1169de10ffa5SKonstantin Belousov 	TASK_INIT(&dev_dtr_task, 0, destroy_dev_tq, NULL);
1170de10ffa5SKonstantin Belousov }
1171de10ffa5SKonstantin Belousov 
1172de10ffa5SKonstantin Belousov SYSINIT(devdtr, SI_SUB_DEVFS, SI_ORDER_SECOND, devdtr_init, NULL);
1173