geom_dev.c revision 308061 
1/*-
2 * Copyright (c) 2002 Poul-Henning Kamp
3 * Copyright (c) 2002 Networks Associates Technology, Inc.
4 * All rights reserved.
5 *
6 * This software was developed for the FreeBSD Project by Poul-Henning Kamp
7 * and NAI Labs, the Security Research Division of Network Associates, Inc.
8 * under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as part of the
9 * DARPA CHATS research program.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 *    notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 *    notice, this list of conditions and the following disclaimer in the
18 *    documentation and/or other materials provided with the distribution.
19 * 3. The names of the authors may not be used to endorse or promote
20 *    products derived from this software without specific prior written
21 *    permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * SUCH DAMAGE.
34 */
35
36#include <sys/cdefs.h>
37__FBSDID("$FreeBSD: stable/10/sys/geom/geom_dev.c 308061 2016-10-28 18:25:32Z mav $");
38
39#include <sys/param.h>
40#include <sys/systm.h>
41#include <sys/malloc.h>
42#include <sys/kernel.h>
43#include <sys/conf.h>
44#include <sys/ctype.h>
45#include <sys/bio.h>
46#include <sys/bus.h>
47#include <sys/lock.h>
48#include <sys/mutex.h>
49#include <sys/proc.h>
50#include <sys/errno.h>
51#include <sys/time.h>
52#include <sys/disk.h>
53#include <sys/fcntl.h>
54#include <sys/limits.h>
55#include <sys/sysctl.h>
56#include <geom/geom.h>
57#include <geom/geom_int.h>
58#include <machine/stdarg.h>
59
60struct g_dev_softc {
61	struct mtx	 sc_mtx;
62	struct cdev	*sc_dev;
63	struct cdev	*sc_alias;
64	int		 sc_open;
65	int		 sc_active;
66};
67
68static d_open_t		g_dev_open;
69static d_close_t	g_dev_close;
70static d_strategy_t	g_dev_strategy;
71static d_ioctl_t	g_dev_ioctl;
72
73static struct cdevsw g_dev_cdevsw = {
74	.d_version =	D_VERSION,
75	.d_open =	g_dev_open,
76	.d_close =	g_dev_close,
77	.d_read =	physread,
78	.d_write =	physwrite,
79	.d_ioctl =	g_dev_ioctl,
80	.d_strategy =	g_dev_strategy,
81	.d_name =	"g_dev",
82	.d_flags =	D_DISK | D_TRACKCLOSE,
83};
84
85static g_init_t g_dev_init;
86static g_fini_t g_dev_fini;
87static g_taste_t g_dev_taste;
88static g_orphan_t g_dev_orphan;
89static g_attrchanged_t g_dev_attrchanged;
90
91static struct g_class g_dev_class	= {
92	.name = "DEV",
93	.version = G_VERSION,
94	.init = g_dev_init,
95	.fini = g_dev_fini,
96	.taste = g_dev_taste,
97	.orphan = g_dev_orphan,
98	.attrchanged = g_dev_attrchanged
99};
100
101/*
102 * We target 262144 (8 x 32768) sectors by default as this significantly
103 * increases the throughput on commonly used SSD's with a marginal
104 * increase in non-interruptible request latency.
105 */
106static uint64_t g_dev_del_max_sectors = 262144;
107SYSCTL_DECL(_kern_geom);
108SYSCTL_NODE(_kern_geom, OID_AUTO, dev, CTLFLAG_RW, 0, "GEOM_DEV stuff");
109SYSCTL_QUAD(_kern_geom_dev, OID_AUTO, delete_max_sectors, CTLFLAG_RW,
110    &g_dev_del_max_sectors, 0, "Maximum number of sectors in a single "
111    "delete request sent to the provider. Larger requests are chunked "
112    "so they can be interrupted. (0 = disable chunking)");
113
114static char *dumpdev = NULL;
115static void
116g_dev_init(struct g_class *mp)
117{
118
119	dumpdev = getenv("dumpdev");
120}
121
122static void
123g_dev_fini(struct g_class *mp)
124{
125
126	freeenv(dumpdev);
127	dumpdev = NULL;
128}
129
130static int
131g_dev_setdumpdev(struct cdev *dev, struct thread *td)
132{
133	struct g_kerneldump kd;
134	struct g_consumer *cp;
135	int error, len;
136
137	if (dev == NULL)
138		return (set_dumper(NULL, NULL, td));
139
140	cp = dev->si_drv2;
141	len = sizeof(kd);
142	kd.offset = 0;
143	kd.length = OFF_MAX;
144	error = g_io_getattr("GEOM::kerneldump", cp, &len, &kd);
145	if (error == 0) {
146		error = set_dumper(&kd.di, devtoname(dev), td);
147		if (error == 0)
148			dev->si_flags |= SI_DUMPDEV;
149	}
150	return (error);
151}
152
153static int
154init_dumpdev(struct cdev *dev)
155{
156	struct g_consumer *cp;
157	const char *devprefix = "/dev/", *devname;
158	int error;
159	size_t len;
160
161	if (dumpdev == NULL)
162		return (0);
163
164	len = strlen(devprefix);
165	devname = devtoname(dev);
166	if (strcmp(devname, dumpdev) != 0 &&
167	   (strncmp(dumpdev, devprefix, len) != 0 ||
168	    strcmp(devname, dumpdev + len) != 0))
169		return (0);
170
171	cp = (struct g_consumer *)dev->si_drv2;
172	error = g_access(cp, 1, 0, 0);
173	if (error != 0)
174		return (error);
175
176	error = g_dev_setdumpdev(dev, curthread);
177	if (error == 0) {
178		freeenv(dumpdev);
179		dumpdev = NULL;
180	}
181
182	(void)g_access(cp, -1, 0, 0);
183
184	return (error);
185}
186
187static void
188g_dev_destroy(void *arg, int flags __unused)
189{
190	struct g_consumer *cp;
191	struct g_geom *gp;
192	struct g_dev_softc *sc;
193	char buf[SPECNAMELEN + 6];
194
195	g_topology_assert();
196	cp = arg;
197	gp = cp->geom;
198	sc = cp->private;
199	g_trace(G_T_TOPOLOGY, "g_dev_destroy(%p(%s))", cp, gp->name);
200	snprintf(buf, sizeof(buf), "cdev=%s", gp->name);
201	devctl_notify_f("GEOM", "DEV", "DESTROY", buf, M_WAITOK);
202	if (cp->acr > 0 || cp->acw > 0 || cp->ace > 0)
203		g_access(cp, -cp->acr, -cp->acw, -cp->ace);
204	g_detach(cp);
205	g_destroy_consumer(cp);
206	g_destroy_geom(gp);
207	mtx_destroy(&sc->sc_mtx);
208	g_free(sc);
209}
210
211void
212g_dev_print(void)
213{
214	struct g_geom *gp;
215	char const *p = "";
216
217	LIST_FOREACH(gp, &g_dev_class.geom, geom) {
218		printf("%s%s", p, gp->name);
219		p = " ";
220	}
221	printf("\n");
222}
223
224static void
225g_dev_set_physpath(struct g_consumer *cp)
226{
227	struct g_dev_softc *sc;
228	char *physpath;
229	int error, physpath_len;
230
231	if (g_access(cp, 1, 0, 0) != 0)
232		return;
233
234	sc = cp->private;
235	physpath_len = MAXPATHLEN;
236	physpath = g_malloc(physpath_len, M_WAITOK|M_ZERO);
237	error = g_io_getattr("GEOM::physpath", cp, &physpath_len, physpath);
238	g_access(cp, -1, 0, 0);
239	if (error == 0 && strlen(physpath) != 0) {
240		struct cdev *dev, *old_alias_dev;
241		struct cdev **alias_devp;
242
243		dev = sc->sc_dev;
244		old_alias_dev = sc->sc_alias;
245		alias_devp = (struct cdev **)&sc->sc_alias;
246		make_dev_physpath_alias(MAKEDEV_WAITOK, alias_devp, dev,
247		    old_alias_dev, physpath);
248	} else if (sc->sc_alias) {
249		destroy_dev((struct cdev *)sc->sc_alias);
250		sc->sc_alias = NULL;
251	}
252	g_free(physpath);
253}
254
255static void
256g_dev_set_media(struct g_consumer *cp)
257{
258	struct g_dev_softc *sc;
259	struct cdev *dev;
260	char buf[SPECNAMELEN + 6];
261
262	sc = cp->private;
263	dev = sc->sc_dev;
264	snprintf(buf, sizeof(buf), "cdev=%s", dev->si_name);
265	devctl_notify_f("DEVFS", "CDEV", "MEDIACHANGE", buf, M_WAITOK);
266	devctl_notify_f("GEOM", "DEV", "MEDIACHANGE", buf, M_WAITOK);
267	dev = sc->sc_alias;
268	if (dev != NULL) {
269		snprintf(buf, sizeof(buf), "cdev=%s", dev->si_name);
270		devctl_notify_f("DEVFS", "CDEV", "MEDIACHANGE", buf, M_WAITOK);
271		devctl_notify_f("GEOM", "DEV", "MEDIACHANGE", buf, M_WAITOK);
272	}
273}
274
275static void
276g_dev_attrchanged(struct g_consumer *cp, const char *attr)
277{
278
279	if (strcmp(attr, "GEOM::media") == 0) {
280		g_dev_set_media(cp);
281		return;
282	}
283
284	if (strcmp(attr, "GEOM::physpath") == 0) {
285		g_dev_set_physpath(cp);
286		return;
287	}
288}
289
290struct g_provider *
291g_dev_getprovider(struct cdev *dev)
292{
293	struct g_consumer *cp;
294
295	g_topology_assert();
296	if (dev == NULL)
297		return (NULL);
298	if (dev->si_devsw != &g_dev_cdevsw)
299		return (NULL);
300	cp = dev->si_drv2;
301	return (cp->provider);
302}
303
304static struct g_geom *
305g_dev_taste(struct g_class *mp, struct g_provider *pp, int insist __unused)
306{
307	struct g_geom *gp;
308	struct g_consumer *cp;
309	struct g_dev_softc *sc;
310	int error, len;
311	struct cdev *dev, *adev;
312	char buf[SPECNAMELEN + 6], *val;
313
314	g_trace(G_T_TOPOLOGY, "dev_taste(%s,%s)", mp->name, pp->name);
315	g_topology_assert();
316	gp = g_new_geomf(mp, "%s", pp->name);
317	sc = g_malloc(sizeof(*sc), M_WAITOK | M_ZERO);
318	mtx_init(&sc->sc_mtx, "g_dev", NULL, MTX_DEF);
319	cp = g_new_consumer(gp);
320	cp->private = sc;
321	cp->flags |= G_CF_DIRECT_SEND | G_CF_DIRECT_RECEIVE;
322	error = g_attach(cp, pp);
323	KASSERT(error == 0,
324	    ("g_dev_taste(%s) failed to g_attach, err=%d", pp->name, error));
325	error = make_dev_p(MAKEDEV_CHECKNAME | MAKEDEV_WAITOK, &dev,
326	    &g_dev_cdevsw, NULL, UID_ROOT, GID_OPERATOR, 0640, "%s", gp->name);
327	if (error != 0) {
328		printf("%s: make_dev_p() failed (gp->name=%s, error=%d)\n",
329		    __func__, gp->name, error);
330		g_detach(cp);
331		g_destroy_consumer(cp);
332		g_destroy_geom(gp);
333		mtx_destroy(&sc->sc_mtx);
334		g_free(sc);
335		return (NULL);
336	}
337	dev->si_flags |= SI_UNMAPPED;
338	sc->sc_dev = dev;
339
340	/* Search for device alias name and create it if found. */
341	adev = NULL;
342	for (len = MIN(strlen(gp->name), sizeof(buf) - 15); len > 0; len--) {
343		snprintf(buf, sizeof(buf), "kern.devalias.%s", gp->name);
344		buf[14 + len] = 0;
345		val = getenv(buf);
346		if (val != NULL) {
347			snprintf(buf, sizeof(buf), "%s%s",
348			    val, gp->name + len);
349			freeenv(val);
350			make_dev_alias_p(MAKEDEV_CHECKNAME | MAKEDEV_WAITOK,
351			    &adev, dev, "%s", buf);
352			adev->si_flags |= SI_UNMAPPED;
353			break;
354		}
355	}
356
357	dev->si_iosize_max = MAXPHYS;
358	dev->si_drv2 = cp;
359	error = init_dumpdev(dev);
360	if (error != 0)
361		printf("%s: init_dumpdev() failed (gp->name=%s, error=%d)\n",
362		    __func__, gp->name, error);
363	if (adev != NULL) {
364		adev->si_iosize_max = MAXPHYS;
365		adev->si_drv2 = cp;
366		init_dumpdev(adev);
367	}
368
369	g_dev_attrchanged(cp, "GEOM::physpath");
370	snprintf(buf, sizeof(buf), "cdev=%s", gp->name);
371	devctl_notify_f("GEOM", "DEV", "CREATE", buf, M_WAITOK);
372
373	return (gp);
374}
375
376static int
377g_dev_open(struct cdev *dev, int flags, int fmt, struct thread *td)
378{
379	struct g_consumer *cp;
380	struct g_dev_softc *sc;
381	int error, r, w, e;
382
383	cp = dev->si_drv2;
384	if (cp == NULL)
385		return(ENXIO);		/* g_dev_taste() not done yet */
386	g_trace(G_T_ACCESS, "g_dev_open(%s, %d, %d, %p)",
387	    cp->geom->name, flags, fmt, td);
388
389	r = flags & FREAD ? 1 : 0;
390	w = flags & FWRITE ? 1 : 0;
391#ifdef notyet
392	e = flags & O_EXCL ? 1 : 0;
393#else
394	e = 0;
395#endif
396
397	/*
398	 * This happens on attempt to open a device node with O_EXEC.
399	 */
400	if (r + w + e == 0)
401		return (EINVAL);
402
403	if (w) {
404		/*
405		 * When running in very secure mode, do not allow
406		 * opens for writing of any disks.
407		 */
408		error = securelevel_ge(td->td_ucred, 2);
409		if (error)
410			return (error);
411	}
412	g_topology_lock();
413	error = g_access(cp, r, w, e);
414	g_topology_unlock();
415	if (error == 0) {
416		sc = cp->private;
417		mtx_lock(&sc->sc_mtx);
418		if (sc->sc_open == 0 && sc->sc_active != 0)
419			wakeup(&sc->sc_active);
420		sc->sc_open += r + w + e;
421		mtx_unlock(&sc->sc_mtx);
422	}
423	return(error);
424}
425
426static int
427g_dev_close(struct cdev *dev, int flags, int fmt, struct thread *td)
428{
429	struct g_consumer *cp;
430	struct g_dev_softc *sc;
431	int error, r, w, e;
432
433	cp = dev->si_drv2;
434	if (cp == NULL)
435		return(ENXIO);
436	g_trace(G_T_ACCESS, "g_dev_close(%s, %d, %d, %p)",
437	    cp->geom->name, flags, fmt, td);
438
439	r = flags & FREAD ? -1 : 0;
440	w = flags & FWRITE ? -1 : 0;
441#ifdef notyet
442	e = flags & O_EXCL ? -1 : 0;
443#else
444	e = 0;
445#endif
446
447	/*
448	 * The vgonel(9) - caused by eg. forced unmount of devfs - calls
449	 * VOP_CLOSE(9) on devfs vnode without any FREAD or FWRITE flags,
450	 * which would result in zero deltas, which in turn would cause
451	 * panic in g_access(9).
452	 *
453	 * Note that we cannot zero the counters (ie. do "r = cp->acr"
454	 * etc) instead, because the consumer might be opened in another
455	 * devfs instance.
456	 */
457	if (r + w + e == 0)
458		return (EINVAL);
459
460	sc = cp->private;
461	mtx_lock(&sc->sc_mtx);
462	sc->sc_open += r + w + e;
463	while (sc->sc_open == 0 && sc->sc_active != 0)
464		msleep(&sc->sc_active, &sc->sc_mtx, 0, "PRIBIO", 0);
465	mtx_unlock(&sc->sc_mtx);
466	g_topology_lock();
467	error = g_access(cp, r, w, e);
468	g_topology_unlock();
469	return (error);
470}
471
472/*
473 * XXX: Until we have unmessed the ioctl situation, there is a race against
474 * XXX: a concurrent orphanization.  We cannot close it by holding topology
475 * XXX: since that would prevent us from doing our job, and stalling events
476 * XXX: will break (actually: stall) the BSD disklabel hacks.
477 */
478static int
479g_dev_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, struct thread *td)
480{
481	struct g_consumer *cp;
482	struct g_provider *pp;
483	off_t offset, length, chunk;
484	int i, error;
485
486	cp = dev->si_drv2;
487	pp = cp->provider;
488
489	error = 0;
490	KASSERT(cp->acr || cp->acw,
491	    ("Consumer with zero access count in g_dev_ioctl"));
492
493	i = IOCPARM_LEN(cmd);
494	switch (cmd) {
495	case DIOCGSECTORSIZE:
496		*(u_int *)data = cp->provider->sectorsize;
497		if (*(u_int *)data == 0)
498			error = ENOENT;
499		break;
500	case DIOCGMEDIASIZE:
501		*(off_t *)data = cp->provider->mediasize;
502		if (*(off_t *)data == 0)
503			error = ENOENT;
504		break;
505	case DIOCGFWSECTORS:
506		error = g_io_getattr("GEOM::fwsectors", cp, &i, data);
507		if (error == 0 && *(u_int *)data == 0)
508			error = ENOENT;
509		break;
510	case DIOCGFWHEADS:
511		error = g_io_getattr("GEOM::fwheads", cp, &i, data);
512		if (error == 0 && *(u_int *)data == 0)
513			error = ENOENT;
514		break;
515	case DIOCGFRONTSTUFF:
516		error = g_io_getattr("GEOM::frontstuff", cp, &i, data);
517		break;
518	case DIOCSKERNELDUMP:
519		if (*(u_int *)data == 0)
520			error = g_dev_setdumpdev(NULL, td);
521		else
522			error = g_dev_setdumpdev(dev, td);
523		break;
524	case DIOCGFLUSH:
525		error = g_io_flush(cp);
526		break;
527	case DIOCGDELETE:
528		offset = ((off_t *)data)[0];
529		length = ((off_t *)data)[1];
530		if ((offset % cp->provider->sectorsize) != 0 ||
531		    (length % cp->provider->sectorsize) != 0 || length <= 0) {
532			printf("%s: offset=%jd length=%jd\n", __func__, offset,
533			    length);
534			error = EINVAL;
535			break;
536		}
537		while (length > 0) {
538			chunk = length;
539			if (g_dev_del_max_sectors != 0 && chunk >
540			    g_dev_del_max_sectors * cp->provider->sectorsize) {
541				chunk = g_dev_del_max_sectors *
542				    cp->provider->sectorsize;
543			}
544			error = g_delete_data(cp, offset, chunk);
545			length -= chunk;
546			offset += chunk;
547			if (error)
548				break;
549			/*
550			 * Since the request size can be large, the service
551			 * time can be is likewise.  We make this ioctl
552			 * interruptible by checking for signals for each bio.
553			 */
554			if (SIGPENDING(td))
555				break;
556		}
557		break;
558	case DIOCGIDENT:
559		error = g_io_getattr("GEOM::ident", cp, &i, data);
560		break;
561	case DIOCGPROVIDERNAME:
562		if (pp == NULL)
563			return (ENOENT);
564		strlcpy(data, pp->name, i);
565		break;
566	case DIOCGSTRIPESIZE:
567		*(off_t *)data = cp->provider->stripesize;
568		break;
569	case DIOCGSTRIPEOFFSET:
570		*(off_t *)data = cp->provider->stripeoffset;
571		break;
572	case DIOCGPHYSPATH:
573		error = g_io_getattr("GEOM::physpath", cp, &i, data);
574		if (error == 0 && *(char *)data == '\0')
575			error = ENOENT;
576		break;
577	case DIOCGATTR: {
578		struct diocgattr_arg *arg = (struct diocgattr_arg *)data;
579
580		if (arg->len > sizeof(arg->value)) {
581			error = EINVAL;
582			break;
583		}
584		error = g_io_getattr(arg->name, cp, &arg->len, &arg->value);
585		break;
586	}
587	default:
588		if (cp->provider->geom->ioctl != NULL) {
589			error = cp->provider->geom->ioctl(cp->provider, cmd, data, fflag, td);
590		} else {
591			error = ENOIOCTL;
592		}
593	}
594
595	return (error);
596}
597
598static void
599g_dev_done(struct bio *bp2)
600{
601	struct g_consumer *cp;
602	struct g_dev_softc *sc;
603	struct bio *bp;
604	int destroy;
605
606	cp = bp2->bio_from;
607	sc = cp->private;
608	bp = bp2->bio_parent;
609	bp->bio_error = bp2->bio_error;
610	bp->bio_completed = bp2->bio_completed;
611	bp->bio_resid = bp->bio_length - bp2->bio_completed;
612	if (bp2->bio_error != 0) {
613		g_trace(G_T_BIO, "g_dev_done(%p) had error %d",
614		    bp2, bp2->bio_error);
615		bp->bio_flags |= BIO_ERROR;
616	} else {
617		g_trace(G_T_BIO, "g_dev_done(%p/%p) resid %ld completed %jd",
618		    bp2, bp, bp2->bio_resid, (intmax_t)bp2->bio_completed);
619	}
620	g_destroy_bio(bp2);
621	destroy = 0;
622	mtx_lock(&sc->sc_mtx);
623	if ((--sc->sc_active) == 0) {
624		if (sc->sc_open == 0)
625			wakeup(&sc->sc_active);
626		if (sc->sc_dev == NULL)
627			destroy = 1;
628	}
629	mtx_unlock(&sc->sc_mtx);
630	if (destroy)
631		g_post_event(g_dev_destroy, cp, M_NOWAIT, NULL);
632	biodone(bp);
633}
634
635static void
636g_dev_strategy(struct bio *bp)
637{
638	struct g_consumer *cp;
639	struct bio *bp2;
640	struct cdev *dev;
641	struct g_dev_softc *sc;
642
643	KASSERT(bp->bio_cmd == BIO_READ ||
644	        bp->bio_cmd == BIO_WRITE ||
645	        bp->bio_cmd == BIO_DELETE ||
646		bp->bio_cmd == BIO_FLUSH,
647		("Wrong bio_cmd bio=%p cmd=%d", bp, bp->bio_cmd));
648	dev = bp->bio_dev;
649	cp = dev->si_drv2;
650	sc = cp->private;
651	KASSERT(cp->acr || cp->acw,
652	    ("Consumer with zero access count in g_dev_strategy"));
653#ifdef INVARIANTS
654	if ((bp->bio_offset % cp->provider->sectorsize) != 0 ||
655	    (bp->bio_bcount % cp->provider->sectorsize) != 0) {
656		bp->bio_resid = bp->bio_bcount;
657		biofinish(bp, NULL, EINVAL);
658		return;
659	}
660#endif
661	mtx_lock(&sc->sc_mtx);
662	KASSERT(sc->sc_open > 0, ("Closed device in g_dev_strategy"));
663	sc->sc_active++;
664	mtx_unlock(&sc->sc_mtx);
665
666	for (;;) {
667		/*
668		 * XXX: This is not an ideal solution, but I belive it to
669		 * XXX: deadlock safe, all things considered.
670		 */
671		bp2 = g_clone_bio(bp);
672		if (bp2 != NULL)
673			break;
674		pause("gdstrat", hz / 10);
675	}
676	KASSERT(bp2 != NULL, ("XXX: ENOMEM in a bad place"));
677	bp2->bio_done = g_dev_done;
678	g_trace(G_T_BIO,
679	    "g_dev_strategy(%p/%p) offset %jd length %jd data %p cmd %d",
680	    bp, bp2, (intmax_t)bp->bio_offset, (intmax_t)bp2->bio_length,
681	    bp2->bio_data, bp2->bio_cmd);
682	g_io_request(bp2, cp);
683	KASSERT(cp->acr || cp->acw,
684	    ("g_dev_strategy raced with g_dev_close and lost"));
685
686}
687
688/*
689 * g_dev_callback()
690 *
691 * Called by devfs when asynchronous device destruction is completed.
692 * - Mark that we have no attached device any more.
693 * - If there are no outstanding requests, schedule geom destruction.
694 *   Otherwise destruction will be scheduled later by g_dev_done().
695 */
696
697static void
698g_dev_callback(void *arg)
699{
700	struct g_consumer *cp;
701	struct g_dev_softc *sc;
702	int destroy;
703
704	cp = arg;
705	sc = cp->private;
706	g_trace(G_T_TOPOLOGY, "g_dev_callback(%p(%s))", cp, cp->geom->name);
707
708	mtx_lock(&sc->sc_mtx);
709	sc->sc_dev = NULL;
710	sc->sc_alias = NULL;
711	destroy = (sc->sc_active == 0);
712	mtx_unlock(&sc->sc_mtx);
713	if (destroy)
714		g_post_event(g_dev_destroy, cp, M_WAITOK, NULL);
715}
716
717/*
718 * g_dev_orphan()
719 *
720 * Called from below when the provider orphaned us.
721 * - Clear any dump settings.
722 * - Request asynchronous device destruction to prevent any more requests
723 *   from coming in.  The provider is already marked with an error, so
724 *   anything which comes in in the interrim will be returned immediately.
725 */
726
727static void
728g_dev_orphan(struct g_consumer *cp)
729{
730	struct cdev *dev;
731	struct g_dev_softc *sc;
732
733	g_topology_assert();
734	sc = cp->private;
735	dev = sc->sc_dev;
736	g_trace(G_T_TOPOLOGY, "g_dev_orphan(%p(%s))", cp, cp->geom->name);
737
738	/* Reset any dump-area set on this device */
739	if (dev->si_flags & SI_DUMPDEV)
740		(void)set_dumper(NULL, NULL, curthread);
741
742	/* Destroy the struct cdev *so we get no more requests */
743	destroy_dev_sched_cb(dev, g_dev_callback, cp);
744}
745
746DECLARE_GEOM_CLASS(g_dev_class, g_dev);
747