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