1 /*- 2 * Copyright (c) 2004-2005 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 55 static char comm[MAXPATHLEN], *class_name = NULL, *gclass_name = NULL; 56 static uint32_t *version = NULL; 57 static int verbose = 0; 58 static struct g_command *class_commands = NULL; 59 60 #define GEOM_CLASS_CMDS 0x01 61 #define GEOM_STD_CMDS 0x02 62 static struct g_command *find_command(const char *cmdstr, int flags); 63 static int std_available(const char *name); 64 65 static void std_help(struct gctl_req *req, unsigned flags); 66 static void std_list(struct gctl_req *req, unsigned flags); 67 static void std_status(struct gctl_req *req, unsigned flags); 68 static void std_load(struct gctl_req *req, unsigned flags); 69 static void std_unload(struct gctl_req *req, unsigned flags); 70 71 struct g_command std_commands[] = { 72 { "help", 0, std_help, G_NULL_OPTS, NULL }, 73 { "list", 0, std_list, G_NULL_OPTS, 74 "[name ...]" 75 }, 76 { "status", 0, std_status, 77 { 78 { 's', "script", NULL, G_TYPE_NONE }, 79 G_OPT_SENTINEL 80 }, 81 "[-s] [name ...]" 82 }, 83 { "load", G_FLAG_VERBOSE | G_FLAG_LOADKLD, std_load, G_NULL_OPTS, NULL }, 84 { "unload", G_FLAG_VERBOSE, std_unload, G_NULL_OPTS, NULL }, 85 G_CMD_SENTINEL 86 }; 87 88 static void 89 usage_command(struct g_command *cmd, const char *prefix) 90 { 91 struct g_option *opt; 92 unsigned i; 93 94 fprintf(stderr, "%s %s %s", prefix, comm, cmd->gc_name); 95 if (cmd->gc_usage != NULL) { 96 fprintf(stderr, " %s\n", cmd->gc_usage); 97 return; 98 } 99 if ((cmd->gc_flags & G_FLAG_VERBOSE) != 0) 100 fprintf(stderr, " [-v]"); 101 for (i = 0; ; i++) { 102 opt = &cmd->gc_options[i]; 103 if (opt->go_name == NULL) 104 break; 105 if (opt->go_val != NULL || opt->go_type == G_TYPE_NONE) 106 fprintf(stderr, " ["); 107 else 108 fprintf(stderr, " "); 109 fprintf(stderr, "-%c", opt->go_char); 110 if (opt->go_type != G_TYPE_NONE) 111 fprintf(stderr, " %s", opt->go_name); 112 if (opt->go_val != NULL || opt->go_type == G_TYPE_NONE) 113 fprintf(stderr, "]"); 114 } 115 fprintf(stderr, "\n"); 116 } 117 118 static void 119 usage(void) 120 { 121 122 if (class_name == NULL) { 123 errx(EXIT_FAILURE, "usage: %s <class> <command> [options]", 124 "geom"); 125 } else { 126 struct g_command *cmd; 127 const char *prefix; 128 unsigned i; 129 130 prefix = "usage:"; 131 if (class_commands != NULL) { 132 for (i = 0; ; i++) { 133 cmd = &class_commands[i]; 134 if (cmd->gc_name == NULL) 135 break; 136 usage_command(cmd, prefix); 137 prefix = " "; 138 } 139 } 140 for (i = 0; ; i++) { 141 cmd = &std_commands[i]; 142 if (cmd->gc_name == NULL) 143 break; 144 /* 145 * If class defines command, which has the same name as 146 * standard command, skip it, because it was already 147 * shown on usage(). 148 */ 149 if (find_command(cmd->gc_name, GEOM_CLASS_CMDS) != NULL) 150 continue; 151 usage_command(cmd, prefix); 152 prefix = " "; 153 } 154 exit(EXIT_FAILURE); 155 } 156 } 157 158 static void 159 load_module(void) 160 { 161 char name1[64], name2[64]; 162 163 snprintf(name1, sizeof(name1), "g_%s", class_name); 164 snprintf(name2, sizeof(name2), "geom_%s", class_name); 165 if (modfind(name1) < 0) { 166 /* Not present in kernel, try loading it. */ 167 if (kldload(name2) < 0 || modfind(name1) < 0) { 168 if (errno != EEXIST) { 169 errx(EXIT_FAILURE, 170 "%s module not available!", name2); 171 } 172 } 173 } 174 } 175 176 static int 177 strlcatf(char *str, size_t size, const char *format, ...) 178 { 179 size_t len; 180 va_list ap; 181 int ret; 182 183 len = strlen(str); 184 str += len; 185 size -= len; 186 187 va_start(ap, format); 188 ret = vsnprintf(str, size, format, ap); 189 va_end(ap); 190 191 return (ret); 192 } 193 194 /* 195 * Find given option in options available for given command. 196 */ 197 static struct g_option * 198 find_option(struct g_command *cmd, char ch) 199 { 200 struct g_option *opt; 201 unsigned i; 202 203 for (i = 0; ; i++) { 204 opt = &cmd->gc_options[i]; 205 if (opt->go_name == NULL) 206 return (NULL); 207 if (opt->go_char == ch) 208 return (opt); 209 } 210 /* NOTREACHED */ 211 return (NULL); 212 } 213 214 /* 215 * Add given option to gctl_req. 216 */ 217 static void 218 set_option(struct gctl_req *req, struct g_option *opt, const char *val) 219 { 220 221 if (opt->go_type == G_TYPE_NUMBER) { 222 intmax_t number; 223 224 errno = 0; 225 number = strtoimax(optarg, NULL, 0); 226 if (errno != 0) { 227 err(EXIT_FAILURE, "Invalid value for '%c' argument.", 228 opt->go_char); 229 } 230 opt->go_val = malloc(sizeof(intmax_t)); 231 if (opt->go_val == NULL) 232 errx(EXIT_FAILURE, "No memory."); 233 *(intmax_t *)opt->go_val = number; 234 235 gctl_ro_param(req, opt->go_name, sizeof(intmax_t), opt->go_val); 236 } else if (opt->go_type == G_TYPE_STRING) { 237 gctl_ro_param(req, opt->go_name, -1, optarg); 238 } else /* if (opt->go_type == G_TYPE_NONE) */ { 239 opt->go_val = malloc(sizeof(int)); 240 if (opt->go_val == NULL) 241 errx(EXIT_FAILURE, "No memory."); 242 *(int *)opt->go_val = *val - '0'; 243 244 gctl_ro_param(req, opt->go_name, sizeof(int), 245 opt->go_val); 246 } 247 } 248 249 /* 250 * 1. Add given argument by caller. 251 * 2. Add default values of not given arguments. 252 * 3. Add the rest of arguments. 253 */ 254 static void 255 parse_arguments(struct g_command *cmd, struct gctl_req *req, int *argc, 256 char ***argv) 257 { 258 struct g_option *opt; 259 char opts[64]; 260 unsigned i; 261 int ch; 262 263 *opts = '\0'; 264 if ((cmd->gc_flags & G_FLAG_VERBOSE) != 0) 265 strlcat(opts, "v", sizeof(opts)); 266 for (i = 0; ; i++) { 267 opt = &cmd->gc_options[i]; 268 if (opt->go_name == NULL) 269 break; 270 strlcatf(opts, sizeof(opts), "%c", opt->go_char); 271 if (opt->go_type != G_TYPE_NONE) 272 strlcat(opts, ":", sizeof(opts)); 273 } 274 275 /* 276 * Add specified arguments. 277 */ 278 while ((ch = getopt(*argc, *argv, opts)) != -1) { 279 /* Standard (not passed to kernel) options. */ 280 switch (ch) { 281 case 'v': 282 verbose = 1; 283 continue; 284 } 285 /* Options passed to kernel. */ 286 opt = find_option(cmd, ch); 287 if (opt == NULL) 288 usage(); 289 if (G_OPT_ISDONE(opt)) { 290 fprintf(stderr, "Flag '%c' specified twice.\n", 291 opt->go_char); 292 usage(); 293 } 294 G_OPT_DONE(opt); 295 296 if (opt->go_type == G_TYPE_NONE) 297 set_option(req, opt, "1"); 298 else 299 set_option(req, opt, optarg); 300 } 301 *argc -= optind; 302 *argv += optind; 303 304 /* 305 * Add not specified arguments, but with default values. 306 */ 307 for (i = 0; ; i++) { 308 opt = &cmd->gc_options[i]; 309 if (opt->go_name == NULL) 310 break; 311 if (G_OPT_ISDONE(opt)) 312 continue; 313 314 if (opt->go_type == G_TYPE_NONE) { 315 assert(opt->go_val == NULL); 316 set_option(req, opt, "0"); 317 } else { 318 if (opt->go_val == NULL) { 319 fprintf(stderr, "Flag '%c' not specified.\n", 320 opt->go_char); 321 usage(); 322 } else { 323 if (opt->go_type == G_TYPE_NUMBER) { 324 gctl_ro_param(req, opt->go_name, 325 sizeof(intmax_t), opt->go_val); 326 } else /* if (opt->go_type == G_TYPE_STRING)*/ { 327 gctl_ro_param(req, opt->go_name, -1, 328 opt->go_val); 329 } 330 } 331 } 332 } 333 /* 334 * Add rest of given arguments. 335 */ 336 gctl_ro_param(req, "nargs", sizeof(int), argc); 337 for (i = 0; i < (unsigned)*argc; i++) { 338 char argname[16]; 339 340 snprintf(argname, sizeof(argname), "arg%u", i); 341 gctl_ro_param(req, argname, -1, (*argv)[i]); 342 } 343 } 344 345 /* 346 * Find given command in commands available for given class. 347 */ 348 static struct g_command * 349 find_command(const char *cmdstr, int flags) 350 { 351 struct g_command *cmd; 352 unsigned i; 353 354 /* 355 * First try to find command defined by loaded library. 356 */ 357 if ((flags & GEOM_CLASS_CMDS) != 0 && class_commands != NULL) { 358 for (i = 0; ; i++) { 359 cmd = &class_commands[i]; 360 if (cmd->gc_name == NULL) 361 break; 362 if (strcmp(cmd->gc_name, cmdstr) == 0) 363 return (cmd); 364 } 365 } 366 /* 367 * Now try to find in standard commands. 368 */ 369 if ((flags & GEOM_STD_CMDS) != 0) { 370 for (i = 0; ; i++) { 371 cmd = &std_commands[i]; 372 if (cmd->gc_name == NULL) 373 break; 374 if (strcmp(cmd->gc_name, cmdstr) == 0) 375 return (cmd); 376 } 377 } 378 return (NULL); 379 } 380 381 static unsigned 382 set_flags(struct g_command *cmd) 383 { 384 unsigned flags = 0; 385 386 if ((cmd->gc_flags & G_FLAG_VERBOSE) != 0 && verbose) 387 flags |= G_FLAG_VERBOSE; 388 389 return (flags); 390 } 391 392 /* 393 * Run command. 394 */ 395 static void 396 run_command(int argc, char *argv[]) 397 { 398 struct g_command *cmd; 399 struct gctl_req *req; 400 const char *errstr; 401 char buf[4096]; 402 403 /* First try to find a command defined by a class. */ 404 cmd = find_command(argv[0], GEOM_CLASS_CMDS); 405 if (cmd == NULL) { 406 /* Now, try to find a standard command. */ 407 cmd = find_command(argv[0], GEOM_STD_CMDS); 408 if (cmd == NULL) { 409 fprintf(stderr, "Unknown command: %s\n", argv[0]); 410 usage(); 411 } 412 if (!std_available(cmd->gc_name)) { 413 fprintf(stderr, "Command '%s' not available.\n", 414 argv[0]); 415 exit(EXIT_FAILURE); 416 } 417 } 418 if ((cmd->gc_flags & G_FLAG_LOADKLD) != 0) 419 load_module(); 420 421 req = gctl_get_handle(); 422 gctl_ro_param(req, "class", -1, gclass_name); 423 gctl_ro_param(req, "verb", -1, argv[0]); 424 if (version != NULL) 425 gctl_ro_param(req, "version", sizeof(*version), version); 426 parse_arguments(cmd, req, &argc, &argv); 427 428 bzero(buf, sizeof(buf)); 429 if (cmd->gc_func != NULL) { 430 unsigned flags; 431 432 flags = set_flags(cmd); 433 cmd->gc_func(req, flags); 434 errstr = req->error; 435 } else { 436 gctl_rw_param(req, "output", sizeof(buf), buf); 437 errstr = gctl_issue(req); 438 } 439 if (errstr != NULL && errstr[0] != '\0') { 440 fprintf(stderr, "%s\n", errstr); 441 if (strncmp(errstr, "warning: ", strlen("warning: ")) != 0) { 442 gctl_free(req); 443 exit(EXIT_FAILURE); 444 } 445 } 446 if (buf[0] != '\0') 447 printf("%s", buf); 448 gctl_free(req); 449 if (verbose) 450 printf("Done.\n"); 451 exit(EXIT_SUCCESS); 452 } 453 454 static const char * 455 library_path(void) 456 { 457 const char *path; 458 459 path = getenv("GEOM_LIBRARY_PATH"); 460 if (path == NULL) 461 path = CLASS_DIR; 462 return (path); 463 } 464 465 static void 466 load_library(void) 467 { 468 char path[MAXPATHLEN]; 469 uint32_t *lib_version; 470 void *dlh; 471 472 snprintf(path, sizeof(path), "%s/geom_%s.so", library_path(), 473 class_name); 474 if (access(path, F_OK) == -1) { 475 if (errno == ENOENT) { 476 /* 477 * If we cannot find library, that's ok, standard 478 * commands can still be used. 479 */ 480 return; 481 } 482 err(EXIT_FAILURE, "Cannot access library"); 483 } 484 dlh = dlopen(path, RTLD_NOW); 485 if (dlh == NULL) 486 errx(EXIT_FAILURE, "Cannot open library: %s.", dlerror()); 487 lib_version = dlsym(dlh, "lib_version"); 488 if (lib_version == NULL) { 489 fprintf(stderr, "Cannot find symbol %s: %s.\n", "lib_version", 490 dlerror()); 491 dlclose(dlh); 492 exit(EXIT_FAILURE); 493 } 494 if (*lib_version != G_LIB_VERSION) { 495 dlclose(dlh); 496 errx(EXIT_FAILURE, "%s and %s are not synchronized.", 497 getprogname(), path); 498 } 499 version = dlsym(dlh, "version"); 500 if (version == NULL) { 501 fprintf(stderr, "Cannot find symbol %s: %s.\n", "version", 502 dlerror()); 503 dlclose(dlh); 504 exit(EXIT_FAILURE); 505 } 506 class_commands = dlsym(dlh, "class_commands"); 507 if (class_commands == NULL) { 508 fprintf(stderr, "Cannot find symbol %s: %s.\n", 509 "class_commands", dlerror()); 510 dlclose(dlh); 511 exit(EXIT_FAILURE); 512 } 513 } 514 515 /* 516 * Class name should be all capital letters. 517 */ 518 static void 519 set_class_name(void) 520 { 521 char *s1, *s2; 522 523 s1 = class_name; 524 for (; *s1 != '\0'; s1++) 525 *s1 = tolower(*s1); 526 gclass_name = malloc(strlen(class_name)); 527 if (gclass_name == NULL) 528 errx(EXIT_FAILURE, "No memory"); 529 s1 = gclass_name; 530 s2 = class_name; 531 for (; *s2 != '\0'; s2++) 532 *s1++ = toupper(*s2); 533 *s1 = '\0'; 534 } 535 536 static void 537 get_class(int *argc, char ***argv) 538 { 539 540 snprintf(comm, sizeof(comm), "%s", basename((*argv)[0])); 541 if (strcmp(comm, "geom") == 0) { 542 if (*argc < 2) 543 usage(); 544 else if (*argc == 2) { 545 if (strcmp((*argv)[1], "-h") == 0 || 546 strcmp((*argv)[1], "help") == 0) { 547 usage(); 548 } 549 } 550 strlcatf(comm, sizeof(comm), " %s", (*argv)[1]); 551 class_name = (*argv)[1]; 552 *argc -= 2; 553 *argv += 2; 554 } else if (*comm == 'g') { 555 class_name = comm + 1; 556 *argc -= 1; 557 *argv += 1; 558 } else { 559 errx(EXIT_FAILURE, "Invalid utility name."); 560 } 561 set_class_name(); 562 load_library(); 563 if (*argc < 1) 564 usage(); 565 } 566 567 int 568 main(int argc, char *argv[]) 569 { 570 571 get_class(&argc, &argv); 572 run_command(argc, argv); 573 /* NOTREACHED */ 574 575 exit(EXIT_FAILURE); 576 } 577 578 static struct gclass * 579 find_class(struct gmesh *mesh, const char *name) 580 { 581 struct gclass *classp; 582 583 LIST_FOREACH(classp, &mesh->lg_class, lg_class) { 584 if (strcmp(classp->lg_name, name) == 0) 585 return (classp); 586 } 587 return (NULL); 588 } 589 590 static struct ggeom * 591 find_geom(struct gclass *classp, const char *name) 592 { 593 struct ggeom *gp; 594 595 LIST_FOREACH(gp, &classp->lg_geom, lg_geom) { 596 if (strcmp(gp->lg_name, name) == 0) 597 return (gp); 598 } 599 return (NULL); 600 } 601 602 static void 603 list_one_provider(struct gprovider *pp, const char *prefix) 604 { 605 struct gconfig *conf; 606 char buf[5]; 607 608 printf("Name: %s\n", pp->lg_name); 609 humanize_number(buf, sizeof(buf), (int64_t)pp->lg_mediasize, "", 610 HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL); 611 printf("%sMediasize: %jd (%s)\n", prefix, (intmax_t)pp->lg_mediasize, 612 buf); 613 printf("%sSectorsize: %u\n", prefix, pp->lg_sectorsize); 614 printf("%sMode: %s\n", prefix, pp->lg_mode); 615 LIST_FOREACH(conf, &pp->lg_config, lg_config) { 616 printf("%s%s: %s\n", prefix, conf->lg_name, conf->lg_val); 617 } 618 } 619 620 static void 621 list_one_consumer(struct gconsumer *cp, const char *prefix) 622 { 623 struct gprovider *pp; 624 struct gconfig *conf; 625 626 pp = cp->lg_provider; 627 if (pp == NULL) 628 printf("[no provider]\n"); 629 else { 630 char buf[5]; 631 632 printf("Name: %s\n", pp->lg_name); 633 humanize_number(buf, sizeof(buf), (int64_t)pp->lg_mediasize, "", 634 HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL); 635 printf("%sMediasize: %jd (%s)\n", prefix, 636 (intmax_t)pp->lg_mediasize, buf); 637 printf("%sSectorsize: %u\n", prefix, pp->lg_sectorsize); 638 printf("%sMode: %s\n", prefix, cp->lg_mode); 639 } 640 LIST_FOREACH(conf, &cp->lg_config, lg_config) { 641 printf("%s%s: %s\n", prefix, conf->lg_name, conf->lg_val); 642 } 643 } 644 645 static void 646 list_one_geom(struct ggeom *gp) 647 { 648 struct gprovider *pp; 649 struct gconsumer *cp; 650 struct gconfig *conf; 651 unsigned n; 652 653 printf("Geom name: %s\n", gp->lg_name); 654 LIST_FOREACH(conf, &gp->lg_config, lg_config) { 655 printf("%s: %s\n", conf->lg_name, conf->lg_val); 656 } 657 if (!LIST_EMPTY(&gp->lg_provider)) { 658 printf("Providers:\n"); 659 n = 1; 660 LIST_FOREACH(pp, &gp->lg_provider, lg_provider) { 661 printf("%u. ", n++); 662 list_one_provider(pp, " "); 663 } 664 } 665 if (!LIST_EMPTY(&gp->lg_consumer)) { 666 printf("Consumers:\n"); 667 n = 1; 668 LIST_FOREACH(cp, &gp->lg_consumer, lg_consumer) { 669 printf("%u. ", n++); 670 list_one_consumer(cp, " "); 671 } 672 } 673 printf("\n"); 674 } 675 676 static void 677 std_help(struct gctl_req *req __unused, unsigned flags __unused) 678 { 679 680 usage(); 681 } 682 683 static int 684 std_list_available(void) 685 { 686 struct gmesh mesh; 687 struct gclass *classp; 688 int error; 689 690 error = geom_gettree(&mesh); 691 if (error != 0) { 692 fprintf(stderr, "Cannot get GEOM tree: %s.\n", strerror(error)); 693 exit(EXIT_FAILURE); 694 } 695 classp = find_class(&mesh, gclass_name); 696 geom_deletetree(&mesh); 697 if (classp != NULL) 698 return (1); 699 return (0); 700 } 701 702 static void 703 std_list(struct gctl_req *req, unsigned flags __unused) 704 { 705 struct gmesh mesh; 706 struct gclass *classp; 707 struct ggeom *gp; 708 const char *name; 709 int error, i, nargs; 710 711 error = geom_gettree(&mesh); 712 if (error != 0) { 713 fprintf(stderr, "Cannot get GEOM tree: %s.\n", strerror(error)); 714 exit(EXIT_FAILURE); 715 } 716 classp = find_class(&mesh, gclass_name); 717 if (classp == NULL) { 718 geom_deletetree(&mesh); 719 fprintf(stderr, "Class %s not found.\n", gclass_name); 720 return; 721 } 722 nargs = gctl_get_int(req, "nargs"); 723 if (nargs > 0) { 724 for (i = 0; i < nargs; i++) { 725 name = gctl_get_ascii(req, "arg%d", i); 726 gp = find_geom(classp, name); 727 if (gp != NULL) 728 list_one_geom(gp); 729 else 730 fprintf(stderr, "No such geom: %s.\n", name); 731 } 732 } else { 733 LIST_FOREACH(gp, &classp->lg_geom, lg_geom) { 734 if (LIST_EMPTY(&gp->lg_provider)) 735 continue; 736 list_one_geom(gp); 737 } 738 } 739 geom_deletetree(&mesh); 740 } 741 742 static int 743 std_status_available(void) 744 { 745 746 /* 'status' command is available when 'list' command is. */ 747 return (std_list_available()); 748 } 749 750 static void 751 status_update_len(struct ggeom *gp, int *name_len, int *status_len) 752 { 753 struct gprovider *pp; 754 struct gconfig *conf; 755 int len; 756 757 assert(gp != NULL); 758 assert(name_len != NULL); 759 assert(status_len != NULL); 760 761 pp = LIST_FIRST(&gp->lg_provider); 762 if (pp != NULL) 763 len = strlen(pp->lg_name); 764 else 765 len = strlen(gp->lg_name); 766 if (*name_len < len) 767 *name_len = len; 768 LIST_FOREACH(conf, &gp->lg_config, lg_config) { 769 if (strcasecmp(conf->lg_name, "state") == 0) { 770 len = strlen(conf->lg_val); 771 if (*status_len < len) 772 *status_len = len; 773 } 774 } 775 } 776 777 static char * 778 status_one_consumer(struct gconsumer *cp) 779 { 780 static char buf[256]; 781 struct gprovider *pp; 782 struct gconfig *conf; 783 784 pp = cp->lg_provider; 785 if (pp == NULL) 786 return (NULL); 787 LIST_FOREACH(conf, &cp->lg_config, lg_config) { 788 if (strcasecmp(conf->lg_name, "synchronized") == 0) 789 break; 790 } 791 if (conf == NULL) 792 snprintf(buf, sizeof(buf), "%s", pp->lg_name); 793 else { 794 snprintf(buf, sizeof(buf), "%s (%s)", pp->lg_name, 795 conf->lg_val); 796 } 797 return (buf); 798 } 799 800 static void 801 status_one_geom(struct ggeom *gp, int script, int name_len, int status_len) 802 { 803 struct gprovider *pp; 804 struct gconsumer *cp; 805 struct gconfig *conf; 806 const char *name, *status, *component; 807 int gotone; 808 809 pp = LIST_FIRST(&gp->lg_provider); 810 if (pp != NULL) 811 name = pp->lg_name; 812 else 813 name = gp->lg_name; 814 LIST_FOREACH(conf, &gp->lg_config, lg_config) { 815 if (strcasecmp(conf->lg_name, "state") == 0) 816 break; 817 } 818 if (conf == NULL) 819 status = "N/A"; 820 else 821 status = conf->lg_val; 822 gotone = 0; 823 LIST_FOREACH(cp, &gp->lg_consumer, lg_consumer) { 824 component = status_one_consumer(cp); 825 if (component == NULL) 826 continue; 827 gotone = 1; 828 printf("%*s %*s %s\n", name_len, name, status_len, status, 829 component); 830 if (!script) 831 name = status = ""; 832 } 833 if (!gotone) { 834 printf("%*s %*s %s\n", name_len, name, status_len, status, 835 "N/A"); 836 } 837 } 838 839 static void 840 std_status(struct gctl_req *req, unsigned flags __unused) 841 { 842 struct gmesh mesh; 843 struct gclass *classp; 844 struct ggeom *gp; 845 const char *name; 846 int name_len, status_len; 847 int error, i, n, nargs, script; 848 849 error = geom_gettree(&mesh); 850 if (error != 0) { 851 fprintf(stderr, "Cannot get GEOM tree: %s.\n", strerror(error)); 852 exit(EXIT_FAILURE); 853 } 854 classp = find_class(&mesh, gclass_name); 855 if (classp == NULL) { 856 fprintf(stderr, "Class %s not found.\n", gclass_name); 857 goto end; 858 } 859 nargs = gctl_get_int(req, "nargs"); 860 script = gctl_get_int(req, "script"); 861 name_len = strlen("Name"); 862 status_len = strlen("Status"); 863 if (nargs > 0) { 864 for (i = 0, n = 0; i < nargs; i++) { 865 name = gctl_get_ascii(req, "arg%d", i); 866 gp = find_geom(classp, name); 867 if (gp == NULL) 868 fprintf(stderr, "No such geom: %s.\n", name); 869 else { 870 status_update_len(gp, &name_len, &status_len); 871 n++; 872 } 873 } 874 if (n == 0) 875 goto end; 876 } else { 877 n = 0; 878 LIST_FOREACH(gp, &classp->lg_geom, lg_geom) { 879 if (LIST_EMPTY(&gp->lg_provider)) 880 continue; 881 status_update_len(gp, &name_len, &status_len); 882 n++; 883 } 884 if (n == 0) 885 goto end; 886 } 887 if (!script) { 888 printf("%*s %*s %s\n", name_len, "Name", status_len, "Status", 889 "Components"); 890 } 891 if (nargs > 0) { 892 for (i = 0; i < nargs; i++) { 893 name = gctl_get_ascii(req, "arg%d", i); 894 gp = find_geom(classp, name); 895 if (gp != NULL) { 896 status_one_geom(gp, script, name_len, 897 status_len); 898 } 899 } 900 } else { 901 LIST_FOREACH(gp, &classp->lg_geom, lg_geom) { 902 if (LIST_EMPTY(&gp->lg_provider)) 903 continue; 904 status_one_geom(gp, script, name_len, status_len); 905 } 906 } 907 end: 908 geom_deletetree(&mesh); 909 } 910 911 static int 912 std_load_available(void) 913 { 914 char name[MAXPATHLEN], paths[MAXPATHLEN * 8], *p; 915 struct stat sb; 916 size_t len; 917 918 snprintf(name, sizeof(name), "g_%s", class_name); 919 /* 920 * If already in kernel, "load" command is not available. 921 */ 922 if (modfind(name) >= 0) 923 return (0); 924 bzero(paths, sizeof(paths)); 925 len = sizeof(paths); 926 if (sysctlbyname("kern.module_path", paths, &len, NULL, 0) < 0) 927 err(EXIT_FAILURE, "sysctl(kern.module_path)"); 928 for (p = strtok(paths, ";"); p != NULL; p = strtok(NULL, ";")) { 929 snprintf(name, sizeof(name), "%s/geom_%s.ko", p, class_name); 930 /* 931 * If geom_<name>.ko file exists, "load" command is available. 932 */ 933 if (stat(name, &sb) == 0) 934 return (1); 935 } 936 return (0); 937 } 938 939 static void 940 std_load(struct gctl_req *req __unused, unsigned flags) 941 { 942 943 /* 944 * Do nothing special here, because of G_FLAG_LOADKLD flag, 945 * module is already loaded. 946 */ 947 if ((flags & G_FLAG_VERBOSE) != 0) 948 printf("Module available.\n"); 949 } 950 951 static int 952 std_unload_available(void) 953 { 954 char name[64]; 955 int id; 956 957 snprintf(name, sizeof(name), "geom_%s", class_name); 958 id = kldfind(name); 959 if (id >= 0) 960 return (1); 961 return (0); 962 } 963 964 static void 965 std_unload(struct gctl_req *req, unsigned flags __unused) 966 { 967 char name[64]; 968 int id; 969 970 snprintf(name, sizeof(name), "geom_%s", class_name); 971 id = kldfind(name); 972 if (id < 0) { 973 gctl_error(req, "Could not find module: %s.", strerror(errno)); 974 return; 975 } 976 if (kldunload(id) < 0) { 977 gctl_error(req, "Could not unload module: %s.", 978 strerror(errno)); 979 return; 980 } 981 } 982 983 static int 984 std_available(const char *name) 985 { 986 987 if (strcmp(name, "help") == 0) 988 return (1); 989 else if (strcmp(name, "list") == 0) 990 return (std_list_available()); 991 else if (strcmp(name, "status") == 0) 992 return (std_status_available()); 993 else if (strcmp(name, "load") == 0) 994 return (std_load_available()); 995 else if (strcmp(name, "unload") == 0) 996 return (std_unload_available()); 997 else 998 assert(!"Unknown standard command."); 999 return (0); 1000 } 1001