xref: /freebsd/sys/geom/geom_subr.c (revision 65a1d63665bf8b9cd2596d4319b31efc2232b722)
1 /*-
2  * SPDX-License-Identifier: BSD-3-Clause
3  *
4  * Copyright (c) 2002 Poul-Henning Kamp
5  * Copyright (c) 2002 Networks Associates Technology, Inc.
6  * All rights reserved.
7  *
8  * This software was developed for the FreeBSD Project by Poul-Henning Kamp
9  * and NAI Labs, the Security Research Division of Network Associates, Inc.
10  * under DARPA/SPAWAR contract N66001-01-C-8035 ("CBOSS"), as part of the
11  * DARPA CHATS research program.
12  *
13  * Redistribution and use in source and binary forms, with or without
14  * modification, are permitted provided that the following conditions
15  * are met:
16  * 1. Redistributions of source code must retain the above copyright
17  *    notice, this list of conditions and the following disclaimer.
18  * 2. Redistributions in binary form must reproduce the above copyright
19  *    notice, this list of conditions and the following disclaimer in the
20  *    documentation and/or other materials provided with the distribution.
21  * 3. The names of the authors may not be used to endorse or promote
22  *    products derived from this software without specific prior written
23  *    permission.
24  *
25  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35  * SUCH DAMAGE.
36  */
37 
38 #include <sys/cdefs.h>
39 __FBSDID("$FreeBSD$");
40 
41 #include "opt_ddb.h"
42 
43 #include <sys/param.h>
44 #include <sys/systm.h>
45 #include <sys/devicestat.h>
46 #include <sys/kernel.h>
47 #include <sys/malloc.h>
48 #include <sys/bio.h>
49 #include <sys/sysctl.h>
50 #include <sys/proc.h>
51 #include <sys/kthread.h>
52 #include <sys/lock.h>
53 #include <sys/mutex.h>
54 #include <sys/errno.h>
55 #include <sys/sbuf.h>
56 #include <sys/sdt.h>
57 #include <geom/geom.h>
58 #include <geom/geom_dbg.h>
59 #include <geom/geom_int.h>
60 #include <machine/stdarg.h>
61 
62 #ifdef DDB
63 #include <ddb/ddb.h>
64 #endif
65 
66 #ifdef KDB
67 #include <sys/kdb.h>
68 #endif
69 
70 SDT_PROVIDER_DEFINE(geom);
71 
72 struct class_list_head g_classes = LIST_HEAD_INITIALIZER(g_classes);
73 static struct g_tailq_head geoms = TAILQ_HEAD_INITIALIZER(geoms);
74 char *g_wait_event, *g_wait_up, *g_wait_down, *g_wait_sim;
75 
76 struct g_hh00 {
77 	struct g_class		*mp;
78 	struct g_provider	*pp;
79 	off_t			size;
80 	int			error;
81 	int			post;
82 };
83 
84 void
85 g_dbg_printf(const char *classname, int lvl, struct bio *bp,
86     const char *format,
87     ...)
88 {
89 #ifndef PRINTF_BUFR_SIZE
90 #define PRINTF_BUFR_SIZE 64
91 #endif
92 	char bufr[PRINTF_BUFR_SIZE];
93 	struct sbuf sb, *sbp __unused;
94 	va_list ap;
95 
96 	sbp = sbuf_new(&sb, bufr, sizeof(bufr), SBUF_FIXEDLEN);
97 	KASSERT(sbp != NULL, ("sbuf_new misused?"));
98 
99 	sbuf_set_drain(&sb, sbuf_printf_drain, NULL);
100 
101 	sbuf_cat(&sb, classname);
102 	if (lvl >= 0)
103 		sbuf_printf(&sb, "[%d]", lvl);
104 
105 	va_start(ap, format);
106 	sbuf_vprintf(&sb, format, ap);
107 	va_end(ap);
108 
109 	if (bp != NULL) {
110 		sbuf_putc(&sb, ' ');
111 		g_format_bio(&sb, bp);
112 	}
113 
114 	/* Terminate the debug line with a single '\n'. */
115 	sbuf_nl_terminate(&sb);
116 
117 	/* Flush line to printf. */
118 	sbuf_finish(&sb);
119 	sbuf_delete(&sb);
120 }
121 
122 /*
123  * This event offers a new class a chance to taste all preexisting providers.
124  */
125 static void
126 g_load_class(void *arg, int flag)
127 {
128 	struct g_hh00 *hh;
129 	struct g_class *mp2, *mp;
130 	struct g_geom *gp;
131 	struct g_provider *pp;
132 
133 	g_topology_assert();
134 	if (flag == EV_CANCEL)	/* XXX: can't happen ? */
135 		return;
136 	if (g_shutdown)
137 		return;
138 
139 	hh = arg;
140 	mp = hh->mp;
141 	hh->error = 0;
142 	if (hh->post) {
143 		g_free(hh);
144 		hh = NULL;
145 	}
146 	g_trace(G_T_TOPOLOGY, "g_load_class(%s)", mp->name);
147 	KASSERT(mp->name != NULL && *mp->name != '\0',
148 	    ("GEOM class has no name"));
149 	LIST_FOREACH(mp2, &g_classes, class) {
150 		if (mp2 == mp) {
151 			printf("The GEOM class %s is already loaded.\n",
152 			    mp2->name);
153 			if (hh != NULL)
154 				hh->error = EEXIST;
155 			return;
156 		} else if (strcmp(mp2->name, mp->name) == 0) {
157 			printf("A GEOM class %s is already loaded.\n",
158 			    mp2->name);
159 			if (hh != NULL)
160 				hh->error = EEXIST;
161 			return;
162 		}
163 	}
164 
165 	LIST_INIT(&mp->geom);
166 	LIST_INSERT_HEAD(&g_classes, mp, class);
167 	if (mp->init != NULL)
168 		mp->init(mp);
169 	if (mp->taste == NULL)
170 		return;
171 	LIST_FOREACH(mp2, &g_classes, class) {
172 		if (mp == mp2)
173 			continue;
174 		LIST_FOREACH(gp, &mp2->geom, geom) {
175 			LIST_FOREACH(pp, &gp->provider, provider) {
176 				mp->taste(mp, pp, 0);
177 				g_topology_assert();
178 			}
179 		}
180 	}
181 }
182 
183 static int
184 g_unload_class(struct g_class *mp)
185 {
186 	struct g_geom *gp;
187 	struct g_provider *pp;
188 	struct g_consumer *cp;
189 	int error;
190 
191 	g_topology_lock();
192 	g_trace(G_T_TOPOLOGY, "g_unload_class(%s)", mp->name);
193 retry:
194 	G_VALID_CLASS(mp);
195 	LIST_FOREACH(gp, &mp->geom, geom) {
196 		/* We refuse to unload if anything is open */
197 		LIST_FOREACH(pp, &gp->provider, provider)
198 			if (pp->acr || pp->acw || pp->ace) {
199 				g_topology_unlock();
200 				return (EBUSY);
201 			}
202 		LIST_FOREACH(cp, &gp->consumer, consumer)
203 			if (cp->acr || cp->acw || cp->ace) {
204 				g_topology_unlock();
205 				return (EBUSY);
206 			}
207 		/* If the geom is withering, wait for it to finish. */
208 		if (gp->flags & G_GEOM_WITHER) {
209 			g_topology_sleep(mp, 1);
210 			goto retry;
211 		}
212 	}
213 
214 	/*
215 	 * We allow unloading if we have no geoms, or a class
216 	 * method we can use to get rid of them.
217 	 */
218 	if (!LIST_EMPTY(&mp->geom) && mp->destroy_geom == NULL) {
219 		g_topology_unlock();
220 		return (EOPNOTSUPP);
221 	}
222 
223 	/* Bar new entries */
224 	mp->taste = NULL;
225 	mp->config = NULL;
226 
227 	LIST_FOREACH(gp, &mp->geom, geom) {
228 		error = mp->destroy_geom(NULL, mp, gp);
229 		if (error != 0) {
230 			g_topology_unlock();
231 			return (error);
232 		}
233 	}
234 	/* Wait for withering to finish. */
235 	for (;;) {
236 		gp = LIST_FIRST(&mp->geom);
237 		if (gp == NULL)
238 			break;
239 		KASSERT(gp->flags & G_GEOM_WITHER,
240 		   ("Non-withering geom in class %s", mp->name));
241 		g_topology_sleep(mp, 1);
242 	}
243 	G_VALID_CLASS(mp);
244 	if (mp->fini != NULL)
245 		mp->fini(mp);
246 	LIST_REMOVE(mp, class);
247 	g_topology_unlock();
248 
249 	return (0);
250 }
251 
252 int
253 g_modevent(module_t mod, int type, void *data)
254 {
255 	struct g_hh00 *hh;
256 	int error;
257 	static int g_ignition;
258 	struct g_class *mp;
259 
260 	mp = data;
261 	if (mp->version != G_VERSION) {
262 		printf("GEOM class %s has Wrong version %x\n",
263 		    mp->name, mp->version);
264 		return (EINVAL);
265 	}
266 	if (!g_ignition) {
267 		g_ignition++;
268 		g_init();
269 	}
270 	error = EOPNOTSUPP;
271 	switch (type) {
272 	case MOD_LOAD:
273 		g_trace(G_T_TOPOLOGY, "g_modevent(%s, LOAD)", mp->name);
274 		hh = g_malloc(sizeof *hh, M_WAITOK | M_ZERO);
275 		hh->mp = mp;
276 		/*
277 		 * Once the system is not cold, MOD_LOAD calls will be
278 		 * from the userland and the g_event thread will be able
279 		 * to acknowledge their completion.
280 		 */
281 		if (cold) {
282 			hh->post = 1;
283 			error = g_post_event(g_load_class, hh, M_WAITOK, NULL);
284 		} else {
285 			error = g_waitfor_event(g_load_class, hh, M_WAITOK,
286 			    NULL);
287 			if (error == 0)
288 				error = hh->error;
289 			g_free(hh);
290 		}
291 		break;
292 	case MOD_UNLOAD:
293 		g_trace(G_T_TOPOLOGY, "g_modevent(%s, UNLOAD)", mp->name);
294 		error = g_unload_class(mp);
295 		if (error == 0) {
296 			KASSERT(LIST_EMPTY(&mp->geom),
297 			    ("Unloaded class (%s) still has geom", mp->name));
298 		}
299 		break;
300 	}
301 	return (error);
302 }
303 
304 static void
305 g_retaste_event(void *arg, int flag)
306 {
307 	struct g_class *mp, *mp2;
308 	struct g_geom *gp;
309 	struct g_hh00 *hh;
310 	struct g_provider *pp;
311 	struct g_consumer *cp;
312 
313 	g_topology_assert();
314 	if (flag == EV_CANCEL)  /* XXX: can't happen ? */
315 		return;
316 	if (g_shutdown || g_notaste)
317 		return;
318 
319 	hh = arg;
320 	mp = hh->mp;
321 	hh->error = 0;
322 	if (hh->post) {
323 		g_free(hh);
324 		hh = NULL;
325 	}
326 	g_trace(G_T_TOPOLOGY, "g_retaste(%s)", mp->name);
327 
328 	LIST_FOREACH(mp2, &g_classes, class) {
329 		LIST_FOREACH(gp, &mp2->geom, geom) {
330 			LIST_FOREACH(pp, &gp->provider, provider) {
331 				if (pp->acr || pp->acw || pp->ace)
332 					continue;
333 				LIST_FOREACH(cp, &pp->consumers, consumers) {
334 					if (cp->geom->class == mp &&
335 					    (cp->flags & G_CF_ORPHAN) == 0)
336 						break;
337 				}
338 				if (cp != NULL) {
339 					cp->flags |= G_CF_ORPHAN;
340 					g_wither_geom(cp->geom, ENXIO);
341 				}
342 				mp->taste(mp, pp, 0);
343 				g_topology_assert();
344 			}
345 		}
346 	}
347 }
348 
349 int
350 g_retaste(struct g_class *mp)
351 {
352 	struct g_hh00 *hh;
353 	int error;
354 
355 	if (mp->taste == NULL)
356 		return (EINVAL);
357 
358 	hh = g_malloc(sizeof *hh, M_WAITOK | M_ZERO);
359 	hh->mp = mp;
360 
361 	if (cold) {
362 		hh->post = 1;
363 		error = g_post_event(g_retaste_event, hh, M_WAITOK, NULL);
364 	} else {
365 		error = g_waitfor_event(g_retaste_event, hh, M_WAITOK, NULL);
366 		if (error == 0)
367 			error = hh->error;
368 		g_free(hh);
369 	}
370 
371 	return (error);
372 }
373 
374 struct g_geom *
375 g_new_geomf(struct g_class *mp, const char *fmt, ...)
376 {
377 	struct g_geom *gp;
378 	va_list ap;
379 	struct sbuf *sb;
380 
381 	g_topology_assert();
382 	G_VALID_CLASS(mp);
383 	sb = sbuf_new_auto();
384 	va_start(ap, fmt);
385 	sbuf_vprintf(sb, fmt, ap);
386 	va_end(ap);
387 	sbuf_finish(sb);
388 	gp = g_malloc(sizeof *gp, M_WAITOK | M_ZERO);
389 	gp->name = g_malloc(sbuf_len(sb) + 1, M_WAITOK | M_ZERO);
390 	gp->class = mp;
391 	gp->rank = 1;
392 	LIST_INIT(&gp->consumer);
393 	LIST_INIT(&gp->provider);
394 	LIST_INSERT_HEAD(&mp->geom, gp, geom);
395 	TAILQ_INSERT_HEAD(&geoms, gp, geoms);
396 	strcpy(gp->name, sbuf_data(sb));
397 	sbuf_delete(sb);
398 	/* Fill in defaults from class */
399 	gp->start = mp->start;
400 	gp->spoiled = mp->spoiled;
401 	gp->attrchanged = mp->attrchanged;
402 	gp->providergone = mp->providergone;
403 	gp->dumpconf = mp->dumpconf;
404 	gp->access = mp->access;
405 	gp->orphan = mp->orphan;
406 	gp->ioctl = mp->ioctl;
407 	gp->resize = mp->resize;
408 	return (gp);
409 }
410 
411 void
412 g_destroy_geom(struct g_geom *gp)
413 {
414 
415 	g_topology_assert();
416 	G_VALID_GEOM(gp);
417 	g_trace(G_T_TOPOLOGY, "g_destroy_geom(%p(%s))", gp, gp->name);
418 	KASSERT(LIST_EMPTY(&gp->consumer),
419 	    ("g_destroy_geom(%s) with consumer(s) [%p]",
420 	    gp->name, LIST_FIRST(&gp->consumer)));
421 	KASSERT(LIST_EMPTY(&gp->provider),
422 	    ("g_destroy_geom(%s) with provider(s) [%p]",
423 	    gp->name, LIST_FIRST(&gp->provider)));
424 	g_cancel_event(gp);
425 	LIST_REMOVE(gp, geom);
426 	TAILQ_REMOVE(&geoms, gp, geoms);
427 	g_free(gp->name);
428 	g_free(gp);
429 }
430 
431 /*
432  * This function is called (repeatedly) until the geom has withered away.
433  */
434 void
435 g_wither_geom(struct g_geom *gp, int error)
436 {
437 	struct g_provider *pp;
438 
439 	g_topology_assert();
440 	G_VALID_GEOM(gp);
441 	g_trace(G_T_TOPOLOGY, "g_wither_geom(%p(%s))", gp, gp->name);
442 	if (!(gp->flags & G_GEOM_WITHER)) {
443 		gp->flags |= G_GEOM_WITHER;
444 		LIST_FOREACH(pp, &gp->provider, provider)
445 			if (!(pp->flags & G_PF_ORPHAN))
446 				g_orphan_provider(pp, error);
447 	}
448 	g_do_wither();
449 }
450 
451 /*
452  * Convenience function to destroy a particular provider.
453  */
454 void
455 g_wither_provider(struct g_provider *pp, int error)
456 {
457 
458 	pp->flags |= G_PF_WITHER;
459 	if (!(pp->flags & G_PF_ORPHAN))
460 		g_orphan_provider(pp, error);
461 }
462 
463 /*
464  * This function is called (repeatedly) until the has withered away.
465  */
466 void
467 g_wither_geom_close(struct g_geom *gp, int error)
468 {
469 	struct g_consumer *cp;
470 
471 	g_topology_assert();
472 	G_VALID_GEOM(gp);
473 	g_trace(G_T_TOPOLOGY, "g_wither_geom_close(%p(%s))", gp, gp->name);
474 	LIST_FOREACH(cp, &gp->consumer, consumer)
475 		if (cp->acr || cp->acw || cp->ace)
476 			g_access(cp, -cp->acr, -cp->acw, -cp->ace);
477 	g_wither_geom(gp, error);
478 }
479 
480 /*
481  * This function is called (repeatedly) until we cant wash away more
482  * withered bits at present.
483  */
484 void
485 g_wither_washer()
486 {
487 	struct g_class *mp;
488 	struct g_geom *gp, *gp2;
489 	struct g_provider *pp, *pp2;
490 	struct g_consumer *cp, *cp2;
491 
492 	g_topology_assert();
493 	LIST_FOREACH(mp, &g_classes, class) {
494 		LIST_FOREACH_SAFE(gp, &mp->geom, geom, gp2) {
495 			LIST_FOREACH_SAFE(pp, &gp->provider, provider, pp2) {
496 				if (!(pp->flags & G_PF_WITHER))
497 					continue;
498 				if (LIST_EMPTY(&pp->consumers))
499 					g_destroy_provider(pp);
500 			}
501 			if (!(gp->flags & G_GEOM_WITHER))
502 				continue;
503 			LIST_FOREACH_SAFE(pp, &gp->provider, provider, pp2) {
504 				if (LIST_EMPTY(&pp->consumers))
505 					g_destroy_provider(pp);
506 			}
507 			LIST_FOREACH_SAFE(cp, &gp->consumer, consumer, cp2) {
508 				if (cp->acr || cp->acw || cp->ace)
509 					continue;
510 				if (cp->provider != NULL)
511 					g_detach(cp);
512 				g_destroy_consumer(cp);
513 			}
514 			if (LIST_EMPTY(&gp->provider) &&
515 			    LIST_EMPTY(&gp->consumer))
516 				g_destroy_geom(gp);
517 		}
518 	}
519 }
520 
521 struct g_consumer *
522 g_new_consumer(struct g_geom *gp)
523 {
524 	struct g_consumer *cp;
525 
526 	g_topology_assert();
527 	G_VALID_GEOM(gp);
528 	KASSERT(!(gp->flags & G_GEOM_WITHER),
529 	    ("g_new_consumer on WITHERing geom(%s) (class %s)",
530 	    gp->name, gp->class->name));
531 	KASSERT(gp->orphan != NULL,
532 	    ("g_new_consumer on geom(%s) (class %s) without orphan",
533 	    gp->name, gp->class->name));
534 
535 	cp = g_malloc(sizeof *cp, M_WAITOK | M_ZERO);
536 	cp->geom = gp;
537 	cp->stat = devstat_new_entry(cp, -1, 0, DEVSTAT_ALL_SUPPORTED,
538 	    DEVSTAT_TYPE_DIRECT, DEVSTAT_PRIORITY_MAX);
539 	LIST_INSERT_HEAD(&gp->consumer, cp, consumer);
540 	return(cp);
541 }
542 
543 void
544 g_destroy_consumer(struct g_consumer *cp)
545 {
546 	struct g_geom *gp;
547 
548 	g_topology_assert();
549 	G_VALID_CONSUMER(cp);
550 	g_trace(G_T_TOPOLOGY, "g_destroy_consumer(%p)", cp);
551 	KASSERT (cp->provider == NULL, ("g_destroy_consumer but attached"));
552 	KASSERT (cp->acr == 0, ("g_destroy_consumer with acr"));
553 	KASSERT (cp->acw == 0, ("g_destroy_consumer with acw"));
554 	KASSERT (cp->ace == 0, ("g_destroy_consumer with ace"));
555 	g_cancel_event(cp);
556 	gp = cp->geom;
557 	LIST_REMOVE(cp, consumer);
558 	devstat_remove_entry(cp->stat);
559 	g_free(cp);
560 	if (gp->flags & G_GEOM_WITHER)
561 		g_do_wither();
562 }
563 
564 static void
565 g_new_provider_event(void *arg, int flag)
566 {
567 	struct g_class *mp;
568 	struct g_provider *pp;
569 	struct g_consumer *cp, *next_cp;
570 
571 	g_topology_assert();
572 	if (flag == EV_CANCEL)
573 		return;
574 	if (g_shutdown)
575 		return;
576 	pp = arg;
577 	G_VALID_PROVIDER(pp);
578 	KASSERT(!(pp->flags & G_PF_WITHER),
579 	    ("g_new_provider_event but withered"));
580 	LIST_FOREACH_SAFE(cp, &pp->consumers, consumers, next_cp) {
581 		if ((cp->flags & G_CF_ORPHAN) == 0 &&
582 		    cp->geom->attrchanged != NULL)
583 			cp->geom->attrchanged(cp, "GEOM::media");
584 	}
585 	if (g_notaste)
586 		return;
587 	LIST_FOREACH(mp, &g_classes, class) {
588 		if (mp->taste == NULL)
589 			continue;
590 		LIST_FOREACH(cp, &pp->consumers, consumers)
591 			if (cp->geom->class == mp &&
592 			    (cp->flags & G_CF_ORPHAN) == 0)
593 				break;
594 		if (cp != NULL)
595 			continue;
596 		mp->taste(mp, pp, 0);
597 		g_topology_assert();
598 	}
599 }
600 
601 
602 struct g_provider *
603 g_new_providerf(struct g_geom *gp, const char *fmt, ...)
604 {
605 	struct g_provider *pp;
606 	struct sbuf *sb;
607 	va_list ap;
608 
609 	g_topology_assert();
610 	G_VALID_GEOM(gp);
611 	KASSERT(gp->access != NULL,
612 	    ("new provider on geom(%s) without ->access (class %s)",
613 	    gp->name, gp->class->name));
614 	KASSERT(gp->start != NULL,
615 	    ("new provider on geom(%s) without ->start (class %s)",
616 	    gp->name, gp->class->name));
617 	KASSERT(!(gp->flags & G_GEOM_WITHER),
618 	    ("new provider on WITHERing geom(%s) (class %s)",
619 	    gp->name, gp->class->name));
620 	sb = sbuf_new_auto();
621 	va_start(ap, fmt);
622 	sbuf_vprintf(sb, fmt, ap);
623 	va_end(ap);
624 	sbuf_finish(sb);
625 	pp = g_malloc(sizeof *pp + sbuf_len(sb) + 1, M_WAITOK | M_ZERO);
626 	pp->name = (char *)(pp + 1);
627 	strcpy(pp->name, sbuf_data(sb));
628 	sbuf_delete(sb);
629 	LIST_INIT(&pp->consumers);
630 	LIST_INIT(&pp->aliases);
631 	pp->error = ENXIO;
632 	pp->geom = gp;
633 	pp->stat = devstat_new_entry(pp, -1, 0, DEVSTAT_ALL_SUPPORTED,
634 	    DEVSTAT_TYPE_DIRECT, DEVSTAT_PRIORITY_MAX);
635 	LIST_INSERT_HEAD(&gp->provider, pp, provider);
636 	g_post_event(g_new_provider_event, pp, M_WAITOK, pp, gp, NULL);
637 	return (pp);
638 }
639 
640 void
641 g_provider_add_alias(struct g_provider *pp, const char *fmt, ...)
642 {
643 	struct sbuf *sb;
644 	struct g_geom_alias *gap;
645 	va_list ap;
646 
647 	/*
648 	 * Generate the alias string and save it in the list.
649 	 */
650 	sb = sbuf_new_auto();
651 	va_start(ap, fmt);
652 	sbuf_vprintf(sb, fmt, ap);
653 	va_end(ap);
654 	sbuf_finish(sb);
655 	gap = g_malloc(sizeof(*gap) + sbuf_len(sb) + 1, M_WAITOK | M_ZERO);
656 	memcpy((char *)(gap + 1), sbuf_data(sb), sbuf_len(sb));
657 	sbuf_delete(sb);
658 	gap->ga_alias = (const char *)(gap + 1);
659 	LIST_INSERT_HEAD(&pp->aliases, gap, ga_next);
660 }
661 
662 void
663 g_error_provider(struct g_provider *pp, int error)
664 {
665 
666 	/* G_VALID_PROVIDER(pp);  We may not have g_topology */
667 	pp->error = error;
668 }
669 
670 static void
671 g_resize_provider_event(void *arg, int flag)
672 {
673 	struct g_hh00 *hh;
674 	struct g_class *mp;
675 	struct g_geom *gp;
676 	struct g_provider *pp;
677 	struct g_consumer *cp, *cp2;
678 	off_t size;
679 
680 	g_topology_assert();
681 	if (g_shutdown)
682 		return;
683 
684 	hh = arg;
685 	pp = hh->pp;
686 	size = hh->size;
687 	g_free(hh);
688 
689 	G_VALID_PROVIDER(pp);
690 	KASSERT(!(pp->flags & G_PF_WITHER),
691 	    ("g_resize_provider_event but withered"));
692 	g_trace(G_T_TOPOLOGY, "g_resize_provider_event(%p)", pp);
693 
694 	LIST_FOREACH_SAFE(cp, &pp->consumers, consumers, cp2) {
695 		gp = cp->geom;
696 		if (gp->resize == NULL && size < pp->mediasize) {
697 			/*
698 			 * XXX: g_dev_orphan method does deferred destroying
699 			 * and it is possible, that other event could already
700 			 * call the orphan method. Check consumer's flags to
701 			 * do not schedule it twice.
702 			 */
703 			if (cp->flags & G_CF_ORPHAN)
704 				continue;
705 			cp->flags |= G_CF_ORPHAN;
706 			cp->geom->orphan(cp);
707 		}
708 	}
709 
710 	pp->mediasize = size;
711 
712 	LIST_FOREACH_SAFE(cp, &pp->consumers, consumers, cp2) {
713 		gp = cp->geom;
714 		if ((gp->flags & G_GEOM_WITHER) == 0 && gp->resize != NULL)
715 			gp->resize(cp);
716 	}
717 
718 	/*
719 	 * After resizing, the previously invalid GEOM class metadata
720 	 * might become valid.  This means we should retaste.
721 	 */
722 	LIST_FOREACH(mp, &g_classes, class) {
723 		if (mp->taste == NULL)
724 			continue;
725 		LIST_FOREACH(cp, &pp->consumers, consumers)
726 			if (cp->geom->class == mp &&
727 			    (cp->flags & G_CF_ORPHAN) == 0)
728 				break;
729 		if (cp != NULL)
730 			continue;
731 		mp->taste(mp, pp, 0);
732 		g_topology_assert();
733 	}
734 }
735 
736 void
737 g_resize_provider(struct g_provider *pp, off_t size)
738 {
739 	struct g_hh00 *hh;
740 
741 	G_VALID_PROVIDER(pp);
742 	if (pp->flags & G_PF_WITHER)
743 		return;
744 
745 	if (size == pp->mediasize)
746 		return;
747 
748 	hh = g_malloc(sizeof *hh, M_WAITOK | M_ZERO);
749 	hh->pp = pp;
750 	hh->size = size;
751 	g_post_event(g_resize_provider_event, hh, M_WAITOK, NULL);
752 }
753 
754 #ifndef	_PATH_DEV
755 #define	_PATH_DEV	"/dev/"
756 #endif
757 
758 struct g_provider *
759 g_provider_by_name(char const *arg)
760 {
761 	struct g_class *cp;
762 	struct g_geom *gp;
763 	struct g_provider *pp, *wpp;
764 
765 	if (strncmp(arg, _PATH_DEV, sizeof(_PATH_DEV) - 1) == 0)
766 		arg += sizeof(_PATH_DEV) - 1;
767 
768 	wpp = NULL;
769 	LIST_FOREACH(cp, &g_classes, class) {
770 		LIST_FOREACH(gp, &cp->geom, geom) {
771 			LIST_FOREACH(pp, &gp->provider, provider) {
772 				if (strcmp(arg, pp->name) != 0)
773 					continue;
774 				if ((gp->flags & G_GEOM_WITHER) == 0 &&
775 				    (pp->flags & G_PF_WITHER) == 0)
776 					return (pp);
777 				else
778 					wpp = pp;
779 			}
780 		}
781 	}
782 
783 	return (wpp);
784 }
785 
786 void
787 g_destroy_provider(struct g_provider *pp)
788 {
789 	struct g_geom *gp;
790 	struct g_geom_alias *gap, *gaptmp;
791 
792 	g_topology_assert();
793 	G_VALID_PROVIDER(pp);
794 	KASSERT(LIST_EMPTY(&pp->consumers),
795 	    ("g_destroy_provider but attached"));
796 	KASSERT (pp->acr == 0, ("g_destroy_provider with acr"));
797 	KASSERT (pp->acw == 0, ("g_destroy_provider with acw"));
798 	KASSERT (pp->ace == 0, ("g_destroy_provider with ace"));
799 	g_cancel_event(pp);
800 	LIST_REMOVE(pp, provider);
801 	gp = pp->geom;
802 	devstat_remove_entry(pp->stat);
803 	/*
804 	 * If a callback was provided, send notification that the provider
805 	 * is now gone.
806 	 */
807 	if (gp->providergone != NULL)
808 		gp->providergone(pp);
809 	LIST_FOREACH_SAFE(gap, &pp->aliases, ga_next, gaptmp)
810 		g_free(gap);
811 	g_free(pp);
812 	if ((gp->flags & G_GEOM_WITHER))
813 		g_do_wither();
814 }
815 
816 /*
817  * We keep the "geoms" list sorted by topological order (== increasing
818  * numerical rank) at all times.
819  * When an attach is done, the attaching geoms rank is invalidated
820  * and it is moved to the tail of the list.
821  * All geoms later in the sequence has their ranks reevaluated in
822  * sequence.  If we cannot assign rank to a geom because it's
823  * prerequisites do not have rank, we move that element to the tail
824  * of the sequence with invalid rank as well.
825  * At some point we encounter our original geom and if we stil fail
826  * to assign it a rank, there must be a loop and we fail back to
827  * g_attach() which detach again and calls redo_rank again
828  * to fix up the damage.
829  * It would be much simpler code wise to do it recursively, but we
830  * can't risk that on the kernel stack.
831  */
832 
833 static int
834 redo_rank(struct g_geom *gp)
835 {
836 	struct g_consumer *cp;
837 	struct g_geom *gp1, *gp2;
838 	int n, m;
839 
840 	g_topology_assert();
841 	G_VALID_GEOM(gp);
842 
843 	/* Invalidate this geoms rank and move it to the tail */
844 	gp1 = TAILQ_NEXT(gp, geoms);
845 	if (gp1 != NULL) {
846 		gp->rank = 0;
847 		TAILQ_REMOVE(&geoms, gp, geoms);
848 		TAILQ_INSERT_TAIL(&geoms, gp, geoms);
849 	} else {
850 		gp1 = gp;
851 	}
852 
853 	/* re-rank the rest of the sequence */
854 	for (; gp1 != NULL; gp1 = gp2) {
855 		gp1->rank = 0;
856 		m = 1;
857 		LIST_FOREACH(cp, &gp1->consumer, consumer) {
858 			if (cp->provider == NULL)
859 				continue;
860 			n = cp->provider->geom->rank;
861 			if (n == 0) {
862 				m = 0;
863 				break;
864 			} else if (n >= m)
865 				m = n + 1;
866 		}
867 		gp1->rank = m;
868 		gp2 = TAILQ_NEXT(gp1, geoms);
869 
870 		/* got a rank, moving on */
871 		if (m != 0)
872 			continue;
873 
874 		/* no rank to original geom means loop */
875 		if (gp == gp1)
876 			return (ELOOP);
877 
878 		/* no rank, put it at the end move on */
879 		TAILQ_REMOVE(&geoms, gp1, geoms);
880 		TAILQ_INSERT_TAIL(&geoms, gp1, geoms);
881 	}
882 	return (0);
883 }
884 
885 int
886 g_attach(struct g_consumer *cp, struct g_provider *pp)
887 {
888 	int error;
889 
890 	g_topology_assert();
891 	G_VALID_CONSUMER(cp);
892 	G_VALID_PROVIDER(pp);
893 	g_trace(G_T_TOPOLOGY, "g_attach(%p, %p)", cp, pp);
894 	KASSERT(cp->provider == NULL, ("attach but attached"));
895 	cp->provider = pp;
896 	cp->flags &= ~G_CF_ORPHAN;
897 	LIST_INSERT_HEAD(&pp->consumers, cp, consumers);
898 	error = redo_rank(cp->geom);
899 	if (error) {
900 		LIST_REMOVE(cp, consumers);
901 		cp->provider = NULL;
902 		redo_rank(cp->geom);
903 	}
904 	return (error);
905 }
906 
907 void
908 g_detach(struct g_consumer *cp)
909 {
910 	struct g_provider *pp;
911 
912 	g_topology_assert();
913 	G_VALID_CONSUMER(cp);
914 	g_trace(G_T_TOPOLOGY, "g_detach(%p)", cp);
915 	KASSERT(cp->provider != NULL, ("detach but not attached"));
916 	KASSERT(cp->acr == 0, ("detach but nonzero acr"));
917 	KASSERT(cp->acw == 0, ("detach but nonzero acw"));
918 	KASSERT(cp->ace == 0, ("detach but nonzero ace"));
919 	KASSERT(cp->nstart == cp->nend,
920 	    ("detach with active requests"));
921 	pp = cp->provider;
922 	LIST_REMOVE(cp, consumers);
923 	cp->provider = NULL;
924 	if ((cp->geom->flags & G_GEOM_WITHER) ||
925 	    (pp->geom->flags & G_GEOM_WITHER) ||
926 	    (pp->flags & G_PF_WITHER))
927 		g_do_wither();
928 	redo_rank(cp->geom);
929 }
930 
931 /*
932  * g_access()
933  *
934  * Access-check with delta values.  The question asked is "can provider
935  * "cp" change the access counters by the relative amounts dc[rwe] ?"
936  */
937 
938 int
939 g_access(struct g_consumer *cp, int dcr, int dcw, int dce)
940 {
941 	struct g_provider *pp;
942 	struct g_geom *gp;
943 	int pw, pe;
944 #ifdef INVARIANTS
945 	int sr, sw, se;
946 #endif
947 	int error;
948 
949 	g_topology_assert();
950 	G_VALID_CONSUMER(cp);
951 	pp = cp->provider;
952 	KASSERT(pp != NULL, ("access but not attached"));
953 	G_VALID_PROVIDER(pp);
954 	gp = pp->geom;
955 
956 	g_trace(G_T_ACCESS, "g_access(%p(%s), %d, %d, %d)",
957 	    cp, pp->name, dcr, dcw, dce);
958 
959 	KASSERT(cp->acr + dcr >= 0, ("access resulting in negative acr"));
960 	KASSERT(cp->acw + dcw >= 0, ("access resulting in negative acw"));
961 	KASSERT(cp->ace + dce >= 0, ("access resulting in negative ace"));
962 	KASSERT(dcr != 0 || dcw != 0 || dce != 0, ("NOP access request"));
963 	KASSERT(cp->acr + dcr != 0 || cp->acw + dcw != 0 ||
964 	    cp->ace + dce != 0 || cp->nstart == cp->nend,
965 	    ("Last close with active requests"));
966 	KASSERT(gp->access != NULL, ("NULL geom->access"));
967 
968 	/*
969 	 * If our class cares about being spoiled, and we have been, we
970 	 * are probably just ahead of the event telling us that.  Fail
971 	 * now rather than having to unravel this later.
972 	 */
973 	if (cp->geom->spoiled != NULL && (cp->flags & G_CF_SPOILED) &&
974 	    (dcr > 0 || dcw > 0 || dce > 0))
975 		return (ENXIO);
976 
977 	/*
978 	 * A number of GEOM classes either need to perform an I/O on the first
979 	 * open or to acquire a different subsystem's lock.  To do that they
980 	 * may have to drop the topology lock.
981 	 * Other GEOM classes perform special actions when opening a lower rank
982 	 * geom for the first time.  As a result, more than one thread may
983 	 * end up performing the special actions.
984 	 * So, we prevent concurrent "first" opens by marking the consumer with
985 	 * special flag.
986 	 *
987 	 * Note that if the geom's access method never drops the topology lock,
988 	 * then we will never see G_GEOM_IN_ACCESS here.
989 	 */
990 	while ((gp->flags & G_GEOM_IN_ACCESS) != 0) {
991 		g_trace(G_T_ACCESS,
992 		    "%s: race on geom %s via provider %s and consumer of %s",
993 		    __func__, gp->name, pp->name, cp->geom->name);
994 		gp->flags |= G_GEOM_ACCESS_WAIT;
995 		g_topology_sleep(gp, 0);
996 	}
997 
998 	/*
999 	 * Figure out what counts the provider would have had, if this
1000 	 * consumer had (r0w0e0) at this time.
1001 	 */
1002 	pw = pp->acw - cp->acw;
1003 	pe = pp->ace - cp->ace;
1004 
1005 	g_trace(G_T_ACCESS,
1006     "open delta:[r%dw%de%d] old:[r%dw%de%d] provider:[r%dw%de%d] %p(%s)",
1007 	    dcr, dcw, dce,
1008 	    cp->acr, cp->acw, cp->ace,
1009 	    pp->acr, pp->acw, pp->ace,
1010 	    pp, pp->name);
1011 
1012 	/* If foot-shooting is enabled, any open on rank#1 is OK */
1013 	if ((g_debugflags & G_F_FOOTSHOOTING) && gp->rank == 1)
1014 		;
1015 	/* If we try exclusive but already write: fail */
1016 	else if (dce > 0 && pw > 0)
1017 		return (EPERM);
1018 	/* If we try write but already exclusive: fail */
1019 	else if (dcw > 0 && pe > 0)
1020 		return (EPERM);
1021 	/* If we try to open more but provider is error'ed: fail */
1022 	else if ((dcr > 0 || dcw > 0 || dce > 0) && pp->error != 0) {
1023 		printf("%s(%d): provider %s has error %d set\n",
1024 		    __func__, __LINE__, pp->name, pp->error);
1025 		return (pp->error);
1026 	}
1027 
1028 	/* Ok then... */
1029 
1030 #ifdef INVARIANTS
1031 	sr = cp->acr;
1032 	sw = cp->acw;
1033 	se = cp->ace;
1034 #endif
1035 	gp->flags |= G_GEOM_IN_ACCESS;
1036 	error = gp->access(pp, dcr, dcw, dce);
1037 	KASSERT(dcr > 0 || dcw > 0 || dce > 0 || error == 0,
1038 	    ("Geom provider %s::%s dcr=%d dcw=%d dce=%d error=%d failed "
1039 	    "closing ->access()", gp->class->name, pp->name, dcr, dcw,
1040 	    dce, error));
1041 
1042 	g_topology_assert();
1043 	gp->flags &= ~G_GEOM_IN_ACCESS;
1044 	KASSERT(cp->acr == sr && cp->acw == sw && cp->ace == se,
1045 	    ("Access counts changed during geom->access"));
1046 	if ((gp->flags & G_GEOM_ACCESS_WAIT) != 0) {
1047 		gp->flags &= ~G_GEOM_ACCESS_WAIT;
1048 		wakeup(gp);
1049 	}
1050 
1051 	if (!error) {
1052 		/*
1053 		 * If we open first write, spoil any partner consumers.
1054 		 * If we close last write and provider is not errored,
1055 		 * trigger re-taste.
1056 		 */
1057 		if (pp->acw == 0 && dcw != 0)
1058 			g_spoil(pp, cp);
1059 		else if (pp->acw != 0 && pp->acw == -dcw && pp->error == 0 &&
1060 		    !(gp->flags & G_GEOM_WITHER))
1061 			g_post_event(g_new_provider_event, pp, M_WAITOK,
1062 			    pp, NULL);
1063 
1064 		pp->acr += dcr;
1065 		pp->acw += dcw;
1066 		pp->ace += dce;
1067 		cp->acr += dcr;
1068 		cp->acw += dcw;
1069 		cp->ace += dce;
1070 		if (pp->acr != 0 || pp->acw != 0 || pp->ace != 0)
1071 			KASSERT(pp->sectorsize > 0,
1072 			    ("Provider %s lacks sectorsize", pp->name));
1073 		if ((cp->geom->flags & G_GEOM_WITHER) &&
1074 		    cp->acr == 0 && cp->acw == 0 && cp->ace == 0)
1075 			g_do_wither();
1076 	}
1077 	return (error);
1078 }
1079 
1080 int
1081 g_handleattr_int(struct bio *bp, const char *attribute, int val)
1082 {
1083 
1084 	return (g_handleattr(bp, attribute, &val, sizeof val));
1085 }
1086 
1087 int
1088 g_handleattr_uint16_t(struct bio *bp, const char *attribute, uint16_t val)
1089 {
1090 
1091 	return (g_handleattr(bp, attribute, &val, sizeof val));
1092 }
1093 
1094 int
1095 g_handleattr_off_t(struct bio *bp, const char *attribute, off_t val)
1096 {
1097 
1098 	return (g_handleattr(bp, attribute, &val, sizeof val));
1099 }
1100 
1101 int
1102 g_handleattr_str(struct bio *bp, const char *attribute, const char *str)
1103 {
1104 
1105 	return (g_handleattr(bp, attribute, str, 0));
1106 }
1107 
1108 int
1109 g_handleattr(struct bio *bp, const char *attribute, const void *val, int len)
1110 {
1111 	int error = 0;
1112 
1113 	if (strcmp(bp->bio_attribute, attribute))
1114 		return (0);
1115 	if (len == 0) {
1116 		bzero(bp->bio_data, bp->bio_length);
1117 		if (strlcpy(bp->bio_data, val, bp->bio_length) >=
1118 		    bp->bio_length) {
1119 			printf("%s: %s %s bio_length %jd strlen %zu -> EFAULT\n",
1120 			    __func__, bp->bio_to->name, attribute,
1121 			    (intmax_t)bp->bio_length, strlen(val));
1122 			error = EFAULT;
1123 		}
1124 	} else if (bp->bio_length == len) {
1125 		bcopy(val, bp->bio_data, len);
1126 	} else {
1127 		printf("%s: %s %s bio_length %jd len %d -> EFAULT\n", __func__,
1128 		    bp->bio_to->name, attribute, (intmax_t)bp->bio_length, len);
1129 		error = EFAULT;
1130 	}
1131 	if (error == 0)
1132 		bp->bio_completed = bp->bio_length;
1133 	g_io_deliver(bp, error);
1134 	return (1);
1135 }
1136 
1137 int
1138 g_std_access(struct g_provider *pp,
1139 	int dr __unused, int dw __unused, int de __unused)
1140 {
1141 
1142 	g_topology_assert();
1143 	G_VALID_PROVIDER(pp);
1144         return (0);
1145 }
1146 
1147 void
1148 g_std_done(struct bio *bp)
1149 {
1150 	struct bio *bp2;
1151 
1152 	bp2 = bp->bio_parent;
1153 	if (bp2->bio_error == 0)
1154 		bp2->bio_error = bp->bio_error;
1155 	bp2->bio_completed += bp->bio_completed;
1156 	g_destroy_bio(bp);
1157 	bp2->bio_inbed++;
1158 	if (bp2->bio_children == bp2->bio_inbed) {
1159 		if (bp2->bio_cmd == BIO_SPEEDUP)
1160 			bp2->bio_completed = bp2->bio_length;
1161 		g_io_deliver(bp2, bp2->bio_error);
1162 	}
1163 }
1164 
1165 /* XXX: maybe this is only g_slice_spoiled */
1166 
1167 void
1168 g_std_spoiled(struct g_consumer *cp)
1169 {
1170 	struct g_geom *gp;
1171 	struct g_provider *pp;
1172 
1173 	g_topology_assert();
1174 	G_VALID_CONSUMER(cp);
1175 	g_trace(G_T_TOPOLOGY, "g_std_spoiled(%p)", cp);
1176 	cp->flags |= G_CF_ORPHAN;
1177 	g_detach(cp);
1178 	gp = cp->geom;
1179 	LIST_FOREACH(pp, &gp->provider, provider)
1180 		g_orphan_provider(pp, ENXIO);
1181 	g_destroy_consumer(cp);
1182 	if (LIST_EMPTY(&gp->provider) && LIST_EMPTY(&gp->consumer))
1183 		g_destroy_geom(gp);
1184 	else
1185 		gp->flags |= G_GEOM_WITHER;
1186 }
1187 
1188 /*
1189  * Spoiling happens when a provider is opened for writing, but consumers
1190  * which are configured by in-band data are attached (slicers for instance).
1191  * Since the write might potentially change the in-band data, such consumers
1192  * need to re-evaluate their existence after the writing session closes.
1193  * We do this by (offering to) tear them down when the open for write happens
1194  * in return for a re-taste when it closes again.
1195  * Together with the fact that such consumers grab an 'e' bit whenever they
1196  * are open, regardless of mode, this ends up DTRT.
1197  */
1198 
1199 static void
1200 g_spoil_event(void *arg, int flag)
1201 {
1202 	struct g_provider *pp;
1203 	struct g_consumer *cp, *cp2;
1204 
1205 	g_topology_assert();
1206 	if (flag == EV_CANCEL)
1207 		return;
1208 	pp = arg;
1209 	G_VALID_PROVIDER(pp);
1210 	g_trace(G_T_TOPOLOGY, "%s %p(%s:%s:%s)", __func__, pp,
1211 	    pp->geom->class->name, pp->geom->name, pp->name);
1212 	for (cp = LIST_FIRST(&pp->consumers); cp != NULL; cp = cp2) {
1213 		cp2 = LIST_NEXT(cp, consumers);
1214 		if ((cp->flags & G_CF_SPOILED) == 0)
1215 			continue;
1216 		cp->flags &= ~G_CF_SPOILED;
1217 		if (cp->geom->spoiled == NULL)
1218 			continue;
1219 		cp->geom->spoiled(cp);
1220 		g_topology_assert();
1221 	}
1222 }
1223 
1224 void
1225 g_spoil(struct g_provider *pp, struct g_consumer *cp)
1226 {
1227 	struct g_consumer *cp2;
1228 
1229 	g_topology_assert();
1230 	G_VALID_PROVIDER(pp);
1231 	G_VALID_CONSUMER(cp);
1232 
1233 	LIST_FOREACH(cp2, &pp->consumers, consumers) {
1234 		if (cp2 == cp)
1235 			continue;
1236 /*
1237 		KASSERT(cp2->acr == 0, ("spoiling cp->acr = %d", cp2->acr));
1238 		KASSERT(cp2->acw == 0, ("spoiling cp->acw = %d", cp2->acw));
1239 */
1240 		KASSERT(cp2->ace == 0, ("spoiling cp->ace = %d", cp2->ace));
1241 		cp2->flags |= G_CF_SPOILED;
1242 	}
1243 	g_post_event(g_spoil_event, pp, M_WAITOK, pp, NULL);
1244 }
1245 
1246 static void
1247 g_media_changed_event(void *arg, int flag)
1248 {
1249 	struct g_provider *pp;
1250 	int retaste;
1251 
1252 	g_topology_assert();
1253 	if (flag == EV_CANCEL)
1254 		return;
1255 	pp = arg;
1256 	G_VALID_PROVIDER(pp);
1257 
1258 	/*
1259 	 * If provider was not open for writing, queue retaste after spoiling.
1260 	 * If it was, retaste will happen automatically on close.
1261 	 */
1262 	retaste = (pp->acw == 0 && pp->error == 0 &&
1263 	    !(pp->geom->flags & G_GEOM_WITHER));
1264 	g_spoil_event(arg, flag);
1265 	if (retaste)
1266 		g_post_event(g_new_provider_event, pp, M_WAITOK, pp, NULL);
1267 }
1268 
1269 int
1270 g_media_changed(struct g_provider *pp, int flag)
1271 {
1272 	struct g_consumer *cp;
1273 
1274 	LIST_FOREACH(cp, &pp->consumers, consumers)
1275 		cp->flags |= G_CF_SPOILED;
1276 	return (g_post_event(g_media_changed_event, pp, flag, pp, NULL));
1277 }
1278 
1279 int
1280 g_media_gone(struct g_provider *pp, int flag)
1281 {
1282 	struct g_consumer *cp;
1283 
1284 	LIST_FOREACH(cp, &pp->consumers, consumers)
1285 		cp->flags |= G_CF_SPOILED;
1286 	return (g_post_event(g_spoil_event, pp, flag, pp, NULL));
1287 }
1288 
1289 int
1290 g_getattr__(const char *attr, struct g_consumer *cp, void *var, int len)
1291 {
1292 	int error, i;
1293 
1294 	i = len;
1295 	error = g_io_getattr(attr, cp, &i, var);
1296 	if (error)
1297 		return (error);
1298 	if (i != len)
1299 		return (EINVAL);
1300 	return (0);
1301 }
1302 
1303 static int
1304 g_get_device_prefix_len(const char *name)
1305 {
1306 	int len;
1307 
1308 	if (strncmp(name, "ada", 3) == 0)
1309 		len = 3;
1310 	else if (strncmp(name, "ad", 2) == 0)
1311 		len = 2;
1312 	else
1313 		return (0);
1314 	if (name[len] < '0' || name[len] > '9')
1315 		return (0);
1316 	do {
1317 		len++;
1318 	} while (name[len] >= '0' && name[len] <= '9');
1319 	return (len);
1320 }
1321 
1322 int
1323 g_compare_names(const char *namea, const char *nameb)
1324 {
1325 	int deva, devb;
1326 
1327 	if (strcmp(namea, nameb) == 0)
1328 		return (1);
1329 	deva = g_get_device_prefix_len(namea);
1330 	if (deva == 0)
1331 		return (0);
1332 	devb = g_get_device_prefix_len(nameb);
1333 	if (devb == 0)
1334 		return (0);
1335 	if (strcmp(namea + deva, nameb + devb) == 0)
1336 		return (1);
1337 	return (0);
1338 }
1339 
1340 #if defined(DIAGNOSTIC) || defined(DDB)
1341 /*
1342  * This function walks the mesh and returns a non-zero integer if it
1343  * finds the argument pointer is an object. The return value indicates
1344  * which type of object it is believed to be. If topology is not locked,
1345  * this function is potentially dangerous, but we don't assert that the
1346  * topology lock is held when called from debugger.
1347  */
1348 int
1349 g_valid_obj(void const *ptr)
1350 {
1351 	struct g_class *mp;
1352 	struct g_geom *gp;
1353 	struct g_consumer *cp;
1354 	struct g_provider *pp;
1355 
1356 #ifdef KDB
1357 	if (kdb_active == 0)
1358 #endif
1359 		g_topology_assert();
1360 
1361 	LIST_FOREACH(mp, &g_classes, class) {
1362 		if (ptr == mp)
1363 			return (1);
1364 		LIST_FOREACH(gp, &mp->geom, geom) {
1365 			if (ptr == gp)
1366 				return (2);
1367 			LIST_FOREACH(cp, &gp->consumer, consumer)
1368 				if (ptr == cp)
1369 					return (3);
1370 			LIST_FOREACH(pp, &gp->provider, provider)
1371 				if (ptr == pp)
1372 					return (4);
1373 		}
1374 	}
1375 	return(0);
1376 }
1377 #endif
1378 
1379 #ifdef DDB
1380 
1381 #define	gprintf(...)	do {						\
1382 	db_printf("%*s", indent, "");					\
1383 	db_printf(__VA_ARGS__);						\
1384 } while (0)
1385 #define	gprintln(...)	do {						\
1386 	gprintf(__VA_ARGS__);						\
1387 	db_printf("\n");						\
1388 } while (0)
1389 
1390 #define	ADDFLAG(obj, flag, sflag)	do {				\
1391 	if ((obj)->flags & (flag)) {					\
1392 		if (comma)						\
1393 			strlcat(str, ",", size);			\
1394 		strlcat(str, (sflag), size);				\
1395 		comma = 1;						\
1396 	}								\
1397 } while (0)
1398 
1399 static char *
1400 provider_flags_to_string(struct g_provider *pp, char *str, size_t size)
1401 {
1402 	int comma = 0;
1403 
1404 	bzero(str, size);
1405 	if (pp->flags == 0) {
1406 		strlcpy(str, "NONE", size);
1407 		return (str);
1408 	}
1409 	ADDFLAG(pp, G_PF_WITHER, "G_PF_WITHER");
1410 	ADDFLAG(pp, G_PF_ORPHAN, "G_PF_ORPHAN");
1411 	return (str);
1412 }
1413 
1414 static char *
1415 geom_flags_to_string(struct g_geom *gp, char *str, size_t size)
1416 {
1417 	int comma = 0;
1418 
1419 	bzero(str, size);
1420 	if (gp->flags == 0) {
1421 		strlcpy(str, "NONE", size);
1422 		return (str);
1423 	}
1424 	ADDFLAG(gp, G_GEOM_WITHER, "G_GEOM_WITHER");
1425 	return (str);
1426 }
1427 static void
1428 db_show_geom_consumer(int indent, struct g_consumer *cp)
1429 {
1430 
1431 	if (indent == 0) {
1432 		gprintln("consumer: %p", cp);
1433 		gprintln("  class:    %s (%p)", cp->geom->class->name,
1434 		    cp->geom->class);
1435 		gprintln("  geom:     %s (%p)", cp->geom->name, cp->geom);
1436 		if (cp->provider == NULL)
1437 			gprintln("  provider: none");
1438 		else {
1439 			gprintln("  provider: %s (%p)", cp->provider->name,
1440 			    cp->provider);
1441 		}
1442 		gprintln("  access:   r%dw%de%d", cp->acr, cp->acw, cp->ace);
1443 		gprintln("  flags:    0x%04x", cp->flags);
1444 #ifdef INVARIANTS
1445 		gprintln("  nstart:   %u", cp->nstart);
1446 		gprintln("  nend:     %u", cp->nend);
1447 #endif
1448 	} else {
1449 		gprintf("consumer: %p (%s), access=r%dw%de%d", cp,
1450 		    cp->provider != NULL ? cp->provider->name : "none",
1451 		    cp->acr, cp->acw, cp->ace);
1452 		if (cp->flags)
1453 			db_printf(", flags=0x%04x", cp->flags);
1454 		db_printf("\n");
1455 	}
1456 }
1457 
1458 static void
1459 db_show_geom_provider(int indent, struct g_provider *pp)
1460 {
1461 	struct g_consumer *cp;
1462 	char flags[64];
1463 
1464 	if (indent == 0) {
1465 		gprintln("provider: %s (%p)", pp->name, pp);
1466 		gprintln("  class:        %s (%p)", pp->geom->class->name,
1467 		    pp->geom->class);
1468 		gprintln("  geom:         %s (%p)", pp->geom->name, pp->geom);
1469 		gprintln("  mediasize:    %jd", (intmax_t)pp->mediasize);
1470 		gprintln("  sectorsize:   %u", pp->sectorsize);
1471 		gprintln("  stripesize:   %ju", (uintmax_t)pp->stripesize);
1472 		gprintln("  stripeoffset: %ju", (uintmax_t)pp->stripeoffset);
1473 		gprintln("  access:       r%dw%de%d", pp->acr, pp->acw,
1474 		    pp->ace);
1475 		gprintln("  flags:        %s (0x%04x)",
1476 		    provider_flags_to_string(pp, flags, sizeof(flags)),
1477 		    pp->flags);
1478 		gprintln("  error:        %d", pp->error);
1479 		if (LIST_EMPTY(&pp->consumers))
1480 			gprintln("  consumers:    none");
1481 	} else {
1482 		gprintf("provider: %s (%p), access=r%dw%de%d",
1483 		    pp->name, pp, pp->acr, pp->acw, pp->ace);
1484 		if (pp->flags != 0) {
1485 			db_printf(", flags=%s (0x%04x)",
1486 			    provider_flags_to_string(pp, flags, sizeof(flags)),
1487 			    pp->flags);
1488 		}
1489 		db_printf("\n");
1490 	}
1491 	if (!LIST_EMPTY(&pp->consumers)) {
1492 		LIST_FOREACH(cp, &pp->consumers, consumers) {
1493 			db_show_geom_consumer(indent + 2, cp);
1494 			if (db_pager_quit)
1495 				break;
1496 		}
1497 	}
1498 }
1499 
1500 static void
1501 db_show_geom_geom(int indent, struct g_geom *gp)
1502 {
1503 	struct g_provider *pp;
1504 	struct g_consumer *cp;
1505 	char flags[64];
1506 
1507 	if (indent == 0) {
1508 		gprintln("geom: %s (%p)", gp->name, gp);
1509 		gprintln("  class:     %s (%p)", gp->class->name, gp->class);
1510 		gprintln("  flags:     %s (0x%04x)",
1511 		    geom_flags_to_string(gp, flags, sizeof(flags)), gp->flags);
1512 		gprintln("  rank:      %d", gp->rank);
1513 		if (LIST_EMPTY(&gp->provider))
1514 			gprintln("  providers: none");
1515 		if (LIST_EMPTY(&gp->consumer))
1516 			gprintln("  consumers: none");
1517 	} else {
1518 		gprintf("geom: %s (%p), rank=%d", gp->name, gp, gp->rank);
1519 		if (gp->flags != 0) {
1520 			db_printf(", flags=%s (0x%04x)",
1521 			    geom_flags_to_string(gp, flags, sizeof(flags)),
1522 			    gp->flags);
1523 		}
1524 		db_printf("\n");
1525 	}
1526 	if (!LIST_EMPTY(&gp->provider)) {
1527 		LIST_FOREACH(pp, &gp->provider, provider) {
1528 			db_show_geom_provider(indent + 2, pp);
1529 			if (db_pager_quit)
1530 				break;
1531 		}
1532 	}
1533 	if (!LIST_EMPTY(&gp->consumer)) {
1534 		LIST_FOREACH(cp, &gp->consumer, consumer) {
1535 			db_show_geom_consumer(indent + 2, cp);
1536 			if (db_pager_quit)
1537 				break;
1538 		}
1539 	}
1540 }
1541 
1542 static void
1543 db_show_geom_class(struct g_class *mp)
1544 {
1545 	struct g_geom *gp;
1546 
1547 	db_printf("class: %s (%p)\n", mp->name, mp);
1548 	LIST_FOREACH(gp, &mp->geom, geom) {
1549 		db_show_geom_geom(2, gp);
1550 		if (db_pager_quit)
1551 			break;
1552 	}
1553 }
1554 
1555 /*
1556  * Print the GEOM topology or the given object.
1557  */
1558 DB_SHOW_COMMAND(geom, db_show_geom)
1559 {
1560 	struct g_class *mp;
1561 
1562 	if (!have_addr) {
1563 		/* No address given, print the entire topology. */
1564 		LIST_FOREACH(mp, &g_classes, class) {
1565 			db_show_geom_class(mp);
1566 			db_printf("\n");
1567 			if (db_pager_quit)
1568 				break;
1569 		}
1570 	} else {
1571 		switch (g_valid_obj((void *)addr)) {
1572 		case 1:
1573 			db_show_geom_class((struct g_class *)addr);
1574 			break;
1575 		case 2:
1576 			db_show_geom_geom(0, (struct g_geom *)addr);
1577 			break;
1578 		case 3:
1579 			db_show_geom_consumer(0, (struct g_consumer *)addr);
1580 			break;
1581 		case 4:
1582 			db_show_geom_provider(0, (struct g_provider *)addr);
1583 			break;
1584 		default:
1585 			db_printf("Not a GEOM object.\n");
1586 			break;
1587 		}
1588 	}
1589 }
1590 
1591 static void
1592 db_print_bio_cmd(struct bio *bp)
1593 {
1594 	db_printf("  cmd: ");
1595 	switch (bp->bio_cmd) {
1596 	case BIO_READ: db_printf("BIO_READ"); break;
1597 	case BIO_WRITE: db_printf("BIO_WRITE"); break;
1598 	case BIO_DELETE: db_printf("BIO_DELETE"); break;
1599 	case BIO_GETATTR: db_printf("BIO_GETATTR"); break;
1600 	case BIO_FLUSH: db_printf("BIO_FLUSH"); break;
1601 	case BIO_CMD0: db_printf("BIO_CMD0"); break;
1602 	case BIO_CMD1: db_printf("BIO_CMD1"); break;
1603 	case BIO_CMD2: db_printf("BIO_CMD2"); break;
1604 	case BIO_ZONE: db_printf("BIO_ZONE"); break;
1605 	default: db_printf("UNKNOWN"); break;
1606 	}
1607 	db_printf("\n");
1608 }
1609 
1610 static void
1611 db_print_bio_flags(struct bio *bp)
1612 {
1613 	int comma;
1614 
1615 	comma = 0;
1616 	db_printf("  flags: ");
1617 	if (bp->bio_flags & BIO_ERROR) {
1618 		db_printf("BIO_ERROR");
1619 		comma = 1;
1620 	}
1621 	if (bp->bio_flags & BIO_DONE) {
1622 		db_printf("%sBIO_DONE", (comma ? ", " : ""));
1623 		comma = 1;
1624 	}
1625 	if (bp->bio_flags & BIO_ONQUEUE)
1626 		db_printf("%sBIO_ONQUEUE", (comma ? ", " : ""));
1627 	db_printf("\n");
1628 }
1629 
1630 /*
1631  * Print useful information in a BIO
1632  */
1633 DB_SHOW_COMMAND(bio, db_show_bio)
1634 {
1635 	struct bio *bp;
1636 
1637 	if (have_addr) {
1638 		bp = (struct bio *)addr;
1639 		db_printf("BIO %p\n", bp);
1640 		db_print_bio_cmd(bp);
1641 		db_print_bio_flags(bp);
1642 		db_printf("  cflags: 0x%hx\n", bp->bio_cflags);
1643 		db_printf("  pflags: 0x%hx\n", bp->bio_pflags);
1644 		db_printf("  offset: %jd\n", (intmax_t)bp->bio_offset);
1645 		db_printf("  length: %jd\n", (intmax_t)bp->bio_length);
1646 		db_printf("  bcount: %ld\n", bp->bio_bcount);
1647 		db_printf("  resid: %ld\n", bp->bio_resid);
1648 		db_printf("  completed: %jd\n", (intmax_t)bp->bio_completed);
1649 		db_printf("  children: %u\n", bp->bio_children);
1650 		db_printf("  inbed: %u\n", bp->bio_inbed);
1651 		db_printf("  error: %d\n", bp->bio_error);
1652 		db_printf("  parent: %p\n", bp->bio_parent);
1653 		db_printf("  driver1: %p\n", bp->bio_driver1);
1654 		db_printf("  driver2: %p\n", bp->bio_driver2);
1655 		db_printf("  caller1: %p\n", bp->bio_caller1);
1656 		db_printf("  caller2: %p\n", bp->bio_caller2);
1657 		db_printf("  bio_from: %p\n", bp->bio_from);
1658 		db_printf("  bio_to: %p\n", bp->bio_to);
1659 
1660 #if defined(BUF_TRACKING) || defined(FULL_BUF_TRACKING)
1661 		db_printf("  bio_track_bp: %p\n", bp->bio_track_bp);
1662 #endif
1663 	}
1664 }
1665 
1666 #undef	gprintf
1667 #undef	gprintln
1668 #undef	ADDFLAG
1669 
1670 #endif	/* DDB */
1671