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