xref: /freebsd/sys/geom/geom_dev.c (revision 273c26a3c3bea87a241d6879abd4f991db180bf0)
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$");
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 
60 struct 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 
68 static d_open_t		g_dev_open;
69 static d_close_t	g_dev_close;
70 static d_strategy_t	g_dev_strategy;
71 static d_ioctl_t	g_dev_ioctl;
72 
73 static 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 
85 static g_init_t g_dev_init;
86 static g_fini_t g_dev_fini;
87 static g_taste_t g_dev_taste;
88 static g_orphan_t g_dev_orphan;
89 static g_attrchanged_t g_dev_attrchanged;
90 
91 static 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  */
106 static uint64_t g_dev_del_max_sectors = 262144;
107 SYSCTL_DECL(_kern_geom);
108 SYSCTL_NODE(_kern_geom, OID_AUTO, dev, CTLFLAG_RW, 0, "GEOM_DEV stuff");
109 SYSCTL_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 
114 static char *dumpdev = NULL;
115 static void
116 g_dev_init(struct g_class *mp)
117 {
118 
119 	dumpdev = kern_getenv("dumpdev");
120 }
121 
122 static void
123 g_dev_fini(struct g_class *mp)
124 {
125 
126 	freeenv(dumpdev);
127 	dumpdev = NULL;
128 }
129 
130 static int
131 g_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 
153 static int
154 init_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 
187 static void
188 g_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 
211 void
212 g_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 
224 static void
225 g_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 
255 static void
256 g_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 
275 static void
276 g_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 
290 struct g_provider *
291 g_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 
304 static struct g_geom *
305 g_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;
311 	struct cdev *dev;
312 	char buf[SPECNAMELEN + 6];
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 	dev->si_iosize_max = MAXPHYS;
341 	dev->si_drv2 = cp;
342 	error = init_dumpdev(dev);
343 	if (error != 0)
344 		printf("%s: init_dumpdev() failed (gp->name=%s, error=%d)\n",
345 		    __func__, gp->name, error);
346 
347 	g_dev_attrchanged(cp, "GEOM::physpath");
348 	snprintf(buf, sizeof(buf), "cdev=%s", gp->name);
349 	devctl_notify_f("GEOM", "DEV", "CREATE", buf, M_WAITOK);
350 
351 	return (gp);
352 }
353 
354 static int
355 g_dev_open(struct cdev *dev, int flags, int fmt, struct thread *td)
356 {
357 	struct g_consumer *cp;
358 	struct g_dev_softc *sc;
359 	int error, r, w, e;
360 
361 	cp = dev->si_drv2;
362 	if (cp == NULL)
363 		return (ENXIO);		/* g_dev_taste() not done yet */
364 	g_trace(G_T_ACCESS, "g_dev_open(%s, %d, %d, %p)",
365 	    cp->geom->name, flags, fmt, td);
366 
367 	r = flags & FREAD ? 1 : 0;
368 	w = flags & FWRITE ? 1 : 0;
369 #ifdef notyet
370 	e = flags & O_EXCL ? 1 : 0;
371 #else
372 	e = 0;
373 #endif
374 
375 	/*
376 	 * This happens on attempt to open a device node with O_EXEC.
377 	 */
378 	if (r + w + e == 0)
379 		return (EINVAL);
380 
381 	if (w) {
382 		/*
383 		 * When running in very secure mode, do not allow
384 		 * opens for writing of any disks.
385 		 */
386 		error = securelevel_ge(td->td_ucred, 2);
387 		if (error)
388 			return (error);
389 	}
390 	g_topology_lock();
391 	error = g_access(cp, r, w, e);
392 	g_topology_unlock();
393 	if (error == 0) {
394 		sc = cp->private;
395 		mtx_lock(&sc->sc_mtx);
396 		if (sc->sc_open == 0 && sc->sc_active != 0)
397 			wakeup(&sc->sc_active);
398 		sc->sc_open += r + w + e;
399 		mtx_unlock(&sc->sc_mtx);
400 	}
401 	return (error);
402 }
403 
404 static int
405 g_dev_close(struct cdev *dev, int flags, int fmt, struct thread *td)
406 {
407 	struct g_consumer *cp;
408 	struct g_dev_softc *sc;
409 	int error, r, w, e;
410 
411 	cp = dev->si_drv2;
412 	if (cp == NULL)
413 		return (ENXIO);
414 	g_trace(G_T_ACCESS, "g_dev_close(%s, %d, %d, %p)",
415 	    cp->geom->name, flags, fmt, td);
416 
417 	r = flags & FREAD ? -1 : 0;
418 	w = flags & FWRITE ? -1 : 0;
419 #ifdef notyet
420 	e = flags & O_EXCL ? -1 : 0;
421 #else
422 	e = 0;
423 #endif
424 
425 	/*
426 	 * The vgonel(9) - caused by eg. forced unmount of devfs - calls
427 	 * VOP_CLOSE(9) on devfs vnode without any FREAD or FWRITE flags,
428 	 * which would result in zero deltas, which in turn would cause
429 	 * panic in g_access(9).
430 	 *
431 	 * Note that we cannot zero the counters (ie. do "r = cp->acr"
432 	 * etc) instead, because the consumer might be opened in another
433 	 * devfs instance.
434 	 */
435 	if (r + w + e == 0)
436 		return (EINVAL);
437 
438 	sc = cp->private;
439 	mtx_lock(&sc->sc_mtx);
440 	sc->sc_open += r + w + e;
441 	while (sc->sc_open == 0 && sc->sc_active != 0)
442 		msleep(&sc->sc_active, &sc->sc_mtx, 0, "PRIBIO", 0);
443 	mtx_unlock(&sc->sc_mtx);
444 	g_topology_lock();
445 	error = g_access(cp, r, w, e);
446 	g_topology_unlock();
447 	return (error);
448 }
449 
450 /*
451  * XXX: Until we have unmessed the ioctl situation, there is a race against
452  * XXX: a concurrent orphanization.  We cannot close it by holding topology
453  * XXX: since that would prevent us from doing our job, and stalling events
454  * XXX: will break (actually: stall) the BSD disklabel hacks.
455  */
456 static int
457 g_dev_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, struct thread *td)
458 {
459 	struct g_consumer *cp;
460 	struct g_provider *pp;
461 	off_t offset, length, chunk;
462 	int i, error;
463 
464 	cp = dev->si_drv2;
465 	pp = cp->provider;
466 
467 	error = 0;
468 	KASSERT(cp->acr || cp->acw,
469 	    ("Consumer with zero access count in g_dev_ioctl"));
470 
471 	i = IOCPARM_LEN(cmd);
472 	switch (cmd) {
473 	case DIOCGSECTORSIZE:
474 		*(u_int *)data = cp->provider->sectorsize;
475 		if (*(u_int *)data == 0)
476 			error = ENOENT;
477 		break;
478 	case DIOCGMEDIASIZE:
479 		*(off_t *)data = cp->provider->mediasize;
480 		if (*(off_t *)data == 0)
481 			error = ENOENT;
482 		break;
483 	case DIOCGFWSECTORS:
484 		error = g_io_getattr("GEOM::fwsectors", cp, &i, data);
485 		if (error == 0 && *(u_int *)data == 0)
486 			error = ENOENT;
487 		break;
488 	case DIOCGFWHEADS:
489 		error = g_io_getattr("GEOM::fwheads", cp, &i, data);
490 		if (error == 0 && *(u_int *)data == 0)
491 			error = ENOENT;
492 		break;
493 	case DIOCGFRONTSTUFF:
494 		error = g_io_getattr("GEOM::frontstuff", cp, &i, data);
495 		break;
496 	case DIOCSKERNELDUMP:
497 		if (*(u_int *)data == 0)
498 			error = g_dev_setdumpdev(NULL, td);
499 		else
500 			error = g_dev_setdumpdev(dev, td);
501 		break;
502 	case DIOCGFLUSH:
503 		error = g_io_flush(cp);
504 		break;
505 	case DIOCGDELETE:
506 		offset = ((off_t *)data)[0];
507 		length = ((off_t *)data)[1];
508 		if ((offset % cp->provider->sectorsize) != 0 ||
509 		    (length % cp->provider->sectorsize) != 0 || length <= 0) {
510 			printf("%s: offset=%jd length=%jd\n", __func__, offset,
511 			    length);
512 			error = EINVAL;
513 			break;
514 		}
515 		while (length > 0) {
516 			chunk = length;
517 			if (g_dev_del_max_sectors != 0 && chunk >
518 			    g_dev_del_max_sectors * cp->provider->sectorsize) {
519 				chunk = g_dev_del_max_sectors *
520 				    cp->provider->sectorsize;
521 			}
522 			error = g_delete_data(cp, offset, chunk);
523 			length -= chunk;
524 			offset += chunk;
525 			if (error)
526 				break;
527 			/*
528 			 * Since the request size can be large, the service
529 			 * time can be is likewise.  We make this ioctl
530 			 * interruptible by checking for signals for each bio.
531 			 */
532 			if (SIGPENDING(td))
533 				break;
534 		}
535 		break;
536 	case DIOCGIDENT:
537 		error = g_io_getattr("GEOM::ident", cp, &i, data);
538 		break;
539 	case DIOCGPROVIDERNAME:
540 		if (pp == NULL)
541 			return (ENOENT);
542 		strlcpy(data, pp->name, i);
543 		break;
544 	case DIOCGSTRIPESIZE:
545 		*(off_t *)data = cp->provider->stripesize;
546 		break;
547 	case DIOCGSTRIPEOFFSET:
548 		*(off_t *)data = cp->provider->stripeoffset;
549 		break;
550 	case DIOCGPHYSPATH:
551 		error = g_io_getattr("GEOM::physpath", cp, &i, data);
552 		if (error == 0 && *(char *)data == '\0')
553 			error = ENOENT;
554 		break;
555 	case DIOCGATTR: {
556 		struct diocgattr_arg *arg = (struct diocgattr_arg *)data;
557 
558 		if (arg->len > sizeof(arg->value)) {
559 			error = EINVAL;
560 			break;
561 		}
562 		error = g_io_getattr(arg->name, cp, &arg->len, &arg->value);
563 		break;
564 	}
565 	case DIOCZONECMD: {
566 		struct disk_zone_args *zone_args =(struct disk_zone_args *)data;
567 		struct disk_zone_rep_entry *new_entries, *old_entries;
568 		struct disk_zone_report *rep;
569 		size_t alloc_size;
570 
571 		old_entries = NULL;
572 		new_entries = NULL;
573 		rep = NULL;
574 		alloc_size = 0;
575 
576 		if (zone_args->zone_cmd == DISK_ZONE_REPORT_ZONES) {
577 
578 			rep = &zone_args->zone_params.report;
579 			alloc_size = rep->entries_allocated *
580 			    sizeof(struct disk_zone_rep_entry);
581 			if (alloc_size != 0)
582 				new_entries = g_malloc(alloc_size,
583 				    M_WAITOK| M_ZERO);
584 			old_entries = rep->entries;
585 			rep->entries = new_entries;
586 		}
587 		error = g_io_zonecmd(zone_args, cp);
588 		if ((zone_args->zone_cmd == DISK_ZONE_REPORT_ZONES)
589 		 && (alloc_size != 0)
590 		 && (error == 0)) {
591 			error = copyout(new_entries, old_entries, alloc_size);
592 		}
593 		if ((old_entries != NULL)
594 		 && (rep != NULL))
595 			rep->entries = old_entries;
596 
597 		if (new_entries != NULL)
598 			g_free(new_entries);
599 		break;
600 	}
601 	default:
602 		if (cp->provider->geom->ioctl != NULL) {
603 			error = cp->provider->geom->ioctl(cp->provider, cmd, data, fflag, td);
604 		} else {
605 			error = ENOIOCTL;
606 		}
607 	}
608 
609 	return (error);
610 }
611 
612 static void
613 g_dev_done(struct bio *bp2)
614 {
615 	struct g_consumer *cp;
616 	struct g_dev_softc *sc;
617 	struct bio *bp;
618 	int destroy;
619 
620 	cp = bp2->bio_from;
621 	sc = cp->private;
622 	bp = bp2->bio_parent;
623 	bp->bio_error = bp2->bio_error;
624 	bp->bio_completed = bp2->bio_completed;
625 	bp->bio_resid = bp->bio_length - bp2->bio_completed;
626 	if (bp2->bio_cmd == BIO_ZONE)
627 		bcopy(&bp2->bio_zone, &bp->bio_zone, sizeof(bp->bio_zone));
628 
629 	if (bp2->bio_error != 0) {
630 		g_trace(G_T_BIO, "g_dev_done(%p) had error %d",
631 		    bp2, bp2->bio_error);
632 		bp->bio_flags |= BIO_ERROR;
633 	} else {
634 		g_trace(G_T_BIO, "g_dev_done(%p/%p) resid %ld completed %jd",
635 		    bp2, bp, bp2->bio_resid, (intmax_t)bp2->bio_completed);
636 	}
637 	g_destroy_bio(bp2);
638 	destroy = 0;
639 	mtx_lock(&sc->sc_mtx);
640 	if ((--sc->sc_active) == 0) {
641 		if (sc->sc_open == 0)
642 			wakeup(&sc->sc_active);
643 		if (sc->sc_dev == NULL)
644 			destroy = 1;
645 	}
646 	mtx_unlock(&sc->sc_mtx);
647 	if (destroy)
648 		g_post_event(g_dev_destroy, cp, M_NOWAIT, NULL);
649 	biodone(bp);
650 }
651 
652 static void
653 g_dev_strategy(struct bio *bp)
654 {
655 	struct g_consumer *cp;
656 	struct bio *bp2;
657 	struct cdev *dev;
658 	struct g_dev_softc *sc;
659 
660 	KASSERT(bp->bio_cmd == BIO_READ ||
661 	        bp->bio_cmd == BIO_WRITE ||
662 	        bp->bio_cmd == BIO_DELETE ||
663 		bp->bio_cmd == BIO_FLUSH ||
664 		bp->bio_cmd == BIO_ZONE,
665 		("Wrong bio_cmd bio=%p cmd=%d", bp, bp->bio_cmd));
666 	dev = bp->bio_dev;
667 	cp = dev->si_drv2;
668 	sc = cp->private;
669 	KASSERT(cp->acr || cp->acw,
670 	    ("Consumer with zero access count in g_dev_strategy"));
671 #ifdef INVARIANTS
672 	if ((bp->bio_offset % cp->provider->sectorsize) != 0 ||
673 	    (bp->bio_bcount % cp->provider->sectorsize) != 0) {
674 		bp->bio_resid = bp->bio_bcount;
675 		biofinish(bp, NULL, EINVAL);
676 		return;
677 	}
678 #endif
679 	mtx_lock(&sc->sc_mtx);
680 	KASSERT(sc->sc_open > 0, ("Closed device in g_dev_strategy"));
681 	sc->sc_active++;
682 	mtx_unlock(&sc->sc_mtx);
683 
684 	for (;;) {
685 		/*
686 		 * XXX: This is not an ideal solution, but I believe it to
687 		 * XXX: deadlock safely, all things considered.
688 		 */
689 		bp2 = g_clone_bio(bp);
690 		if (bp2 != NULL)
691 			break;
692 		pause("gdstrat", hz / 10);
693 	}
694 	KASSERT(bp2 != NULL, ("XXX: ENOMEM in a bad place"));
695 	bp2->bio_done = g_dev_done;
696 	g_trace(G_T_BIO,
697 	    "g_dev_strategy(%p/%p) offset %jd length %jd data %p cmd %d",
698 	    bp, bp2, (intmax_t)bp->bio_offset, (intmax_t)bp2->bio_length,
699 	    bp2->bio_data, bp2->bio_cmd);
700 	g_io_request(bp2, cp);
701 	KASSERT(cp->acr || cp->acw,
702 	    ("g_dev_strategy raced with g_dev_close and lost"));
703 
704 }
705 
706 /*
707  * g_dev_callback()
708  *
709  * Called by devfs when asynchronous device destruction is completed.
710  * - Mark that we have no attached device any more.
711  * - If there are no outstanding requests, schedule geom destruction.
712  *   Otherwise destruction will be scheduled later by g_dev_done().
713  */
714 
715 static void
716 g_dev_callback(void *arg)
717 {
718 	struct g_consumer *cp;
719 	struct g_dev_softc *sc;
720 	int destroy;
721 
722 	cp = arg;
723 	sc = cp->private;
724 	g_trace(G_T_TOPOLOGY, "g_dev_callback(%p(%s))", cp, cp->geom->name);
725 
726 	mtx_lock(&sc->sc_mtx);
727 	sc->sc_dev = NULL;
728 	sc->sc_alias = NULL;
729 	destroy = (sc->sc_active == 0);
730 	mtx_unlock(&sc->sc_mtx);
731 	if (destroy)
732 		g_post_event(g_dev_destroy, cp, M_WAITOK, NULL);
733 }
734 
735 /*
736  * g_dev_orphan()
737  *
738  * Called from below when the provider orphaned us.
739  * - Clear any dump settings.
740  * - Request asynchronous device destruction to prevent any more requests
741  *   from coming in.  The provider is already marked with an error, so
742  *   anything which comes in the interim will be returned immediately.
743  */
744 
745 static void
746 g_dev_orphan(struct g_consumer *cp)
747 {
748 	struct cdev *dev;
749 	struct g_dev_softc *sc;
750 
751 	g_topology_assert();
752 	sc = cp->private;
753 	dev = sc->sc_dev;
754 	g_trace(G_T_TOPOLOGY, "g_dev_orphan(%p(%s))", cp, cp->geom->name);
755 
756 	/* Reset any dump-area set on this device */
757 	if (dev->si_flags & SI_DUMPDEV)
758 		(void)set_dumper(NULL, NULL, curthread);
759 
760 	/* Destroy the struct cdev *so we get no more requests */
761 	destroy_dev_sched_cb(dev, g_dev_callback, cp);
762 }
763 
764 DECLARE_GEOM_CLASS(g_dev_class, g_dev);
765