1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 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 #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 <paths.h> 39 #include <stdio.h> 40 #include <stdlib.h> 41 #include <stdarg.h> 42 #include <stdbool.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 71 #define GEOM_CLASS_WIDTH 10 72 73 static struct g_command *find_command(const char *cmdstr, int flags); 74 static void list_one_geom_by_provider(const char *provider_name); 75 static int std_available(const char *name); 76 static int std_list_available(void); 77 static int std_load_available(void); 78 79 static void std_help(struct gctl_req *req, unsigned flags); 80 static void std_list(struct gctl_req *req, unsigned flags); 81 static void std_status(struct gctl_req *req, unsigned flags); 82 static void std_load(struct gctl_req *req, unsigned flags); 83 static void std_unload(struct gctl_req *req, unsigned flags); 84 85 static struct g_command std_commands[] = { 86 { "help", 0, std_help, G_NULL_OPTS, NULL }, 87 { "list", 0, std_list, 88 { 89 { 'a', "all", NULL, G_TYPE_BOOL }, 90 G_OPT_SENTINEL 91 }, 92 "[-a] [name ...]" 93 }, 94 { "status", 0, std_status, 95 { 96 { 'a', "all", NULL, G_TYPE_BOOL }, 97 { 'g', "geoms", NULL, G_TYPE_BOOL }, 98 { 's', "script", NULL, G_TYPE_BOOL }, 99 G_OPT_SENTINEL 100 }, 101 "[-ags] [name ...]" 102 }, 103 { "load", G_FLAG_VERBOSE | G_FLAG_LOADKLD, std_load, G_NULL_OPTS, 104 NULL }, 105 { "unload", G_FLAG_VERBOSE, std_unload, G_NULL_OPTS, NULL }, 106 G_CMD_SENTINEL 107 }; 108 109 static void 110 usage_command(struct g_command *cmd, const char *prefix) 111 { 112 struct g_option *opt; 113 unsigned i; 114 115 if (cmd->gc_usage != NULL) { 116 char *pos, *ptr, *sptr; 117 118 sptr = ptr = strdup(cmd->gc_usage); 119 while ((pos = strsep(&ptr, "\n")) != NULL) { 120 if (*pos == '\0') 121 continue; 122 fprintf(stderr, "%s %s %s %s\n", prefix, comm, 123 cmd->gc_name, pos); 124 } 125 free(sptr); 126 return; 127 } 128 129 fprintf(stderr, "%s %s %s", prefix, comm, cmd->gc_name); 130 if ((cmd->gc_flags & G_FLAG_VERBOSE) != 0) 131 fprintf(stderr, " [-v]"); 132 for (i = 0; ; i++) { 133 opt = &cmd->gc_options[i]; 134 if (opt->go_name == NULL) 135 break; 136 if (opt->go_val != NULL || G_OPT_TYPE(opt) == G_TYPE_BOOL) 137 fprintf(stderr, " ["); 138 else 139 fprintf(stderr, " "); 140 fprintf(stderr, "-%c", opt->go_char); 141 if (G_OPT_TYPE(opt) != G_TYPE_BOOL) 142 fprintf(stderr, " %s", opt->go_name); 143 if (opt->go_val != NULL || G_OPT_TYPE(opt) == G_TYPE_BOOL) 144 fprintf(stderr, "]"); 145 } 146 fprintf(stderr, "\n"); 147 } 148 149 static void 150 usage(void) 151 { 152 153 if (class_name == NULL) { 154 fprintf(stderr, "usage: geom <class> <command> [options]\n"); 155 fprintf(stderr, " geom -p <provider-name>\n"); 156 fprintf(stderr, " geom -t\n"); 157 exit(EXIT_FAILURE); 158 } else { 159 struct g_command *cmd; 160 const char *prefix; 161 unsigned i; 162 163 prefix = "usage:"; 164 if (class_commands != NULL) { 165 for (i = 0; ; i++) { 166 cmd = &class_commands[i]; 167 if (cmd->gc_name == NULL) 168 break; 169 usage_command(cmd, prefix); 170 prefix = " "; 171 } 172 } 173 for (i = 0; ; i++) { 174 cmd = &std_commands[i]; 175 if (cmd->gc_name == NULL) 176 break; 177 /* 178 * If class defines command, which has the same name as 179 * standard command, skip it, because it was already 180 * shown on usage(). 181 */ 182 if (find_command(cmd->gc_name, GEOM_CLASS_CMDS) != NULL) 183 continue; 184 usage_command(cmd, prefix); 185 prefix = " "; 186 } 187 exit(EXIT_FAILURE); 188 } 189 } 190 191 static void 192 load_module(void) 193 { 194 char name1[64], name2[64]; 195 196 snprintf(name1, sizeof(name1), "g_%s", class_name); 197 snprintf(name2, sizeof(name2), "geom_%s", class_name); 198 if (modfind(name1) < 0) { 199 /* Not present in kernel, try loading it. */ 200 if (kldload(name2) < 0 || modfind(name1) < 0) { 201 if (errno != EEXIST) { 202 err(EXIT_FAILURE, "cannot load %s", name2); 203 } 204 } 205 } 206 } 207 208 static int 209 strlcatf(char *str, size_t size, const char *format, ...) 210 { 211 size_t len; 212 va_list ap; 213 int ret; 214 215 len = strlen(str); 216 str += len; 217 size -= len; 218 219 va_start(ap, format); 220 ret = vsnprintf(str, size, format, ap); 221 va_end(ap); 222 223 return (ret); 224 } 225 226 /* 227 * Find given option in options available for given command. 228 */ 229 static struct g_option * 230 find_option(struct g_command *cmd, char ch) 231 { 232 struct g_option *opt; 233 unsigned i; 234 235 for (i = 0; ; i++) { 236 opt = &cmd->gc_options[i]; 237 if (opt->go_name == NULL) 238 return (NULL); 239 if (opt->go_char == ch) 240 return (opt); 241 } 242 /* NOTREACHED */ 243 return (NULL); 244 } 245 246 /* 247 * Add given option to gctl_req. 248 */ 249 static void 250 set_option(struct gctl_req *req, struct g_option *opt, const char *val) 251 { 252 const char *optname; 253 uint64_t number; 254 void *ptr; 255 256 if (G_OPT_ISMULTI(opt)) { 257 size_t optnamesize; 258 259 if (G_OPT_NUM(opt) == UCHAR_MAX) 260 errx(EXIT_FAILURE, "Too many -%c options.", opt->go_char); 261 262 /* 263 * Base option name length plus 3 bytes for option number 264 * (max. 255 options) plus 1 byte for terminating '\0'. 265 */ 266 optnamesize = strlen(opt->go_name) + 3 + 1; 267 ptr = malloc(optnamesize); 268 if (ptr == NULL) 269 errx(EXIT_FAILURE, "No memory."); 270 snprintf(ptr, optnamesize, "%s%u", opt->go_name, G_OPT_NUM(opt)); 271 G_OPT_NUMINC(opt); 272 optname = ptr; 273 } else { 274 optname = opt->go_name; 275 } 276 277 if (G_OPT_TYPE(opt) == G_TYPE_NUMBER) { 278 if (expand_number(val, &number) == -1) { 279 err(EXIT_FAILURE, "Invalid value for '%c' argument", 280 opt->go_char); 281 } 282 ptr = malloc(sizeof(intmax_t)); 283 if (ptr == NULL) 284 errx(EXIT_FAILURE, "No memory."); 285 *(intmax_t *)ptr = number; 286 opt->go_val = ptr; 287 gctl_ro_param(req, optname, sizeof(intmax_t), opt->go_val); 288 } else if (G_OPT_TYPE(opt) == G_TYPE_STRING) { 289 gctl_ro_param(req, optname, -1, val); 290 } else if (G_OPT_TYPE(opt) == G_TYPE_BOOL) { 291 ptr = malloc(sizeof(int)); 292 if (ptr == NULL) 293 errx(EXIT_FAILURE, "No memory."); 294 *(int *)ptr = *val - '0'; 295 opt->go_val = ptr; 296 gctl_ro_param(req, optname, sizeof(int), opt->go_val); 297 } else { 298 assert(!"Invalid type"); 299 } 300 301 if (G_OPT_ISMULTI(opt)) 302 free(__DECONST(char *, optname)); 303 } 304 305 /* 306 * 1. Add given argument by caller. 307 * 2. Add default values of not given arguments. 308 * 3. Add the rest of arguments. 309 */ 310 static void 311 parse_arguments(struct g_command *cmd, struct gctl_req *req, int *argc, 312 char ***argv) 313 { 314 struct g_option *opt; 315 char opts[64]; 316 unsigned i; 317 int ch, vcount; 318 319 *opts = '\0'; 320 if ((cmd->gc_flags & G_FLAG_VERBOSE) != 0) 321 strlcat(opts, "v", sizeof(opts)); 322 for (i = 0; ; i++) { 323 opt = &cmd->gc_options[i]; 324 if (opt->go_name == NULL) 325 break; 326 assert(G_OPT_TYPE(opt) != 0); 327 assert((opt->go_type & ~(G_TYPE_MASK | G_TYPE_MULTI)) == 0); 328 /* Multiple bool arguments makes no sense. */ 329 assert(G_OPT_TYPE(opt) != G_TYPE_BOOL || 330 (opt->go_type & G_TYPE_MULTI) == 0); 331 strlcatf(opts, sizeof(opts), "%c", opt->go_char); 332 if (G_OPT_TYPE(opt) != G_TYPE_BOOL) 333 strlcat(opts, ":", sizeof(opts)); 334 } 335 336 /* 337 * Add specified arguments. 338 */ 339 vcount = 0; 340 while ((ch = getopt(*argc, *argv, opts)) != -1) { 341 /* Standard (not passed to kernel) options. */ 342 if (ch == 'v' && (cmd->gc_flags & G_FLAG_VERBOSE) != 0) 343 verbose = 1; 344 /* Options passed to kernel. */ 345 opt = find_option(cmd, ch); 346 if (opt == NULL) { 347 if (ch == 'v' && (cmd->gc_flags & G_FLAG_VERBOSE) != 0){ 348 if (++vcount < 2) 349 continue; 350 else 351 warnx("Option 'v' specified twice."); 352 } 353 usage(); 354 } 355 if (!G_OPT_ISMULTI(opt) && G_OPT_ISDONE(opt)) { 356 warnx("Option '%c' specified twice.", opt->go_char); 357 usage(); 358 } 359 G_OPT_DONE(opt); 360 361 if (G_OPT_TYPE(opt) == G_TYPE_BOOL) 362 set_option(req, opt, "1"); 363 else 364 set_option(req, opt, optarg); 365 } 366 *argc -= optind; 367 *argv += optind; 368 369 /* 370 * Add not specified arguments, but with default values. 371 */ 372 for (i = 0; ; i++) { 373 opt = &cmd->gc_options[i]; 374 if (opt->go_name == NULL) 375 break; 376 if (G_OPT_ISDONE(opt)) 377 continue; 378 379 if (G_OPT_TYPE(opt) == G_TYPE_BOOL) { 380 assert(opt->go_val == NULL); 381 set_option(req, opt, "0"); 382 } else { 383 if (opt->go_val == NULL) { 384 warnx("Option '%c' not specified.", 385 opt->go_char); 386 usage(); 387 } else if (opt->go_val == G_VAL_OPTIONAL) { 388 /* add nothing. */ 389 } else { 390 set_option(req, opt, opt->go_val); 391 } 392 } 393 } 394 395 /* 396 * Add rest of given arguments. 397 */ 398 gctl_ro_param(req, "nargs", sizeof(int), argc); 399 for (i = 0; i < (unsigned)*argc; i++) { 400 char argname[16]; 401 402 snprintf(argname, sizeof(argname), "arg%u", i); 403 gctl_ro_param(req, argname, -1, (*argv)[i]); 404 } 405 } 406 407 /* 408 * Find given command in commands available for given class. 409 */ 410 static struct g_command * 411 find_command(const char *cmdstr, int flags) 412 { 413 struct g_command *cmd; 414 unsigned i; 415 416 /* 417 * First try to find command defined by loaded library. 418 */ 419 if ((flags & GEOM_CLASS_CMDS) != 0 && class_commands != NULL) { 420 for (i = 0; ; i++) { 421 cmd = &class_commands[i]; 422 if (cmd->gc_name == NULL) 423 break; 424 if (strcmp(cmd->gc_name, cmdstr) == 0) 425 return (cmd); 426 } 427 } 428 /* 429 * Now try to find in standard commands. 430 */ 431 if ((flags & GEOM_STD_CMDS) != 0) { 432 for (i = 0; ; i++) { 433 cmd = &std_commands[i]; 434 if (cmd->gc_name == NULL) 435 break; 436 if (strcmp(cmd->gc_name, cmdstr) == 0) 437 return (cmd); 438 } 439 } 440 return (NULL); 441 } 442 443 static unsigned 444 set_flags(struct g_command *cmd) 445 { 446 unsigned flags = 0; 447 448 if ((cmd->gc_flags & G_FLAG_VERBOSE) != 0 && verbose) 449 flags |= G_FLAG_VERBOSE; 450 451 return (flags); 452 } 453 454 /* 455 * Run command. 456 */ 457 static void 458 run_command(int argc, char *argv[]) 459 { 460 struct g_command *cmd; 461 struct gctl_req *req; 462 const char *errstr; 463 char buf[4096]; 464 465 /* First try to find a command defined by a class. */ 466 cmd = find_command(argv[0], GEOM_CLASS_CMDS); 467 if (cmd == NULL) { 468 /* Now, try to find a standard command. */ 469 cmd = find_command(argv[0], GEOM_STD_CMDS); 470 if (cmd == NULL) { 471 warnx("Unknown command: %s.", argv[0]); 472 usage(); 473 } 474 if (!std_available(cmd->gc_name)) { 475 warnx("Command '%s' not available; " 476 "try 'load' first.", argv[0]); 477 exit(EXIT_FAILURE); 478 } 479 } 480 if ((cmd->gc_flags & G_FLAG_LOADKLD) != 0) 481 load_module(); 482 483 req = gctl_get_handle(); 484 gctl_ro_param(req, "class", -1, gclass_name); 485 gctl_ro_param(req, "verb", -1, argv[0]); 486 if (version != NULL) 487 gctl_ro_param(req, "version", sizeof(*version), version); 488 parse_arguments(cmd, req, &argc, &argv); 489 490 buf[0] = '\0'; 491 if (cmd->gc_func != NULL) { 492 unsigned flags; 493 494 flags = set_flags(cmd); 495 cmd->gc_func(req, flags); 496 errstr = req->error; 497 } else { 498 gctl_add_param(req, "output", sizeof(buf), buf, 499 GCTL_PARAM_WR | GCTL_PARAM_ASCII); 500 errstr = gctl_issue(req); 501 } 502 if (errstr != NULL && errstr[0] != '\0') { 503 warnx("%s", errstr); 504 /* Suppress EXIT_FAILURE for warnings */ 505 if (strncmp(errstr, "warning: ", strlen("warning: ")) == 0) 506 req->nerror = 0; 507 if (req->nerror != 0) { 508 gctl_free(req); 509 exit(EXIT_FAILURE); 510 } 511 } 512 if (buf[0] != '\0') 513 printf("%s", buf); 514 gctl_free(req); 515 if (verbose) 516 printf("Done.\n"); 517 exit(EXIT_SUCCESS); 518 } 519 520 #ifndef STATIC_GEOM_CLASSES 521 static const char * 522 library_path(void) 523 { 524 const char *path; 525 526 path = getenv("GEOM_LIBRARY_PATH"); 527 if (path == NULL) 528 path = GEOM_CLASS_DIR; 529 return (path); 530 } 531 532 static void 533 load_library(void) 534 { 535 char *curpath, path[MAXPATHLEN], *tofree, *totalpath; 536 uint32_t *lib_version; 537 void *dlh; 538 int ret; 539 540 ret = 0; 541 tofree = totalpath = strdup(library_path()); 542 if (totalpath == NULL) 543 err(EXIT_FAILURE, "Not enough memory for library path"); 544 545 if (strchr(totalpath, ':') != NULL) 546 curpath = strsep(&totalpath, ":"); 547 else 548 curpath = totalpath; 549 /* Traverse the paths to find one that contains the library we want. */ 550 while (curpath != NULL) { 551 snprintf(path, sizeof(path), "%s/geom_%s.so", curpath, 552 class_name); 553 ret = access(path, F_OK); 554 if (ret == -1) { 555 if (errno == ENOENT) { 556 /* 557 * If we cannot find library, try the next 558 * path. 559 */ 560 curpath = strsep(&totalpath, ":"); 561 continue; 562 } 563 err(EXIT_FAILURE, "Cannot access library"); 564 } 565 break; 566 } 567 free(tofree); 568 /* No library was found, but standard commands can still be used */ 569 if (ret == -1) 570 return; 571 dlh = dlopen(path, RTLD_NOW); 572 if (dlh == NULL) 573 errx(EXIT_FAILURE, "Cannot open library: %s.", dlerror()); 574 lib_version = dlsym(dlh, "lib_version"); 575 if (lib_version == NULL) { 576 warnx("Cannot find symbol %s: %s.", "lib_version", dlerror()); 577 dlclose(dlh); 578 exit(EXIT_FAILURE); 579 } 580 if (*lib_version != G_LIB_VERSION) { 581 dlclose(dlh); 582 errx(EXIT_FAILURE, "%s and %s are not synchronized.", 583 getprogname(), path); 584 } 585 version = dlsym(dlh, "version"); 586 if (version == NULL) { 587 warnx("Cannot find symbol %s: %s.", "version", dlerror()); 588 dlclose(dlh); 589 exit(EXIT_FAILURE); 590 } 591 class_commands = dlsym(dlh, "class_commands"); 592 if (class_commands == NULL) { 593 warnx("Cannot find symbol %s: %s.", "class_commands", 594 dlerror()); 595 dlclose(dlh); 596 exit(EXIT_FAILURE); 597 } 598 } 599 #endif /* !STATIC_GEOM_CLASSES */ 600 601 /* 602 * Class name should be all capital letters. 603 */ 604 static void 605 set_class_name(void) 606 { 607 char *s1, *s2; 608 609 s1 = class_name; 610 for (; *s1 != '\0'; s1++) 611 *s1 = tolower(*s1); 612 gclass_name = malloc(strlen(class_name) + 1); 613 if (gclass_name == NULL) 614 errx(EXIT_FAILURE, "No memory"); 615 s1 = gclass_name; 616 s2 = class_name; 617 for (; *s2 != '\0'; s2++) 618 *s1++ = toupper(*s2); 619 *s1 = '\0'; 620 } 621 622 static void 623 get_class(int *argc, char ***argv) 624 { 625 626 snprintf(comm, sizeof(comm), "%s", basename((*argv)[0])); 627 if (strcmp(comm, "geom") == 0) { 628 if (*argc < 2) 629 usage(); 630 else if (*argc == 2) { 631 if (strcmp((*argv)[1], "-h") == 0 || 632 strcmp((*argv)[1], "help") == 0) { 633 usage(); 634 } 635 } 636 strlcatf(comm, sizeof(comm), " %s", (*argv)[1]); 637 class_name = (*argv)[1]; 638 *argc -= 2; 639 *argv += 2; 640 } else if (*comm == 'g') { 641 class_name = comm + 1; 642 *argc -= 1; 643 *argv += 1; 644 } else { 645 errx(EXIT_FAILURE, "Invalid utility name."); 646 } 647 648 #ifndef STATIC_GEOM_CLASSES 649 load_library(); 650 #else 651 if (!strcasecmp(class_name, "part")) { 652 version = &gpart_version; 653 class_commands = gpart_class_commands; 654 } else if (!strcasecmp(class_name, "label")) { 655 version = &glabel_version; 656 class_commands = glabel_class_commands; 657 } 658 #endif /* !STATIC_GEOM_CLASSES */ 659 660 set_class_name(); 661 662 /* If we can't load or list, it's not a class. */ 663 if (!std_load_available() && !std_list_available()) 664 errx(EXIT_FAILURE, "Invalid class name '%s'.", class_name); 665 666 if (*argc < 1) 667 usage(); 668 } 669 670 static struct ggeom * 671 find_geom_by_provider(struct gmesh *mesh, const char *name) 672 { 673 struct gclass *classp; 674 struct ggeom *gp; 675 struct gprovider *pp; 676 677 LIST_FOREACH(classp, &mesh->lg_class, lg_class) { 678 LIST_FOREACH(gp, &classp->lg_geom, lg_geom) { 679 LIST_FOREACH(pp, &gp->lg_provider, lg_provider) { 680 if (strcmp(pp->lg_name, name) == 0) 681 return (gp); 682 } 683 } 684 } 685 686 return (NULL); 687 } 688 689 static int 690 compute_tree_width_geom(struct gmesh *mesh, struct ggeom *gp, int indent) 691 { 692 struct gclass *classp2; 693 struct ggeom *gp2; 694 struct gconsumer *cp2; 695 struct gprovider *pp; 696 int max_width, width; 697 698 max_width = width = indent + strlen(gp->lg_name); 699 700 LIST_FOREACH(pp, &gp->lg_provider, lg_provider) { 701 LIST_FOREACH(classp2, &mesh->lg_class, lg_class) { 702 LIST_FOREACH(gp2, &classp2->lg_geom, lg_geom) { 703 LIST_FOREACH(cp2, 704 &gp2->lg_consumer, lg_consumer) { 705 if (pp != cp2->lg_provider) 706 continue; 707 width = compute_tree_width_geom(mesh, 708 gp2, indent + 2); 709 if (width > max_width) 710 max_width = width; 711 } 712 } 713 } 714 } 715 716 return (max_width); 717 } 718 719 static int 720 compute_tree_width(struct gmesh *mesh) 721 { 722 struct gclass *classp; 723 struct ggeom *gp; 724 int max_width, width; 725 726 max_width = width = 0; 727 728 LIST_FOREACH(classp, &mesh->lg_class, lg_class) { 729 LIST_FOREACH(gp, &classp->lg_geom, lg_geom) { 730 if (!LIST_EMPTY(&gp->lg_consumer)) 731 continue; 732 width = compute_tree_width_geom(mesh, gp, 0); 733 if (width > max_width) 734 max_width = width; 735 } 736 } 737 738 return (max_width); 739 } 740 741 static void 742 show_tree_geom(struct gmesh *mesh, struct ggeom *gp, int indent, int width) 743 { 744 struct gclass *classp2; 745 struct ggeom *gp2; 746 struct gconsumer *cp2; 747 struct gprovider *pp; 748 749 if (LIST_EMPTY(&gp->lg_provider)) { 750 printf("%*s%-*.*s %-*.*s\n", indent, "", 751 width - indent, width - indent, gp->lg_name, 752 GEOM_CLASS_WIDTH, GEOM_CLASS_WIDTH, gp->lg_class->lg_name); 753 return; 754 } 755 756 LIST_FOREACH(pp, &gp->lg_provider, lg_provider) { 757 printf("%*s%-*.*s %-*.*s %s\n", indent, "", 758 width - indent, width - indent, gp->lg_name, 759 GEOM_CLASS_WIDTH, GEOM_CLASS_WIDTH, gp->lg_class->lg_name, 760 pp->lg_name); 761 762 LIST_FOREACH(classp2, &mesh->lg_class, lg_class) { 763 LIST_FOREACH(gp2, &classp2->lg_geom, lg_geom) { 764 LIST_FOREACH(cp2, 765 &gp2->lg_consumer, lg_consumer) { 766 if (pp != cp2->lg_provider) 767 continue; 768 show_tree_geom(mesh, gp2, 769 indent + 2, width); 770 } 771 } 772 } 773 } 774 } 775 776 static void 777 show_tree(void) 778 { 779 struct gmesh mesh; 780 struct gclass *classp; 781 struct ggeom *gp; 782 int error, width; 783 784 error = geom_gettree(&mesh); 785 if (error != 0) 786 errc(EXIT_FAILURE, error, "Cannot get GEOM tree"); 787 788 width = compute_tree_width(&mesh); 789 790 printf("%-*.*s %-*.*s %s\n", 791 width, width, "Geom", 792 GEOM_CLASS_WIDTH, GEOM_CLASS_WIDTH, "Class", 793 "Provider"); 794 795 LIST_FOREACH(classp, &mesh.lg_class, lg_class) { 796 LIST_FOREACH(gp, &classp->lg_geom, lg_geom) { 797 if (!LIST_EMPTY(&gp->lg_consumer)) 798 continue; 799 show_tree_geom(&mesh, gp, 0, width); 800 } 801 } 802 } 803 804 int 805 main(int argc, char *argv[]) 806 { 807 char *provider_name; 808 bool tflag; 809 int ch; 810 811 provider_name = NULL; 812 tflag = false; 813 814 if (strcmp(getprogname(), "geom") == 0) { 815 while ((ch = getopt(argc, argv, "hp:t")) != -1) { 816 switch (ch) { 817 case 'p': 818 provider_name = strdup(optarg); 819 if (provider_name == NULL) 820 err(1, "strdup"); 821 break; 822 case 't': 823 tflag = true; 824 break; 825 case 'h': 826 default: 827 usage(); 828 } 829 } 830 831 /* 832 * Don't adjust argc and argv, it would break get_class(). 833 */ 834 } 835 836 if (tflag && provider_name != NULL) { 837 errx(EXIT_FAILURE, 838 "At most one of -P and -t may be specified."); 839 } 840 841 if (provider_name != NULL) { 842 list_one_geom_by_provider(provider_name); 843 return (0); 844 } 845 846 if (tflag) { 847 show_tree(); 848 return (0); 849 } 850 851 get_class(&argc, &argv); 852 run_command(argc, argv); 853 /* NOTREACHED */ 854 855 exit(EXIT_FAILURE); 856 } 857 858 static struct gclass * 859 find_class(struct gmesh *mesh, const char *name) 860 { 861 struct gclass *classp; 862 863 LIST_FOREACH(classp, &mesh->lg_class, lg_class) { 864 if (strcmp(classp->lg_name, name) == 0) 865 return (classp); 866 } 867 return (NULL); 868 } 869 870 static struct ggeom * 871 find_geom(struct gclass *classp, const char *name) 872 { 873 struct ggeom *gp; 874 875 if (strncmp(name, _PATH_DEV, sizeof(_PATH_DEV) - 1) == 0) 876 name += sizeof(_PATH_DEV) - 1; 877 878 LIST_FOREACH(gp, &classp->lg_geom, lg_geom) { 879 if (strcmp(gp->lg_name, name) == 0) 880 return (gp); 881 } 882 return (NULL); 883 } 884 885 static void 886 list_one_provider(struct gprovider *pp, const char *prefix) 887 { 888 struct gconfig *conf; 889 char buf[5]; 890 891 printf("Name: %s\n", pp->lg_name); 892 humanize_number(buf, sizeof(buf), (int64_t)pp->lg_mediasize, "", 893 HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL); 894 printf("%sMediasize: %jd (%s)\n", prefix, (intmax_t)pp->lg_mediasize, 895 buf); 896 printf("%sSectorsize: %u\n", prefix, pp->lg_sectorsize); 897 if (pp->lg_stripesize > 0 || pp->lg_stripeoffset > 0) { 898 printf("%sStripesize: %ju\n", prefix, pp->lg_stripesize); 899 printf("%sStripeoffset: %ju\n", prefix, pp->lg_stripeoffset); 900 } 901 printf("%sMode: %s\n", prefix, pp->lg_mode); 902 LIST_FOREACH(conf, &pp->lg_config, lg_config) { 903 printf("%s%s: %s\n", prefix, conf->lg_name, conf->lg_val); 904 } 905 } 906 907 static void 908 list_one_consumer(struct gconsumer *cp, const char *prefix) 909 { 910 struct gprovider *pp; 911 struct gconfig *conf; 912 913 pp = cp->lg_provider; 914 if (pp == NULL) 915 printf("[no provider]\n"); 916 else { 917 char buf[5]; 918 919 printf("Name: %s\n", pp->lg_name); 920 humanize_number(buf, sizeof(buf), (int64_t)pp->lg_mediasize, "", 921 HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL); 922 printf("%sMediasize: %jd (%s)\n", prefix, 923 (intmax_t)pp->lg_mediasize, buf); 924 printf("%sSectorsize: %u\n", prefix, pp->lg_sectorsize); 925 if (pp->lg_stripesize > 0 || pp->lg_stripeoffset > 0) { 926 printf("%sStripesize: %ju\n", prefix, pp->lg_stripesize); 927 printf("%sStripeoffset: %ju\n", prefix, pp->lg_stripeoffset); 928 } 929 printf("%sMode: %s\n", prefix, cp->lg_mode); 930 } 931 LIST_FOREACH(conf, &cp->lg_config, lg_config) { 932 printf("%s%s: %s\n", prefix, conf->lg_name, conf->lg_val); 933 } 934 } 935 936 static void 937 list_one_geom(struct ggeom *gp) 938 { 939 struct gprovider *pp; 940 struct gconsumer *cp; 941 struct gconfig *conf; 942 unsigned n; 943 944 printf("Geom name: %s\n", gp->lg_name); 945 LIST_FOREACH(conf, &gp->lg_config, lg_config) { 946 printf("%s: %s\n", conf->lg_name, conf->lg_val); 947 } 948 if (!LIST_EMPTY(&gp->lg_provider)) { 949 printf("Providers:\n"); 950 n = 1; 951 LIST_FOREACH(pp, &gp->lg_provider, lg_provider) { 952 printf("%u. ", n++); 953 list_one_provider(pp, " "); 954 } 955 } 956 if (!LIST_EMPTY(&gp->lg_consumer)) { 957 printf("Consumers:\n"); 958 n = 1; 959 LIST_FOREACH(cp, &gp->lg_consumer, lg_consumer) { 960 printf("%u. ", n++); 961 list_one_consumer(cp, " "); 962 } 963 } 964 printf("\n"); 965 } 966 967 static void 968 list_one_geom_by_provider(const char *provider_name) 969 { 970 struct gmesh mesh; 971 struct ggeom *gp; 972 int error; 973 974 error = geom_gettree(&mesh); 975 if (error != 0) 976 errc(EXIT_FAILURE, error, "Cannot get GEOM tree"); 977 978 gp = find_geom_by_provider(&mesh, provider_name); 979 if (gp == NULL) 980 errx(EXIT_FAILURE, "Cannot find provider '%s'.", provider_name); 981 982 printf("Geom class: %s\n", gp->lg_class->lg_name); 983 list_one_geom(gp); 984 } 985 986 static void 987 std_help(struct gctl_req *req __unused, unsigned flags __unused) 988 { 989 990 usage(); 991 } 992 993 static int 994 std_list_available(void) 995 { 996 struct gmesh mesh; 997 struct gclass *classp; 998 int error; 999 1000 error = geom_gettree_geom(&mesh, gclass_name, "", 0); 1001 if (error != 0) 1002 errc(EXIT_FAILURE, error, "Cannot get GEOM tree"); 1003 classp = find_class(&mesh, gclass_name); 1004 geom_deletetree(&mesh); 1005 if (classp != NULL) 1006 return (1); 1007 return (0); 1008 } 1009 1010 static void 1011 std_list(struct gctl_req *req, unsigned flags __unused) 1012 { 1013 struct gmesh mesh; 1014 struct gclass *classp; 1015 struct ggeom *gp; 1016 const char *name; 1017 int all, error, i, nargs; 1018 1019 nargs = gctl_get_int(req, "nargs"); 1020 if (nargs == 1) { 1021 error = geom_gettree_geom(&mesh, gclass_name, 1022 gctl_get_ascii(req, "arg0"), 1); 1023 } else 1024 error = geom_gettree(&mesh); 1025 if (error != 0) 1026 errc(EXIT_FAILURE, error, "Cannot get GEOM tree"); 1027 classp = find_class(&mesh, gclass_name); 1028 if (classp == NULL) { 1029 geom_deletetree(&mesh); 1030 errx(EXIT_FAILURE, "Class '%s' not found.", gclass_name); 1031 } 1032 all = gctl_get_int(req, "all"); 1033 if (nargs > 0) { 1034 for (i = 0; i < nargs; i++) { 1035 name = gctl_get_ascii(req, "arg%d", i); 1036 gp = find_geom(classp, name); 1037 if (gp == NULL) { 1038 errx(EXIT_FAILURE, "Class '%s' does not have " 1039 "an instance named '%s'.", 1040 gclass_name, name); 1041 } 1042 list_one_geom(gp); 1043 } 1044 } else { 1045 LIST_FOREACH(gp, &classp->lg_geom, lg_geom) { 1046 if (LIST_EMPTY(&gp->lg_provider) && !all) 1047 continue; 1048 list_one_geom(gp); 1049 } 1050 } 1051 geom_deletetree(&mesh); 1052 } 1053 1054 static int 1055 std_status_available(void) 1056 { 1057 1058 /* 'status' command is available when 'list' command is. */ 1059 return (std_list_available()); 1060 } 1061 1062 static void 1063 status_update_len(struct ggeom *gp, int *name_len, int *status_len) 1064 { 1065 struct gconfig *conf; 1066 int len; 1067 1068 assert(gp != NULL); 1069 assert(name_len != NULL); 1070 assert(status_len != NULL); 1071 1072 len = strlen(gp->lg_name); 1073 if (*name_len < len) 1074 *name_len = len; 1075 LIST_FOREACH(conf, &gp->lg_config, lg_config) { 1076 if (strcasecmp(conf->lg_name, "state") == 0) { 1077 len = strlen(conf->lg_val); 1078 if (*status_len < len) 1079 *status_len = len; 1080 } 1081 } 1082 } 1083 1084 static void 1085 status_update_len_prs(struct ggeom *gp, int *name_len, int *status_len) 1086 { 1087 struct gprovider *pp; 1088 struct gconfig *conf; 1089 int len, glen; 1090 1091 assert(gp != NULL); 1092 assert(name_len != NULL); 1093 assert(status_len != NULL); 1094 1095 glen = 0; 1096 LIST_FOREACH(conf, &gp->lg_config, lg_config) { 1097 if (strcasecmp(conf->lg_name, "state") == 0) { 1098 glen = strlen(conf->lg_val); 1099 break; 1100 } 1101 } 1102 LIST_FOREACH(pp, &gp->lg_provider, lg_provider) { 1103 len = strlen(pp->lg_name); 1104 if (*name_len < len) 1105 *name_len = len; 1106 len = glen; 1107 LIST_FOREACH(conf, &pp->lg_config, lg_config) { 1108 if (strcasecmp(conf->lg_name, "state") == 0) { 1109 len = strlen(conf->lg_val); 1110 break; 1111 } 1112 } 1113 if (*status_len < len) 1114 *status_len = len; 1115 } 1116 } 1117 1118 static char * 1119 status_one_consumer(struct gconsumer *cp) 1120 { 1121 static char buf[256]; 1122 struct gprovider *pp; 1123 struct gconfig *conf; 1124 const char *state, *syncr; 1125 1126 pp = cp->lg_provider; 1127 if (pp == NULL) 1128 return (NULL); 1129 state = NULL; 1130 syncr = NULL; 1131 LIST_FOREACH(conf, &cp->lg_config, lg_config) { 1132 if (strcasecmp(conf->lg_name, "state") == 0) 1133 state = conf->lg_val; 1134 if (strcasecmp(conf->lg_name, "synchronized") == 0) 1135 syncr = conf->lg_val; 1136 } 1137 if (state == NULL && syncr == NULL) 1138 snprintf(buf, sizeof(buf), "%s", pp->lg_name); 1139 else if (state != NULL && syncr != NULL) { 1140 snprintf(buf, sizeof(buf), "%s (%s, %s)", pp->lg_name, 1141 state, syncr); 1142 } else { 1143 snprintf(buf, sizeof(buf), "%s (%s)", pp->lg_name, 1144 state ? state : syncr); 1145 } 1146 return (buf); 1147 } 1148 1149 static void 1150 status_one_geom(struct ggeom *gp, int script, int name_len, int status_len) 1151 { 1152 struct gconsumer *cp; 1153 struct gconfig *conf; 1154 const char *name, *status, *component; 1155 int gotone; 1156 1157 name = gp->lg_name; 1158 status = "N/A"; 1159 LIST_FOREACH(conf, &gp->lg_config, lg_config) { 1160 if (strcasecmp(conf->lg_name, "state") == 0) { 1161 status = conf->lg_val; 1162 break; 1163 } 1164 } 1165 gotone = 0; 1166 LIST_FOREACH(cp, &gp->lg_consumer, lg_consumer) { 1167 component = status_one_consumer(cp); 1168 if (component == NULL) 1169 continue; 1170 gotone = 1; 1171 printf("%*s %*s %s\n", name_len, name, status_len, status, 1172 component); 1173 if (!script) 1174 name = status = ""; 1175 } 1176 if (!gotone) { 1177 printf("%*s %*s %s\n", name_len, name, status_len, status, 1178 "N/A"); 1179 } 1180 } 1181 1182 static void 1183 status_one_geom_prs(struct ggeom *gp, int script, int name_len, int status_len) 1184 { 1185 struct gprovider *pp; 1186 struct gconsumer *cp; 1187 struct gconfig *conf; 1188 const char *name, *status, *component; 1189 int gotone; 1190 1191 LIST_FOREACH(pp, &gp->lg_provider, lg_provider) { 1192 name = pp->lg_name; 1193 status = "N/A"; 1194 LIST_FOREACH(conf, &gp->lg_config, lg_config) { 1195 if (strcasecmp(conf->lg_name, "state") == 0) { 1196 status = conf->lg_val; 1197 break; 1198 } 1199 } 1200 LIST_FOREACH(conf, &pp->lg_config, lg_config) { 1201 if (strcasecmp(conf->lg_name, "state") == 0) { 1202 status = conf->lg_val; 1203 break; 1204 } 1205 } 1206 gotone = 0; 1207 LIST_FOREACH(cp, &gp->lg_consumer, lg_consumer) { 1208 component = status_one_consumer(cp); 1209 if (component == NULL) 1210 continue; 1211 gotone = 1; 1212 printf("%*s %*s %s\n", name_len, name, 1213 status_len, status, component); 1214 if (!script) 1215 name = status = ""; 1216 } 1217 if (!gotone) { 1218 printf("%*s %*s %s\n", name_len, name, 1219 status_len, status, "N/A"); 1220 } 1221 } 1222 } 1223 1224 static void 1225 std_status(struct gctl_req *req, unsigned flags __unused) 1226 { 1227 struct gmesh mesh; 1228 struct gclass *classp; 1229 struct ggeom *gp; 1230 const char *name; 1231 int name_len, status_len; 1232 int all, error, geoms, i, n, nargs, script; 1233 1234 error = geom_gettree(&mesh); 1235 if (error != 0) 1236 errc(EXIT_FAILURE, error, "Cannot get GEOM tree"); 1237 classp = find_class(&mesh, gclass_name); 1238 if (classp == NULL) 1239 errx(EXIT_FAILURE, "Class %s not found.", gclass_name); 1240 nargs = gctl_get_int(req, "nargs"); 1241 all = gctl_get_int(req, "all"); 1242 geoms = gctl_get_int(req, "geoms"); 1243 script = gctl_get_int(req, "script"); 1244 if (script) { 1245 name_len = 0; 1246 status_len = 0; 1247 } else { 1248 name_len = strlen("Name"); 1249 status_len = strlen("Status"); 1250 } 1251 if (nargs > 0) { 1252 for (i = 0, n = 0; i < nargs; i++) { 1253 name = gctl_get_ascii(req, "arg%d", i); 1254 gp = find_geom(classp, name); 1255 if (gp == NULL) 1256 errx(EXIT_FAILURE, "No such geom: %s.", name); 1257 if (geoms) { 1258 status_update_len(gp, 1259 &name_len, &status_len); 1260 } else { 1261 status_update_len_prs(gp, 1262 &name_len, &status_len); 1263 } 1264 n++; 1265 } 1266 if (n == 0) 1267 goto end; 1268 } else { 1269 n = 0; 1270 LIST_FOREACH(gp, &classp->lg_geom, lg_geom) { 1271 if (LIST_EMPTY(&gp->lg_provider) && !all) 1272 continue; 1273 if (geoms) { 1274 status_update_len(gp, 1275 &name_len, &status_len); 1276 } else { 1277 status_update_len_prs(gp, 1278 &name_len, &status_len); 1279 } 1280 n++; 1281 } 1282 if (n == 0) 1283 goto end; 1284 } 1285 if (!script) { 1286 printf("%*s %*s %s\n", name_len, "Name", status_len, "Status", 1287 "Components"); 1288 } 1289 if (nargs > 0) { 1290 for (i = 0; i < nargs; i++) { 1291 name = gctl_get_ascii(req, "arg%d", i); 1292 gp = find_geom(classp, name); 1293 if (gp == NULL) 1294 continue; 1295 if (geoms) { 1296 status_one_geom(gp, script, name_len, 1297 status_len); 1298 } else { 1299 status_one_geom_prs(gp, script, name_len, 1300 status_len); 1301 } 1302 } 1303 } else { 1304 LIST_FOREACH(gp, &classp->lg_geom, lg_geom) { 1305 if (LIST_EMPTY(&gp->lg_provider) && !all) 1306 continue; 1307 if (geoms) { 1308 status_one_geom(gp, script, name_len, 1309 status_len); 1310 } else { 1311 status_one_geom_prs(gp, script, name_len, 1312 status_len); 1313 } 1314 } 1315 } 1316 end: 1317 geom_deletetree(&mesh); 1318 } 1319 1320 static int 1321 std_load_available(void) 1322 { 1323 char name[MAXPATHLEN], paths[MAXPATHLEN * 8], *p; 1324 struct stat sb; 1325 size_t len; 1326 1327 snprintf(name, sizeof(name), "g_%s", class_name); 1328 /* 1329 * If already in kernel, "load" command is NOP. 1330 */ 1331 if (modfind(name) >= 0) 1332 return (1); 1333 bzero(paths, sizeof(paths)); 1334 len = sizeof(paths); 1335 if (sysctlbyname("kern.module_path", paths, &len, NULL, 0) < 0) 1336 err(EXIT_FAILURE, "sysctl(kern.module_path)"); 1337 for (p = strtok(paths, ";"); p != NULL; p = strtok(NULL, ";")) { 1338 snprintf(name, sizeof(name), "%s/geom_%s.ko", p, class_name); 1339 /* 1340 * If geom_<name>.ko file exists, "load" command is available. 1341 */ 1342 if (stat(name, &sb) == 0) 1343 return (1); 1344 } 1345 return (0); 1346 } 1347 1348 static void 1349 std_load(struct gctl_req *req __unused, unsigned flags) 1350 { 1351 1352 /* 1353 * Do nothing special here, because of G_FLAG_LOADKLD flag, 1354 * module is already loaded. 1355 */ 1356 if ((flags & G_FLAG_VERBOSE) != 0) 1357 printf("Module available.\n"); 1358 } 1359 1360 static int 1361 std_unload_available(void) 1362 { 1363 char name[64]; 1364 int id; 1365 1366 snprintf(name, sizeof(name), "geom_%s", class_name); 1367 id = kldfind(name); 1368 if (id >= 0) 1369 return (1); 1370 return (0); 1371 } 1372 1373 static void 1374 std_unload(struct gctl_req *req, unsigned flags __unused) 1375 { 1376 char name[64]; 1377 int id; 1378 1379 snprintf(name, sizeof(name), "geom_%s", class_name); 1380 id = kldfind(name); 1381 if (id < 0) { 1382 gctl_error(req, "Could not find module: %s.", strerror(errno)); 1383 return; 1384 } 1385 if (kldunload(id) < 0) { 1386 gctl_error(req, "Could not unload module: %s.", 1387 strerror(errno)); 1388 return; 1389 } 1390 } 1391 1392 static int 1393 std_available(const char *name) 1394 { 1395 1396 if (strcmp(name, "help") == 0) 1397 return (1); 1398 else if (strcmp(name, "list") == 0) 1399 return (std_list_available()); 1400 else if (strcmp(name, "status") == 0) 1401 return (std_status_available()); 1402 else if (strcmp(name, "load") == 0) 1403 return (std_load_available()); 1404 else if (strcmp(name, "unload") == 0) 1405 return (std_unload_available()); 1406 else 1407 assert(!"Unknown standard command."); 1408 return (0); 1409 } 1410