xref: /freebsd/sys/geom/geom_dev.c (revision 603eaf792b659f91d7d1a065d82503966d1386fc)
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 }
128 
129 static int
130 g_dev_setdumpdev(struct cdev *dev)
131 {
132 	struct g_kerneldump kd;
133 	struct g_consumer *cp;
134 	int error, len;
135 
136 	if (dev == NULL)
137 		return (set_dumper(NULL, NULL));
138 
139 	cp = dev->si_drv2;
140 	len = sizeof(kd);
141 	kd.offset = 0;
142 	kd.length = OFF_MAX;
143 	error = g_io_getattr("GEOM::kerneldump", cp, &len, &kd);
144 	if (error == 0) {
145 		error = set_dumper(&kd.di, devtoname(dev));
146 		if (error == 0)
147 			dev->si_flags |= SI_DUMPDEV;
148 	}
149 	return (error);
150 }
151 
152 static void
153 init_dumpdev(struct cdev *dev)
154 {
155 
156 	if (dumpdev == NULL)
157 		return;
158 	if (strcmp(devtoname(dev), dumpdev) != 0)
159 		return;
160 	if (g_dev_setdumpdev(dev) == 0) {
161 		freeenv(dumpdev);
162 		dumpdev = NULL;
163 	}
164 }
165 
166 static void
167 g_dev_destroy(void *arg, int flags __unused)
168 {
169 	struct g_consumer *cp;
170 	struct g_geom *gp;
171 	struct g_dev_softc *sc;
172 
173 	g_topology_assert();
174 	cp = arg;
175 	gp = cp->geom;
176 	sc = cp->private;
177 	g_trace(G_T_TOPOLOGY, "g_dev_destroy(%p(%s))", cp, gp->name);
178 	if (cp->acr > 0 || cp->acw > 0 || cp->ace > 0)
179 		g_access(cp, -cp->acr, -cp->acw, -cp->ace);
180 	g_detach(cp);
181 	g_destroy_consumer(cp);
182 	g_destroy_geom(gp);
183 	mtx_destroy(&sc->sc_mtx);
184 	g_free(sc);
185 }
186 
187 void
188 g_dev_print(void)
189 {
190 	struct g_geom *gp;
191 	char const *p = "";
192 
193 	LIST_FOREACH(gp, &g_dev_class.geom, geom) {
194 		printf("%s%s", p, gp->name);
195 		p = " ";
196 	}
197 	printf("\n");
198 }
199 
200 static void
201 g_dev_attrchanged(struct g_consumer *cp, const char *attr)
202 {
203 	struct g_dev_softc *sc;
204 	struct cdev *dev;
205 	char buf[SPECNAMELEN + 6];
206 
207 	sc = cp->private;
208 	if (strcmp(attr, "GEOM::media") == 0) {
209 		dev = sc->sc_dev;
210 		snprintf(buf, sizeof(buf), "cdev=%s", dev->si_name);
211 		devctl_notify_f("DEVFS", "CDEV", "MEDIACHANGE", buf, M_WAITOK);
212 		dev = sc->sc_alias;
213 		if (dev != NULL) {
214 			snprintf(buf, sizeof(buf), "cdev=%s", dev->si_name);
215 			devctl_notify_f("DEVFS", "CDEV", "MEDIACHANGE", buf,
216 			    M_WAITOK);
217 		}
218 		return;
219 	}
220 
221 	if (strcmp(attr, "GEOM::physpath") != 0)
222 		return;
223 
224 	if (g_access(cp, 1, 0, 0) == 0) {
225 		char *physpath;
226 		int error, physpath_len;
227 
228 		physpath_len = MAXPATHLEN;
229 		physpath = g_malloc(physpath_len, M_WAITOK|M_ZERO);
230 		error =
231 		    g_io_getattr("GEOM::physpath", cp, &physpath_len, physpath);
232 		g_access(cp, -1, 0, 0);
233 		if (error == 0 && strlen(physpath) != 0) {
234 			struct cdev *old_alias_dev;
235 			struct cdev **alias_devp;
236 
237 			dev = sc->sc_dev;
238 			old_alias_dev = sc->sc_alias;
239 			alias_devp = (struct cdev **)&sc->sc_alias;
240 			make_dev_physpath_alias(MAKEDEV_WAITOK, alias_devp,
241 			    dev, old_alias_dev, physpath);
242 		} else if (sc->sc_alias) {
243 			destroy_dev((struct cdev *)sc->sc_alias);
244 			sc->sc_alias = NULL;
245 		}
246 		g_free(physpath);
247 	}
248 }
249 
250 struct g_provider *
251 g_dev_getprovider(struct cdev *dev)
252 {
253 	struct g_consumer *cp;
254 
255 	g_topology_assert();
256 	if (dev == NULL)
257 		return (NULL);
258 	if (dev->si_devsw != &g_dev_cdevsw)
259 		return (NULL);
260 	cp = dev->si_drv2;
261 	return (cp->provider);
262 }
263 
264 static struct g_geom *
265 g_dev_taste(struct g_class *mp, struct g_provider *pp, int insist __unused)
266 {
267 	struct g_geom *gp;
268 	struct g_consumer *cp;
269 	struct g_dev_softc *sc;
270 	int error, len;
271 	struct cdev *dev, *adev;
272 	char buf[64], *val;
273 
274 	g_trace(G_T_TOPOLOGY, "dev_taste(%s,%s)", mp->name, pp->name);
275 	g_topology_assert();
276 	gp = g_new_geomf(mp, "%s", pp->name);
277 	sc = g_malloc(sizeof(*sc), M_WAITOK | M_ZERO);
278 	mtx_init(&sc->sc_mtx, "g_dev", NULL, MTX_DEF);
279 	cp = g_new_consumer(gp);
280 	cp->private = sc;
281 	cp->flags |= G_CF_DIRECT_SEND | G_CF_DIRECT_RECEIVE;
282 	error = g_attach(cp, pp);
283 	KASSERT(error == 0,
284 	    ("g_dev_taste(%s) failed to g_attach, err=%d", pp->name, error));
285 	error = make_dev_p(MAKEDEV_CHECKNAME | MAKEDEV_WAITOK, &dev,
286 	    &g_dev_cdevsw, NULL, UID_ROOT, GID_OPERATOR, 0640, "%s", gp->name);
287 	if (error != 0) {
288 		printf("%s: make_dev_p() failed (gp->name=%s, error=%d)\n",
289 		    __func__, gp->name, error);
290 		g_detach(cp);
291 		g_destroy_consumer(cp);
292 		g_destroy_geom(gp);
293 		mtx_destroy(&sc->sc_mtx);
294 		g_free(sc);
295 		return (NULL);
296 	}
297 	dev->si_flags |= SI_UNMAPPED;
298 	sc->sc_dev = dev;
299 
300 	/* Search for device alias name and create it if found. */
301 	adev = NULL;
302 	for (len = MIN(strlen(gp->name), sizeof(buf) - 15); len > 0; len--) {
303 		snprintf(buf, sizeof(buf), "kern.devalias.%s", gp->name);
304 		buf[14 + len] = 0;
305 		val = kern_getenv(buf);
306 		if (val != NULL) {
307 			snprintf(buf, sizeof(buf), "%s%s",
308 			    val, gp->name + len);
309 			freeenv(val);
310 			if ((make_dev_alias_p(MAKEDEV_CHECKNAME|MAKEDEV_WAITOK,
311 			    &adev, dev, "%s", buf)) != 0)
312 				printf("Warning: unable to create device "
313 				    "alias %s\n", buf);
314 			break;
315 		}
316 	}
317 
318 	dev->si_iosize_max = MAXPHYS;
319 	dev->si_drv2 = cp;
320 	init_dumpdev(dev);
321 	if (adev != NULL) {
322 		adev->si_iosize_max = MAXPHYS;
323 		adev->si_drv2 = cp;
324 		adev->si_flags |= SI_UNMAPPED;
325 		init_dumpdev(adev);
326 	}
327 
328 	g_dev_attrchanged(cp, "GEOM::physpath");
329 
330 	return (gp);
331 }
332 
333 static int
334 g_dev_open(struct cdev *dev, int flags, int fmt, struct thread *td)
335 {
336 	struct g_consumer *cp;
337 	struct g_dev_softc *sc;
338 	int error, r, w, e;
339 
340 	cp = dev->si_drv2;
341 	if (cp == NULL)
342 		return (ENXIO);		/* g_dev_taste() not done yet */
343 	g_trace(G_T_ACCESS, "g_dev_open(%s, %d, %d, %p)",
344 	    cp->geom->name, flags, fmt, td);
345 
346 	r = flags & FREAD ? 1 : 0;
347 	w = flags & FWRITE ? 1 : 0;
348 #ifdef notyet
349 	e = flags & O_EXCL ? 1 : 0;
350 #else
351 	e = 0;
352 #endif
353 	if (w) {
354 		/*
355 		 * When running in very secure mode, do not allow
356 		 * opens for writing of any disks.
357 		 */
358 		error = securelevel_ge(td->td_ucred, 2);
359 		if (error)
360 			return (error);
361 	}
362 	g_topology_lock();
363 	error = g_access(cp, r, w, e);
364 	g_topology_unlock();
365 	if (error == 0) {
366 		sc = cp->private;
367 		mtx_lock(&sc->sc_mtx);
368 		if (sc->sc_open == 0 && sc->sc_active != 0)
369 			wakeup(&sc->sc_active);
370 		sc->sc_open += r + w + e;
371 		mtx_unlock(&sc->sc_mtx);
372 	}
373 	return (error);
374 }
375 
376 static int
377 g_dev_close(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);
386 	g_trace(G_T_ACCESS, "g_dev_close(%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 	sc = cp->private;
397 	mtx_lock(&sc->sc_mtx);
398 	sc->sc_open += r + w + e;
399 	while (sc->sc_open == 0 && sc->sc_active != 0)
400 		msleep(&sc->sc_active, &sc->sc_mtx, 0, "PRIBIO", 0);
401 	mtx_unlock(&sc->sc_mtx);
402 	g_topology_lock();
403 	error = g_access(cp, r, w, e);
404 	g_topology_unlock();
405 	return (error);
406 }
407 
408 /*
409  * XXX: Until we have unmessed the ioctl situation, there is a race against
410  * XXX: a concurrent orphanization.  We cannot close it by holding topology
411  * XXX: since that would prevent us from doing our job, and stalling events
412  * XXX: will break (actually: stall) the BSD disklabel hacks.
413  */
414 static int
415 g_dev_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, struct thread *td)
416 {
417 	struct g_consumer *cp;
418 	struct g_provider *pp;
419 	off_t offset, length, chunk;
420 	int i, error;
421 
422 	cp = dev->si_drv2;
423 	pp = cp->provider;
424 
425 	error = 0;
426 	KASSERT(cp->acr || cp->acw,
427 	    ("Consumer with zero access count in g_dev_ioctl"));
428 
429 	i = IOCPARM_LEN(cmd);
430 	switch (cmd) {
431 	case DIOCGSECTORSIZE:
432 		*(u_int *)data = cp->provider->sectorsize;
433 		if (*(u_int *)data == 0)
434 			error = ENOENT;
435 		break;
436 	case DIOCGMEDIASIZE:
437 		*(off_t *)data = cp->provider->mediasize;
438 		if (*(off_t *)data == 0)
439 			error = ENOENT;
440 		break;
441 	case DIOCGFWSECTORS:
442 		error = g_io_getattr("GEOM::fwsectors", cp, &i, data);
443 		if (error == 0 && *(u_int *)data == 0)
444 			error = ENOENT;
445 		break;
446 	case DIOCGFWHEADS:
447 		error = g_io_getattr("GEOM::fwheads", cp, &i, data);
448 		if (error == 0 && *(u_int *)data == 0)
449 			error = ENOENT;
450 		break;
451 	case DIOCGFRONTSTUFF:
452 		error = g_io_getattr("GEOM::frontstuff", cp, &i, data);
453 		break;
454 	case DIOCSKERNELDUMP:
455 		if (*(u_int *)data == 0)
456 			error = g_dev_setdumpdev(NULL);
457 		else
458 			error = g_dev_setdumpdev(dev);
459 		break;
460 	case DIOCGFLUSH:
461 		error = g_io_flush(cp);
462 		break;
463 	case DIOCGDELETE:
464 		offset = ((off_t *)data)[0];
465 		length = ((off_t *)data)[1];
466 		if ((offset % cp->provider->sectorsize) != 0 ||
467 		    (length % cp->provider->sectorsize) != 0 || length <= 0) {
468 			printf("%s: offset=%jd length=%jd\n", __func__, offset,
469 			    length);
470 			error = EINVAL;
471 			break;
472 		}
473 		while (length > 0) {
474 			chunk = length;
475 			if (g_dev_del_max_sectors != 0 && chunk >
476 			    g_dev_del_max_sectors * cp->provider->sectorsize) {
477 				chunk = g_dev_del_max_sectors *
478 				    cp->provider->sectorsize;
479 			}
480 			error = g_delete_data(cp, offset, chunk);
481 			length -= chunk;
482 			offset += chunk;
483 			if (error)
484 				break;
485 			/*
486 			 * Since the request size can be large, the service
487 			 * time can be is likewise.  We make this ioctl
488 			 * interruptible by checking for signals for each bio.
489 			 */
490 			if (SIGPENDING(td))
491 				break;
492 		}
493 		break;
494 	case DIOCGIDENT:
495 		error = g_io_getattr("GEOM::ident", cp, &i, data);
496 		break;
497 	case DIOCGPROVIDERNAME:
498 		if (pp == NULL)
499 			return (ENOENT);
500 		strlcpy(data, pp->name, i);
501 		break;
502 	case DIOCGSTRIPESIZE:
503 		*(off_t *)data = cp->provider->stripesize;
504 		break;
505 	case DIOCGSTRIPEOFFSET:
506 		*(off_t *)data = cp->provider->stripeoffset;
507 		break;
508 	case DIOCGPHYSPATH:
509 		error = g_io_getattr("GEOM::physpath", cp, &i, data);
510 		if (error == 0 && *(char *)data == '\0')
511 			error = ENOENT;
512 		break;
513 	case DIOCGATTR: {
514 		struct diocgattr_arg *arg = (struct diocgattr_arg *)data;
515 
516 		if (arg->len > sizeof(arg->value)) {
517 			error = EINVAL;
518 			break;
519 		}
520 		error = g_io_getattr(arg->name, cp, &arg->len, &arg->value);
521 		break;
522 	}
523 	default:
524 		if (cp->provider->geom->ioctl != NULL) {
525 			error = cp->provider->geom->ioctl(cp->provider, cmd, data, fflag, td);
526 		} else {
527 			error = ENOIOCTL;
528 		}
529 	}
530 
531 	return (error);
532 }
533 
534 static void
535 g_dev_done(struct bio *bp2)
536 {
537 	struct g_consumer *cp;
538 	struct g_dev_softc *sc;
539 	struct bio *bp;
540 	int destroy;
541 
542 	cp = bp2->bio_from;
543 	sc = cp->private;
544 	bp = bp2->bio_parent;
545 	bp->bio_error = bp2->bio_error;
546 	bp->bio_completed = bp2->bio_completed;
547 	bp->bio_resid = bp->bio_length - bp2->bio_completed;
548 	if (bp2->bio_error != 0) {
549 		g_trace(G_T_BIO, "g_dev_done(%p) had error %d",
550 		    bp2, bp2->bio_error);
551 		bp->bio_flags |= BIO_ERROR;
552 	} else {
553 		g_trace(G_T_BIO, "g_dev_done(%p/%p) resid %ld completed %jd",
554 		    bp2, bp, bp2->bio_resid, (intmax_t)bp2->bio_completed);
555 	}
556 	g_destroy_bio(bp2);
557 	destroy = 0;
558 	mtx_lock(&sc->sc_mtx);
559 	if ((--sc->sc_active) == 0) {
560 		if (sc->sc_open == 0)
561 			wakeup(&sc->sc_active);
562 		if (sc->sc_dev == NULL)
563 			destroy = 1;
564 	}
565 	mtx_unlock(&sc->sc_mtx);
566 	if (destroy)
567 		g_post_event(g_dev_destroy, cp, M_WAITOK, NULL);
568 	biodone(bp);
569 }
570 
571 static void
572 g_dev_strategy(struct bio *bp)
573 {
574 	struct g_consumer *cp;
575 	struct bio *bp2;
576 	struct cdev *dev;
577 	struct g_dev_softc *sc;
578 
579 	KASSERT(bp->bio_cmd == BIO_READ ||
580 	        bp->bio_cmd == BIO_WRITE ||
581 	        bp->bio_cmd == BIO_DELETE ||
582 		bp->bio_cmd == BIO_FLUSH,
583 		("Wrong bio_cmd bio=%p cmd=%d", bp, bp->bio_cmd));
584 	dev = bp->bio_dev;
585 	cp = dev->si_drv2;
586 	sc = cp->private;
587 	KASSERT(cp->acr || cp->acw,
588 	    ("Consumer with zero access count in g_dev_strategy"));
589 #ifdef INVARIANTS
590 	if ((bp->bio_offset % cp->provider->sectorsize) != 0 ||
591 	    (bp->bio_bcount % cp->provider->sectorsize) != 0) {
592 		bp->bio_resid = bp->bio_bcount;
593 		biofinish(bp, NULL, EINVAL);
594 		return;
595 	}
596 #endif
597 	mtx_lock(&sc->sc_mtx);
598 	KASSERT(sc->sc_open > 0, ("Closed device in g_dev_strategy"));
599 	sc->sc_active++;
600 	mtx_unlock(&sc->sc_mtx);
601 
602 	for (;;) {
603 		/*
604 		 * XXX: This is not an ideal solution, but I belive it to
605 		 * XXX: deadlock safe, all things considered.
606 		 */
607 		bp2 = g_clone_bio(bp);
608 		if (bp2 != NULL)
609 			break;
610 		pause("gdstrat", hz / 10);
611 	}
612 	KASSERT(bp2 != NULL, ("XXX: ENOMEM in a bad place"));
613 	bp2->bio_done = g_dev_done;
614 	g_trace(G_T_BIO,
615 	    "g_dev_strategy(%p/%p) offset %jd length %jd data %p cmd %d",
616 	    bp, bp2, (intmax_t)bp->bio_offset, (intmax_t)bp2->bio_length,
617 	    bp2->bio_data, bp2->bio_cmd);
618 	g_io_request(bp2, cp);
619 	KASSERT(cp->acr || cp->acw,
620 	    ("g_dev_strategy raced with g_dev_close and lost"));
621 
622 }
623 
624 /*
625  * g_dev_callback()
626  *
627  * Called by devfs when asynchronous device destruction is completed.
628  * - Mark that we have no attached device any more.
629  * - If there are no outstanding requests, schedule geom destruction.
630  *   Otherwise destruction will be scheduled later by g_dev_done().
631  */
632 
633 static void
634 g_dev_callback(void *arg)
635 {
636 	struct g_consumer *cp;
637 	struct g_dev_softc *sc;
638 	int destroy;
639 
640 	cp = arg;
641 	sc = cp->private;
642 	g_trace(G_T_TOPOLOGY, "g_dev_callback(%p(%s))", cp, cp->geom->name);
643 
644 	mtx_lock(&sc->sc_mtx);
645 	sc->sc_dev = NULL;
646 	sc->sc_alias = NULL;
647 	destroy = (sc->sc_active == 0);
648 	mtx_unlock(&sc->sc_mtx);
649 	if (destroy)
650 		g_post_event(g_dev_destroy, cp, M_WAITOK, NULL);
651 }
652 
653 /*
654  * g_dev_orphan()
655  *
656  * Called from below when the provider orphaned us.
657  * - Clear any dump settings.
658  * - Request asynchronous device destruction to prevent any more requests
659  *   from coming in.  The provider is already marked with an error, so
660  *   anything which comes in in the interrim will be returned immediately.
661  */
662 
663 static void
664 g_dev_orphan(struct g_consumer *cp)
665 {
666 	struct cdev *dev;
667 	struct g_dev_softc *sc;
668 
669 	g_topology_assert();
670 	sc = cp->private;
671 	dev = sc->sc_dev;
672 	g_trace(G_T_TOPOLOGY, "g_dev_orphan(%p(%s))", cp, cp->geom->name);
673 
674 	/* Reset any dump-area set on this device */
675 	if (dev->si_flags & SI_DUMPDEV)
676 		(void)set_dumper(NULL, NULL);
677 
678 	/* Destroy the struct cdev *so we get no more requests */
679 	destroy_dev_sched_cb(dev, g_dev_callback, cp);
680 }
681 
682 DECLARE_GEOM_CLASS(g_dev_class, g_dev);
683