xref: /freebsd/sbin/geom/core/geom.c (revision 780fb4a2) 
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3  *
4  * Copyright (c) 2004-2009 Pawel Jakub Dawidek <pjd@FreeBSD.org>
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26  * SUCH DAMAGE.
27  */
28 
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
31 
32 #include <sys/param.h>
33 #include <sys/linker.h>
34 #include <sys/module.h>
35 #include <sys/stat.h>
36 #include <sys/sysctl.h>
37 #include <ctype.h>
38 #include <err.h>
39 #include <errno.h>
40 #include <stdio.h>
41 #include <stdlib.h>
42 #include <stdarg.h>
43 #include <stdint.h>
44 #include <string.h>
45 #include <unistd.h>
46 #include <libgen.h>
47 #include <libutil.h>
48 #include <inttypes.h>
49 #include <dlfcn.h>
50 #include <assert.h>
51 #include <libgeom.h>
52 #include <geom.h>
53 
54 #include "misc/subr.h"
55 
56 #ifdef STATIC_GEOM_CLASSES
57 extern uint32_t gpart_version;
58 extern struct g_command gpart_class_commands[];
59 extern uint32_t glabel_version;
60 extern struct g_command glabel_class_commands[];
61 #endif
62 
63 static char comm[MAXPATHLEN], *class_name = NULL, *gclass_name = NULL;
64 static uint32_t *version = NULL;
65 static int verbose = 0;
66 static struct g_command *class_commands = NULL;
67 
68 #define	GEOM_CLASS_CMDS	0x01
69 #define	GEOM_STD_CMDS	0x02
70 static struct g_command *find_command(const char *cmdstr, int flags);
71 static int std_available(const char *name);
72 
73 static void std_help(struct gctl_req *req, unsigned flags);
74 static void std_list(struct gctl_req *req, unsigned flags);
75 static void std_status(struct gctl_req *req, unsigned flags);
76 static void std_load(struct gctl_req *req, unsigned flags);
77 static void std_unload(struct gctl_req *req, unsigned flags);
78 
79 static struct g_command std_commands[] = {
80 	{ "help", 0, std_help, G_NULL_OPTS, NULL },
81 	{ "list", 0, std_list,
82 	    {
83 		{ 'a', "all", NULL, G_TYPE_BOOL },
84 		G_OPT_SENTINEL
85 	    },
86 	    "[-a] [name ...]"
87 	},
88 	{ "status", 0, std_status,
89 	    {
90 		{ 'a', "all", NULL, G_TYPE_BOOL },
91 		{ 'g', "geoms", NULL, G_TYPE_BOOL },
92 		{ 's', "script", NULL, G_TYPE_BOOL },
93 		G_OPT_SENTINEL
94 	    },
95 	    "[-ags] [name ...]"
96 	},
97 	{ "load", G_FLAG_VERBOSE | G_FLAG_LOADKLD, std_load, G_NULL_OPTS,
98 	    NULL },
99 	{ "unload", G_FLAG_VERBOSE, std_unload, G_NULL_OPTS, NULL },
100 	G_CMD_SENTINEL
101 };
102 
103 static void
104 usage_command(struct g_command *cmd, const char *prefix)
105 {
106 	struct g_option *opt;
107 	unsigned i;
108 
109 	if (cmd->gc_usage != NULL) {
110 		char *pos, *ptr, *sptr;
111 
112 		sptr = ptr = strdup(cmd->gc_usage);
113 		while ((pos = strsep(&ptr, "\n")) != NULL) {
114 			if (*pos == '\0')
115 				continue;
116 			fprintf(stderr, "%s %s %s %s\n", prefix, comm,
117 			    cmd->gc_name, pos);
118 		}
119 		free(sptr);
120 		return;
121 	}
122 
123 	fprintf(stderr, "%s %s %s", prefix, comm, cmd->gc_name);
124 	if ((cmd->gc_flags & G_FLAG_VERBOSE) != 0)
125 		fprintf(stderr, " [-v]");
126 	for (i = 0; ; i++) {
127 		opt = &cmd->gc_options[i];
128 		if (opt->go_name == NULL)
129 			break;
130 		if (opt->go_val != NULL || G_OPT_TYPE(opt) == G_TYPE_BOOL)
131 			fprintf(stderr, " [");
132 		else
133 			fprintf(stderr, " ");
134 		fprintf(stderr, "-%c", opt->go_char);
135 		if (G_OPT_TYPE(opt) != G_TYPE_BOOL)
136 			fprintf(stderr, " %s", opt->go_name);
137 		if (opt->go_val != NULL || G_OPT_TYPE(opt) == G_TYPE_BOOL)
138 			fprintf(stderr, "]");
139 	}
140 	fprintf(stderr, "\n");
141 }
142 
143 static void
144 usage(void)
145 {
146 
147 	if (class_name == NULL) {
148 		errx(EXIT_FAILURE, "usage: %s <class> <command> [options]",
149 		    "geom");
150 	} else {
151 		struct g_command *cmd;
152 		const char *prefix;
153 		unsigned i;
154 
155 		prefix = "usage:";
156 		if (class_commands != NULL) {
157 			for (i = 0; ; i++) {
158 				cmd = &class_commands[i];
159 				if (cmd->gc_name == NULL)
160 					break;
161 				usage_command(cmd, prefix);
162 				prefix = "      ";
163 			}
164 		}
165 		for (i = 0; ; i++) {
166 			cmd = &std_commands[i];
167 			if (cmd->gc_name == NULL)
168 				break;
169 			/*
170 			 * If class defines command, which has the same name as
171 			 * standard command, skip it, because it was already
172 			 * shown on usage().
173 			 */
174 			if (find_command(cmd->gc_name, GEOM_CLASS_CMDS) != NULL)
175 				continue;
176 			usage_command(cmd, prefix);
177 			prefix = "      ";
178 		}
179 		exit(EXIT_FAILURE);
180 	}
181 }
182 
183 static void
184 load_module(void)
185 {
186 	char name1[64], name2[64];
187 
188 	snprintf(name1, sizeof(name1), "g_%s", class_name);
189 	snprintf(name2, sizeof(name2), "geom_%s", class_name);
190 	if (modfind(name1) < 0) {
191 		/* Not present in kernel, try loading it. */
192 		if (kldload(name2) < 0 || modfind(name1) < 0) {
193 			if (errno != EEXIST) {
194 				errx(EXIT_FAILURE,
195 				    "%s module not available!", name2);
196 			}
197 		}
198 	}
199 }
200 
201 static int
202 strlcatf(char *str, size_t size, const char *format, ...)
203 {
204 	size_t len;
205 	va_list ap;
206 	int ret;
207 
208 	len = strlen(str);
209 	str += len;
210 	size -= len;
211 
212 	va_start(ap, format);
213 	ret = vsnprintf(str, size, format, ap);
214 	va_end(ap);
215 
216 	return (ret);
217 }
218 
219 /*
220  * Find given option in options available for given command.
221  */
222 static struct g_option *
223 find_option(struct g_command *cmd, char ch)
224 {
225 	struct g_option *opt;
226 	unsigned i;
227 
228 	for (i = 0; ; i++) {
229 		opt = &cmd->gc_options[i];
230 		if (opt->go_name == NULL)
231 			return (NULL);
232 		if (opt->go_char == ch)
233 			return (opt);
234 	}
235 	/* NOTREACHED */
236 	return (NULL);
237 }
238 
239 /*
240  * Add given option to gctl_req.
241  */
242 static void
243 set_option(struct gctl_req *req, struct g_option *opt, const char *val)
244 {
245 	const char *optname;
246 	uint64_t number;
247 	void *ptr;
248 
249 	if (G_OPT_ISMULTI(opt)) {
250 		size_t optnamesize;
251 
252 		if (G_OPT_NUM(opt) == UCHAR_MAX)
253 			errx(EXIT_FAILURE, "Too many -%c options.", opt->go_char);
254 
255 		/*
256 		 * Base option name length plus 3 bytes for option number
257 		 * (max. 255 options) plus 1 byte for terminating '\0'.
258 		 */
259 		optnamesize = strlen(opt->go_name) + 3 + 1;
260 		ptr = malloc(optnamesize);
261 		if (ptr == NULL)
262 			errx(EXIT_FAILURE, "No memory.");
263 		snprintf(ptr, optnamesize, "%s%u", opt->go_name, G_OPT_NUM(opt));
264 		G_OPT_NUMINC(opt);
265 		optname = ptr;
266 	} else {
267 		optname = opt->go_name;
268 	}
269 
270 	if (G_OPT_TYPE(opt) == G_TYPE_NUMBER) {
271 		if (expand_number(val, &number) == -1) {
272 			err(EXIT_FAILURE, "Invalid value for '%c' argument",
273 			    opt->go_char);
274 		}
275 		ptr = malloc(sizeof(intmax_t));
276 		if (ptr == NULL)
277 			errx(EXIT_FAILURE, "No memory.");
278 		*(intmax_t *)ptr = number;
279 		opt->go_val = ptr;
280 		gctl_ro_param(req, optname, sizeof(intmax_t), opt->go_val);
281 	} else if (G_OPT_TYPE(opt) == G_TYPE_STRING) {
282 		gctl_ro_param(req, optname, -1, val);
283 	} else if (G_OPT_TYPE(opt) == G_TYPE_BOOL) {
284 		ptr = malloc(sizeof(int));
285 		if (ptr == NULL)
286 			errx(EXIT_FAILURE, "No memory.");
287 		*(int *)ptr = *val - '0';
288 		opt->go_val = ptr;
289 		gctl_ro_param(req, optname, sizeof(int), opt->go_val);
290 	} else {
291 		assert(!"Invalid type");
292 	}
293 
294 	if (G_OPT_ISMULTI(opt))
295 		free(__DECONST(char *, optname));
296 }
297 
298 /*
299  * 1. Add given argument by caller.
300  * 2. Add default values of not given arguments.
301  * 3. Add the rest of arguments.
302  */
303 static void
304 parse_arguments(struct g_command *cmd, struct gctl_req *req, int *argc,
305     char ***argv)
306 {
307 	struct g_option *opt;
308 	char opts[64];
309 	unsigned i;
310 	int ch;
311 
312 	*opts = '\0';
313 	if ((cmd->gc_flags & G_FLAG_VERBOSE) != 0)
314 		strlcat(opts, "v", sizeof(opts));
315 	for (i = 0; ; i++) {
316 		opt = &cmd->gc_options[i];
317 		if (opt->go_name == NULL)
318 			break;
319 		assert(G_OPT_TYPE(opt) != 0);
320 		assert((opt->go_type & ~(G_TYPE_MASK | G_TYPE_MULTI)) == 0);
321 		/* Multiple bool arguments makes no sense. */
322 		assert(G_OPT_TYPE(opt) != G_TYPE_BOOL ||
323 		    (opt->go_type & G_TYPE_MULTI) == 0);
324 		strlcatf(opts, sizeof(opts), "%c", opt->go_char);
325 		if (G_OPT_TYPE(opt) != G_TYPE_BOOL)
326 			strlcat(opts, ":", sizeof(opts));
327 	}
328 
329 	/*
330 	 * Add specified arguments.
331 	 */
332 	while ((ch = getopt(*argc, *argv, opts)) != -1) {
333 		/* Standard (not passed to kernel) options. */
334 		switch (ch) {
335 		case 'v':
336 			verbose = 1;
337 			continue;
338 		}
339 		/* Options passed to kernel. */
340 		opt = find_option(cmd, ch);
341 		if (opt == NULL)
342 			usage();
343 		if (!G_OPT_ISMULTI(opt) && G_OPT_ISDONE(opt)) {
344 			warnx("Option '%c' specified twice.", opt->go_char);
345 			usage();
346 		}
347 		G_OPT_DONE(opt);
348 
349 		if (G_OPT_TYPE(opt) == G_TYPE_BOOL)
350 			set_option(req, opt, "1");
351 		else
352 			set_option(req, opt, optarg);
353 	}
354 	*argc -= optind;
355 	*argv += optind;
356 
357 	/*
358 	 * Add not specified arguments, but with default values.
359 	 */
360 	for (i = 0; ; i++) {
361 		opt = &cmd->gc_options[i];
362 		if (opt->go_name == NULL)
363 			break;
364 		if (G_OPT_ISDONE(opt))
365 			continue;
366 
367 		if (G_OPT_TYPE(opt) == G_TYPE_BOOL) {
368 			assert(opt->go_val == NULL);
369 			set_option(req, opt, "0");
370 		} else {
371 			if (opt->go_val == NULL) {
372 				warnx("Option '%c' not specified.",
373 				    opt->go_char);
374 				usage();
375 			} else if (opt->go_val == G_VAL_OPTIONAL) {
376 				/* add nothing. */
377 			} else {
378 				set_option(req, opt, opt->go_val);
379 			}
380 		}
381 	}
382 
383 	/*
384 	 * Add rest of given arguments.
385 	 */
386 	gctl_ro_param(req, "nargs", sizeof(int), argc);
387 	for (i = 0; i < (unsigned)*argc; i++) {
388 		char argname[16];
389 
390 		snprintf(argname, sizeof(argname), "arg%u", i);
391 		gctl_ro_param(req, argname, -1, (*argv)[i]);
392 	}
393 }
394 
395 /*
396  * Find given command in commands available for given class.
397  */
398 static struct g_command *
399 find_command(const char *cmdstr, int flags)
400 {
401 	struct g_command *cmd;
402 	unsigned i;
403 
404 	/*
405 	 * First try to find command defined by loaded library.
406 	 */
407 	if ((flags & GEOM_CLASS_CMDS) != 0 && class_commands != NULL) {
408 		for (i = 0; ; i++) {
409 			cmd = &class_commands[i];
410 			if (cmd->gc_name == NULL)
411 				break;
412 			if (strcmp(cmd->gc_name, cmdstr) == 0)
413 				return (cmd);
414 		}
415 	}
416 	/*
417 	 * Now try to find in standard commands.
418 	 */
419 	if ((flags & GEOM_STD_CMDS) != 0) {
420 		for (i = 0; ; i++) {
421 			cmd = &std_commands[i];
422 			if (cmd->gc_name == NULL)
423 				break;
424 			if (strcmp(cmd->gc_name, cmdstr) == 0)
425 				return (cmd);
426 		}
427 	}
428 	return (NULL);
429 }
430 
431 static unsigned
432 set_flags(struct g_command *cmd)
433 {
434 	unsigned flags = 0;
435 
436 	if ((cmd->gc_flags & G_FLAG_VERBOSE) != 0 && verbose)
437 		flags |= G_FLAG_VERBOSE;
438 
439 	return (flags);
440 }
441 
442 /*
443  * Run command.
444  */
445 static void
446 run_command(int argc, char *argv[])
447 {
448 	struct g_command *cmd;
449 	struct gctl_req *req;
450 	const char *errstr;
451 	char buf[4096];
452 
453 	/* First try to find a command defined by a class. */
454 	cmd = find_command(argv[0], GEOM_CLASS_CMDS);
455 	if (cmd == NULL) {
456 		/* Now, try to find a standard command. */
457 		cmd = find_command(argv[0], GEOM_STD_CMDS);
458 		if (cmd == NULL) {
459 			warnx("Unknown command: %s.", argv[0]);
460 			usage();
461 		}
462 		if (!std_available(cmd->gc_name)) {
463 			warnx("Command '%s' not available.", argv[0]);
464 			exit(EXIT_FAILURE);
465 		}
466 	}
467 	if ((cmd->gc_flags & G_FLAG_LOADKLD) != 0)
468 		load_module();
469 
470 	req = gctl_get_handle();
471 	gctl_ro_param(req, "class", -1, gclass_name);
472 	gctl_ro_param(req, "verb", -1, argv[0]);
473 	if (version != NULL)
474 		gctl_ro_param(req, "version", sizeof(*version), version);
475 	parse_arguments(cmd, req, &argc, &argv);
476 
477 	bzero(buf, sizeof(buf));
478 	if (cmd->gc_func != NULL) {
479 		unsigned flags;
480 
481 		flags = set_flags(cmd);
482 		cmd->gc_func(req, flags);
483 		errstr = req->error;
484 	} else {
485 		gctl_rw_param(req, "output", sizeof(buf), buf);
486 		errstr = gctl_issue(req);
487 	}
488 	if (errstr != NULL && errstr[0] != '\0') {
489 		warnx("%s", errstr);
490 		if (strncmp(errstr, "warning: ", strlen("warning: ")) != 0) {
491 			gctl_free(req);
492 			exit(EXIT_FAILURE);
493 		}
494 	}
495 	if (buf[0] != '\0')
496 		printf("%s", buf);
497 	gctl_free(req);
498 	if (verbose)
499 		printf("Done.\n");
500 	exit(EXIT_SUCCESS);
501 }
502 
503 #ifndef STATIC_GEOM_CLASSES
504 static const char *
505 library_path(void)
506 {
507 	const char *path;
508 
509 	path = getenv("GEOM_LIBRARY_PATH");
510 	if (path == NULL)
511 		path = GEOM_CLASS_DIR;
512 	return (path);
513 }
514 
515 static void
516 load_library(void)
517 {
518 	char *curpath, path[MAXPATHLEN], *tofree, *totalpath;
519 	uint32_t *lib_version;
520 	void *dlh;
521 	int ret;
522 
523 	ret = 0;
524 	tofree = totalpath = strdup(library_path());
525 	if (totalpath == NULL)
526 		err(EXIT_FAILURE, "Not enough memory for library path");
527 
528 	if (strchr(totalpath, ':') != NULL)
529 		curpath = strsep(&totalpath, ":");
530 	else
531 		curpath = totalpath;
532 	/* Traverse the paths to find one that contains the library we want. */
533 	while (curpath != NULL) {
534 		snprintf(path, sizeof(path), "%s/geom_%s.so", curpath,
535 		    class_name);
536 		ret = access(path, F_OK);
537 		if (ret == -1) {
538 			if (errno == ENOENT) {
539 				/*
540 				 * If we cannot find library, try the next
541 				 * path.
542 				 */
543 				curpath = strsep(&totalpath, ":");
544 				continue;
545 			}
546 			err(EXIT_FAILURE, "Cannot access library");
547 		}
548 		break;
549 	}
550 	free(tofree);
551 	/* No library was found, but standard commands can still be used */
552 	if (ret == -1)
553 		return;
554 	dlh = dlopen(path, RTLD_NOW);
555 	if (dlh == NULL)
556 		errx(EXIT_FAILURE, "Cannot open library: %s.", dlerror());
557 	lib_version = dlsym(dlh, "lib_version");
558 	if (lib_version == NULL) {
559 		warnx("Cannot find symbol %s: %s.", "lib_version", dlerror());
560 		dlclose(dlh);
561 		exit(EXIT_FAILURE);
562 	}
563 	if (*lib_version != G_LIB_VERSION) {
564 		dlclose(dlh);
565 		errx(EXIT_FAILURE, "%s and %s are not synchronized.",
566 		    getprogname(), path);
567 	}
568 	version = dlsym(dlh, "version");
569 	if (version == NULL) {
570 		warnx("Cannot find symbol %s: %s.", "version", dlerror());
571 		dlclose(dlh);
572 		exit(EXIT_FAILURE);
573 	}
574 	class_commands = dlsym(dlh, "class_commands");
575 	if (class_commands == NULL) {
576 		warnx("Cannot find symbol %s: %s.", "class_commands",
577 		    dlerror());
578 		dlclose(dlh);
579 		exit(EXIT_FAILURE);
580 	}
581 }
582 #endif	/* !STATIC_GEOM_CLASSES */
583 
584 /*
585  * Class name should be all capital letters.
586  */
587 static void
588 set_class_name(void)
589 {
590 	char *s1, *s2;
591 
592 	s1 = class_name;
593 	for (; *s1 != '\0'; s1++)
594 		*s1 = tolower(*s1);
595 	gclass_name = malloc(strlen(class_name) + 1);
596 	if (gclass_name == NULL)
597 		errx(EXIT_FAILURE, "No memory");
598 	s1 = gclass_name;
599 	s2 = class_name;
600 	for (; *s2 != '\0'; s2++)
601 		*s1++ = toupper(*s2);
602 	*s1 = '\0';
603 }
604 
605 static void
606 get_class(int *argc, char ***argv)
607 {
608 
609 	snprintf(comm, sizeof(comm), "%s", basename((*argv)[0]));
610 	if (strcmp(comm, "geom") == 0) {
611 		if (*argc < 2)
612 			usage();
613 		else if (*argc == 2) {
614 			if (strcmp((*argv)[1], "-h") == 0 ||
615 			    strcmp((*argv)[1], "help") == 0) {
616 				usage();
617 			}
618 		}
619 		strlcatf(comm, sizeof(comm), " %s", (*argv)[1]);
620 		class_name = (*argv)[1];
621 		*argc -= 2;
622 		*argv += 2;
623 	} else if (*comm == 'g') {
624 		class_name = comm + 1;
625 		*argc -= 1;
626 		*argv += 1;
627 	} else {
628 		errx(EXIT_FAILURE, "Invalid utility name.");
629 	}
630 
631 #ifndef STATIC_GEOM_CLASSES
632 	load_library();
633 #else
634 	if (!strcasecmp(class_name, "part")) {
635 		version = &gpart_version;
636 		class_commands = gpart_class_commands;
637 	} else if (!strcasecmp(class_name, "label")) {
638 		version = &glabel_version;
639 		class_commands = glabel_class_commands;
640 	}
641 #endif /* !STATIC_GEOM_CLASSES */
642 
643 	set_class_name();
644 
645 	/* If we can't load or list, it's not a class. */
646 	if (!std_available("load") && !std_available("list"))
647 		errx(EXIT_FAILURE, "Invalid class name.");
648 
649 	if (*argc < 1)
650 		usage();
651 }
652 
653 int
654 main(int argc, char *argv[])
655 {
656 
657 	get_class(&argc, &argv);
658 	run_command(argc, argv);
659 	/* NOTREACHED */
660 
661 	exit(EXIT_FAILURE);
662 }
663 
664 static struct gclass *
665 find_class(struct gmesh *mesh, const char *name)
666 {
667 	struct gclass *classp;
668 
669 	LIST_FOREACH(classp, &mesh->lg_class, lg_class) {
670 		if (strcmp(classp->lg_name, name) == 0)
671 			return (classp);
672 	}
673 	return (NULL);
674 }
675 
676 static struct ggeom *
677 find_geom(struct gclass *classp, const char *name)
678 {
679 	struct ggeom *gp;
680 
681 	LIST_FOREACH(gp, &classp->lg_geom, lg_geom) {
682 		if (strcmp(gp->lg_name, name) == 0)
683 			return (gp);
684 	}
685 	return (NULL);
686 }
687 
688 static void
689 list_one_provider(struct gprovider *pp, const char *prefix)
690 {
691 	struct gconfig *conf;
692 	char buf[5];
693 
694 	printf("Name: %s\n", pp->lg_name);
695 	humanize_number(buf, sizeof(buf), (int64_t)pp->lg_mediasize, "",
696 	    HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);
697 	printf("%sMediasize: %jd (%s)\n", prefix, (intmax_t)pp->lg_mediasize,
698 	    buf);
699 	printf("%sSectorsize: %u\n", prefix, pp->lg_sectorsize);
700 	if (pp->lg_stripesize > 0 || pp->lg_stripeoffset > 0) {
701 		printf("%sStripesize: %ju\n", prefix, pp->lg_stripesize);
702 		printf("%sStripeoffset: %ju\n", prefix, pp->lg_stripeoffset);
703 	}
704 	printf("%sMode: %s\n", prefix, pp->lg_mode);
705 	LIST_FOREACH(conf, &pp->lg_config, lg_config) {
706 		printf("%s%s: %s\n", prefix, conf->lg_name, conf->lg_val);
707 	}
708 }
709 
710 static void
711 list_one_consumer(struct gconsumer *cp, const char *prefix)
712 {
713 	struct gprovider *pp;
714 	struct gconfig *conf;
715 
716 	pp = cp->lg_provider;
717 	if (pp == NULL)
718 		printf("[no provider]\n");
719 	else {
720 		char buf[5];
721 
722 		printf("Name: %s\n", pp->lg_name);
723 		humanize_number(buf, sizeof(buf), (int64_t)pp->lg_mediasize, "",
724 		    HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);
725 		printf("%sMediasize: %jd (%s)\n", prefix,
726 		    (intmax_t)pp->lg_mediasize, buf);
727 		printf("%sSectorsize: %u\n", prefix, pp->lg_sectorsize);
728 		if (pp->lg_stripesize > 0 || pp->lg_stripeoffset > 0) {
729 			printf("%sStripesize: %ju\n", prefix, pp->lg_stripesize);
730 			printf("%sStripeoffset: %ju\n", prefix, pp->lg_stripeoffset);
731 		}
732 		printf("%sMode: %s\n", prefix, cp->lg_mode);
733 	}
734 	LIST_FOREACH(conf, &cp->lg_config, lg_config) {
735 		printf("%s%s: %s\n", prefix, conf->lg_name, conf->lg_val);
736 	}
737 }
738 
739 static void
740 list_one_geom(struct ggeom *gp)
741 {
742 	struct gprovider *pp;
743 	struct gconsumer *cp;
744 	struct gconfig *conf;
745 	unsigned n;
746 
747 	printf("Geom name: %s\n", gp->lg_name);
748 	LIST_FOREACH(conf, &gp->lg_config, lg_config) {
749 		printf("%s: %s\n", conf->lg_name, conf->lg_val);
750 	}
751 	if (!LIST_EMPTY(&gp->lg_provider)) {
752 		printf("Providers:\n");
753 		n = 1;
754 		LIST_FOREACH(pp, &gp->lg_provider, lg_provider) {
755 			printf("%u. ", n++);
756 			list_one_provider(pp, "   ");
757 		}
758 	}
759 	if (!LIST_EMPTY(&gp->lg_consumer)) {
760 		printf("Consumers:\n");
761 		n = 1;
762 		LIST_FOREACH(cp, &gp->lg_consumer, lg_consumer) {
763 			printf("%u. ", n++);
764 			list_one_consumer(cp, "   ");
765 		}
766 	}
767 	printf("\n");
768 }
769 
770 static void
771 std_help(struct gctl_req *req __unused, unsigned flags __unused)
772 {
773 
774 	usage();
775 }
776 
777 static int
778 std_list_available(void)
779 {
780 	struct gmesh mesh;
781 	struct gclass *classp;
782 	int error;
783 
784 	error = geom_gettree(&mesh);
785 	if (error != 0)
786 		errc(EXIT_FAILURE, error, "Cannot get GEOM tree");
787 	classp = find_class(&mesh, gclass_name);
788 	geom_deletetree(&mesh);
789 	if (classp != NULL)
790 		return (1);
791 	return (0);
792 }
793 
794 static void
795 std_list(struct gctl_req *req, unsigned flags __unused)
796 {
797 	struct gmesh mesh;
798 	struct gclass *classp;
799 	struct ggeom *gp;
800 	const char *name;
801 	int all, error, i, nargs;
802 
803 	error = geom_gettree(&mesh);
804 	if (error != 0)
805 		errc(EXIT_FAILURE, error, "Cannot get GEOM tree");
806 	classp = find_class(&mesh, gclass_name);
807 	if (classp == NULL) {
808 		geom_deletetree(&mesh);
809 		errx(EXIT_FAILURE, "Class %s not found.", gclass_name);
810 	}
811 	nargs = gctl_get_int(req, "nargs");
812 	all = gctl_get_int(req, "all");
813 	if (nargs > 0) {
814 		for (i = 0; i < nargs; i++) {
815 			name = gctl_get_ascii(req, "arg%d", i);
816 			gp = find_geom(classp, name);
817 			if (gp == NULL)
818 				errx(EXIT_FAILURE, "No such geom: %s.", name);
819 			list_one_geom(gp);
820 		}
821 	} else {
822 		LIST_FOREACH(gp, &classp->lg_geom, lg_geom) {
823 			if (LIST_EMPTY(&gp->lg_provider) && !all)
824 				continue;
825 			list_one_geom(gp);
826 		}
827 	}
828 	geom_deletetree(&mesh);
829 }
830 
831 static int
832 std_status_available(void)
833 {
834 
835 	/* 'status' command is available when 'list' command is. */
836 	return (std_list_available());
837 }
838 
839 static void
840 status_update_len(struct ggeom *gp, int *name_len, int *status_len)
841 {
842 	struct gconfig *conf;
843 	int len;
844 
845 	assert(gp != NULL);
846 	assert(name_len != NULL);
847 	assert(status_len != NULL);
848 
849 	len = strlen(gp->lg_name);
850 	if (*name_len < len)
851 		*name_len = len;
852 	LIST_FOREACH(conf, &gp->lg_config, lg_config) {
853 		if (strcasecmp(conf->lg_name, "state") == 0) {
854 			len = strlen(conf->lg_val);
855 			if (*status_len < len)
856 				*status_len = len;
857 		}
858 	}
859 }
860 
861 static void
862 status_update_len_prs(struct ggeom *gp, int *name_len, int *status_len)
863 {
864 	struct gprovider *pp;
865 	struct gconfig *conf;
866 	int len, glen;
867 
868 	assert(gp != NULL);
869 	assert(name_len != NULL);
870 	assert(status_len != NULL);
871 
872 	glen = 0;
873 	LIST_FOREACH(conf, &gp->lg_config, lg_config) {
874 		if (strcasecmp(conf->lg_name, "state") == 0) {
875 			glen = strlen(conf->lg_val);
876 			break;
877 		}
878 	}
879 	LIST_FOREACH(pp, &gp->lg_provider, lg_provider) {
880 		len = strlen(pp->lg_name);
881 		if (*name_len < len)
882 			*name_len = len;
883 		len = glen;
884 		LIST_FOREACH(conf, &pp->lg_config, lg_config) {
885 			if (strcasecmp(conf->lg_name, "state") == 0) {
886 				len = strlen(conf->lg_val);
887 				break;
888 			}
889 		}
890 		if (*status_len < len)
891 			*status_len = len;
892 	}
893 }
894 
895 static char *
896 status_one_consumer(struct gconsumer *cp)
897 {
898 	static char buf[256];
899 	struct gprovider *pp;
900 	struct gconfig *conf;
901 	const char *state, *syncr;
902 
903 	pp = cp->lg_provider;
904 	if (pp == NULL)
905 		return (NULL);
906 	state = NULL;
907 	syncr = NULL;
908 	LIST_FOREACH(conf, &cp->lg_config, lg_config) {
909 		if (strcasecmp(conf->lg_name, "state") == 0)
910 			state = conf->lg_val;
911 		if (strcasecmp(conf->lg_name, "synchronized") == 0)
912 			syncr = conf->lg_val;
913 	}
914 	if (state == NULL && syncr == NULL)
915 		snprintf(buf, sizeof(buf), "%s", pp->lg_name);
916 	else if (state != NULL && syncr != NULL) {
917 		snprintf(buf, sizeof(buf), "%s (%s, %s)", pp->lg_name,
918 		    state, syncr);
919 	} else {
920 		snprintf(buf, sizeof(buf), "%s (%s)", pp->lg_name,
921 		    state ? state : syncr);
922 	}
923 	return (buf);
924 }
925 
926 static void
927 status_one_geom(struct ggeom *gp, int script, int name_len, int status_len)
928 {
929 	struct gconsumer *cp;
930 	struct gconfig *conf;
931 	const char *name, *status, *component;
932 	int gotone;
933 
934 	name = gp->lg_name;
935 	status = "N/A";
936 	LIST_FOREACH(conf, &gp->lg_config, lg_config) {
937 		if (strcasecmp(conf->lg_name, "state") == 0) {
938 			status = conf->lg_val;
939 			break;
940 		}
941 	}
942 	gotone = 0;
943 	LIST_FOREACH(cp, &gp->lg_consumer, lg_consumer) {
944 		component = status_one_consumer(cp);
945 		if (component == NULL)
946 			continue;
947 		gotone = 1;
948 		printf("%*s  %*s  %s\n", name_len, name, status_len, status,
949 		    component);
950 		if (!script)
951 			name = status = "";
952 	}
953 	if (!gotone) {
954 		printf("%*s  %*s  %s\n", name_len, name, status_len, status,
955 		    "N/A");
956 	}
957 }
958 
959 static void
960 status_one_geom_prs(struct ggeom *gp, int script, int name_len, int status_len)
961 {
962 	struct gprovider *pp;
963 	struct gconsumer *cp;
964 	struct gconfig *conf;
965 	const char *name, *status, *component;
966 	int gotone;
967 
968 	LIST_FOREACH(pp, &gp->lg_provider, lg_provider) {
969 		name = pp->lg_name;
970 		status = "N/A";
971 		LIST_FOREACH(conf, &gp->lg_config, lg_config) {
972 			if (strcasecmp(conf->lg_name, "state") == 0) {
973 				status = conf->lg_val;
974 				break;
975 			}
976 		}
977 		LIST_FOREACH(conf, &pp->lg_config, lg_config) {
978 			if (strcasecmp(conf->lg_name, "state") == 0) {
979 				status = conf->lg_val;
980 				break;
981 			}
982 		}
983 		gotone = 0;
984 		LIST_FOREACH(cp, &gp->lg_consumer, lg_consumer) {
985 			component = status_one_consumer(cp);
986 			if (component == NULL)
987 				continue;
988 			gotone = 1;
989 			printf("%*s  %*s  %s\n", name_len, name,
990 			    status_len, status, component);
991 			if (!script)
992 				name = status = "";
993 		}
994 		if (!gotone) {
995 			printf("%*s  %*s  %s\n", name_len, name,
996 			    status_len, status, "N/A");
997 		}
998 	}
999 }
1000 
1001 static void
1002 std_status(struct gctl_req *req, unsigned flags __unused)
1003 {
1004 	struct gmesh mesh;
1005 	struct gclass *classp;
1006 	struct ggeom *gp;
1007 	const char *name;
1008 	int name_len, status_len;
1009 	int all, error, geoms, i, n, nargs, script;
1010 
1011 	error = geom_gettree(&mesh);
1012 	if (error != 0)
1013 		errc(EXIT_FAILURE, error, "Cannot get GEOM tree");
1014 	classp = find_class(&mesh, gclass_name);
1015 	if (classp == NULL)
1016 		errx(EXIT_FAILURE, "Class %s not found.", gclass_name);
1017 	nargs = gctl_get_int(req, "nargs");
1018 	all = gctl_get_int(req, "all");
1019 	geoms = gctl_get_int(req, "geoms");
1020 	script = gctl_get_int(req, "script");
1021 	if (script) {
1022 		name_len = 0;
1023 		status_len = 0;
1024 	} else {
1025 		name_len = strlen("Name");
1026 		status_len = strlen("Status");
1027 	}
1028 	if (nargs > 0) {
1029 		for (i = 0, n = 0; i < nargs; i++) {
1030 			name = gctl_get_ascii(req, "arg%d", i);
1031 			gp = find_geom(classp, name);
1032 			if (gp == NULL)
1033 				errx(EXIT_FAILURE, "No such geom: %s.", name);
1034 			if (geoms) {
1035 				status_update_len(gp,
1036 				    &name_len, &status_len);
1037 			} else {
1038 				status_update_len_prs(gp,
1039 				    &name_len, &status_len);
1040 			}
1041 			n++;
1042 		}
1043 		if (n == 0)
1044 			goto end;
1045 	} else {
1046 		n = 0;
1047 		LIST_FOREACH(gp, &classp->lg_geom, lg_geom) {
1048 			if (LIST_EMPTY(&gp->lg_provider) && !all)
1049 				continue;
1050 			if (geoms) {
1051 				status_update_len(gp,
1052 				    &name_len, &status_len);
1053 			} else {
1054 				status_update_len_prs(gp,
1055 				    &name_len, &status_len);
1056 			}
1057 			n++;
1058 		}
1059 		if (n == 0)
1060 			goto end;
1061 	}
1062 	if (!script) {
1063 		printf("%*s  %*s  %s\n", name_len, "Name", status_len, "Status",
1064 		    "Components");
1065 	}
1066 	if (nargs > 0) {
1067 		for (i = 0; i < nargs; i++) {
1068 			name = gctl_get_ascii(req, "arg%d", i);
1069 			gp = find_geom(classp, name);
1070 			if (gp == NULL)
1071 				continue;
1072 			if (geoms) {
1073 				status_one_geom(gp, script, name_len,
1074 				    status_len);
1075 			} else {
1076 				status_one_geom_prs(gp, script, name_len,
1077 				    status_len);
1078 			}
1079 		}
1080 	} else {
1081 		LIST_FOREACH(gp, &classp->lg_geom, lg_geom) {
1082 			if (LIST_EMPTY(&gp->lg_provider) && !all)
1083 				continue;
1084 			if (geoms) {
1085 				status_one_geom(gp, script, name_len,
1086 				    status_len);
1087 			} else {
1088 				status_one_geom_prs(gp, script, name_len,
1089 				    status_len);
1090 			}
1091 		}
1092 	}
1093 end:
1094 	geom_deletetree(&mesh);
1095 }
1096 
1097 static int
1098 std_load_available(void)
1099 {
1100 	char name[MAXPATHLEN], paths[MAXPATHLEN * 8], *p;
1101 	struct stat sb;
1102 	size_t len;
1103 
1104 	snprintf(name, sizeof(name), "g_%s", class_name);
1105 	/*
1106 	 * If already in kernel, "load" command is not available.
1107 	 */
1108 	if (modfind(name) >= 0)
1109 		return (0);
1110 	bzero(paths, sizeof(paths));
1111 	len = sizeof(paths);
1112 	if (sysctlbyname("kern.module_path", paths, &len, NULL, 0) < 0)
1113 		err(EXIT_FAILURE, "sysctl(kern.module_path)");
1114 	for (p = strtok(paths, ";"); p != NULL; p = strtok(NULL, ";")) {
1115 		snprintf(name, sizeof(name), "%s/geom_%s.ko", p, class_name);
1116 		/*
1117 		 * If geom_<name>.ko file exists, "load" command is available.
1118 		 */
1119 		if (stat(name, &sb) == 0)
1120 			return (1);
1121 	}
1122 	return (0);
1123 }
1124 
1125 static void
1126 std_load(struct gctl_req *req __unused, unsigned flags)
1127 {
1128 
1129 	/*
1130 	 * Do nothing special here, because of G_FLAG_LOADKLD flag,
1131 	 * module is already loaded.
1132 	 */
1133 	if ((flags & G_FLAG_VERBOSE) != 0)
1134 		printf("Module available.\n");
1135 }
1136 
1137 static int
1138 std_unload_available(void)
1139 {
1140 	char name[64];
1141 	int id;
1142 
1143 	snprintf(name, sizeof(name), "geom_%s", class_name);
1144 	id = kldfind(name);
1145 	if (id >= 0)
1146 		return (1);
1147 	return (0);
1148 }
1149 
1150 static void
1151 std_unload(struct gctl_req *req, unsigned flags __unused)
1152 {
1153 	char name[64];
1154 	int id;
1155 
1156 	snprintf(name, sizeof(name), "geom_%s", class_name);
1157 	id = kldfind(name);
1158 	if (id < 0) {
1159 		gctl_error(req, "Could not find module: %s.", strerror(errno));
1160 		return;
1161 	}
1162 	if (kldunload(id) < 0) {
1163 		gctl_error(req, "Could not unload module: %s.",
1164 		    strerror(errno));
1165 		return;
1166 	}
1167 }
1168 
1169 static int
1170 std_available(const char *name)
1171 {
1172 
1173 	if (strcmp(name, "help") == 0)
1174 		return (1);
1175 	else if (strcmp(name, "list") == 0)
1176 		return (std_list_available());
1177 	else if (strcmp(name, "status") == 0)
1178 		return (std_status_available());
1179 	else if (strcmp(name, "load") == 0)
1180 		return (std_load_available());
1181 	else if (strcmp(name, "unload") == 0)
1182 		return (std_unload_available());
1183 	else
1184 		assert(!"Unknown standard command.");
1185 	return (0);
1186 }
1187