sbin/geom/core/geom.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2004-2009 Pawel Jakub Dawidek <pjd@FreeBSD.org>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <sys/param.h>
  33 #include <sys/linker.h>
  34 #include <sys/module.h>
  35 #include <sys/stat.h>
  36 #include <sys/sysctl.h>
  37 #include <ctype.h>
  38 #include <err.h>
  39 #include <errno.h>
  40 #include <paths.h>
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <stdarg.h>
  44 #include <stdbool.h>
  45 #include <stdint.h>
  46 #include <string.h>
  47 #include <unistd.h>
  48 #include <libgen.h>
  49 #include <libutil.h>
  50 #include <inttypes.h>
  51 #include <dlfcn.h>
  52 #include <assert.h>
  53 #include <libgeom.h>
  54 #include <geom.h>
  55
  56 #include "misc/subr.h"
  57
  58 #ifdef STATIC_GEOM_CLASSES
  59 extern uint32_t gpart_version;
  60 extern struct g_command gpart_class_commands[];
  61 extern uint32_t glabel_version;
  62 extern struct g_command glabel_class_commands[];
  63 #endif
  64
  65 static char comm[MAXPATHLEN], *class_name = NULL, *gclass_name = NULL;
  66 static uint32_t *version = NULL;
  67 static int verbose = 0;
  68 static struct g_command *class_commands = NULL;
  69
  70 #define GEOM_CLASS_CMDS         0x01
  71 #define GEOM_STD_CMDS           0x02
  72
  73 #define GEOM_CLASS_WIDTH        10
  74
  75 static struct g_command *find_command(const char *cmdstr, int flags);
  76 static void list_one_geom_by_provider(const char *provider_name);
  77 static int std_available(const char *name);
  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;
 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         while ((ch = getopt(*argc, *argv, opts)) != -1) {
 340                 /* Standard (not passed to kernel) options. */
 341                 switch (ch) {
 342                 case 'v':
 343                         verbose = 1;
 344                         continue;
 345                 }
 346                 /* Options passed to kernel. */
 347                 opt = find_option(cmd, ch);
 348                 if (opt == NULL)
 349                         usage();
 350                 if (!G_OPT_ISMULTI(opt) && G_OPT_ISDONE(opt)) {
 351                         warnx("Option '%c' specified twice.", opt->go_char);
 352                         usage();
 353                 }
 354                 G_OPT_DONE(opt);
 355
 356                 if (G_OPT_TYPE(opt) == G_TYPE_BOOL)
 357                         set_option(req, opt, "1");
 358                 else
 359                         set_option(req, opt, optarg);
 360         }
 361         *argc -= optind;
 362         *argv += optind;
 363
 364         /*
 365          * Add not specified arguments, but with default values.
 366          */
 367         for (i = 0; ; i++) {
 368                 opt = &cmd->gc_options[i];
 369                 if (opt->go_name == NULL)
 370                         break;
 371                 if (G_OPT_ISDONE(opt))
 372                         continue;
 373
 374                 if (G_OPT_TYPE(opt) == G_TYPE_BOOL) {
 375                         assert(opt->go_val == NULL);
 376                         set_option(req, opt, "0");
 377                 } else {
 378                         if (opt->go_val == NULL) {
 379                                 warnx("Option '%c' not specified.",
 380                                     opt->go_char);
 381                                 usage();
 382                         } else if (opt->go_val == G_VAL_OPTIONAL) {
 383                                 /* add nothing. */
 384                         } else {
 385                                 set_option(req, opt, opt->go_val);
 386                         }
 387                 }
 388         }
 389
 390         /*
 391          * Add rest of given arguments.
 392          */
 393         gctl_ro_param(req, "nargs", sizeof(int), argc);
 394         for (i = 0; i < (unsigned)*argc; i++) {
 395                 char argname[16];
 396
 397                 snprintf(argname, sizeof(argname), "arg%u", i);
 398                 gctl_ro_param(req, argname, -1, (*argv)[i]);
 399         }
 400 }
 401
 402 /*
 403  * Find given command in commands available for given class.
 404  */
 405 static struct g_command *
 406 find_command(const char *cmdstr, int flags)
 407 {
 408         struct g_command *cmd;
 409         unsigned i;
 410
 411         /*
 412          * First try to find command defined by loaded library.
 413          */
 414         if ((flags & GEOM_CLASS_CMDS) != 0 && class_commands != NULL) {
 415                 for (i = 0; ; i++) {
 416                         cmd = &class_commands[i];
 417                         if (cmd->gc_name == NULL)
 418                                 break;
 419                         if (strcmp(cmd->gc_name, cmdstr) == 0)
 420                                 return (cmd);
 421                 }
 422         }
 423         /*
 424          * Now try to find in standard commands.
 425          */
 426         if ((flags & GEOM_STD_CMDS) != 0) {
 427                 for (i = 0; ; i++) {
 428                         cmd = &std_commands[i];
 429                         if (cmd->gc_name == NULL)
 430                                 break;
 431                         if (strcmp(cmd->gc_name, cmdstr) == 0)
 432                                 return (cmd);
 433                 }
 434         }
 435         return (NULL);
 436 }
 437
 438 static unsigned
 439 set_flags(struct g_command *cmd)
 440 {
 441         unsigned flags = 0;
 442
 443         if ((cmd->gc_flags & G_FLAG_VERBOSE) != 0 && verbose)
 444                 flags |= G_FLAG_VERBOSE;
 445
 446         return (flags);
 447 }
 448
 449 /*
 450  * Run command.
 451  */
 452 static void
 453 run_command(int argc, char *argv[])
 454 {
 455         struct g_command *cmd;
 456         struct gctl_req *req;
 457         const char *errstr;
 458         char buf[4096];
 459
 460         /* First try to find a command defined by a class. */
 461         cmd = find_command(argv[0], GEOM_CLASS_CMDS);
 462         if (cmd == NULL) {
 463                 /* Now, try to find a standard command. */
 464                 cmd = find_command(argv[0], GEOM_STD_CMDS);
 465                 if (cmd == NULL) {
 466                         warnx("Unknown command: %s.", argv[0]);
 467                         usage();
 468                 }
 469                 if (!std_available(cmd->gc_name)) {
 470                         warnx("Command '%s' not available; "
 471                             "try 'load' first.", argv[0]);
 472                         exit(EXIT_FAILURE);
 473                 }
 474         }
 475         if ((cmd->gc_flags & G_FLAG_LOADKLD) != 0)
 476                 load_module();
 477
 478         req = gctl_get_handle();
 479         gctl_ro_param(req, "class", -1, gclass_name);
 480         gctl_ro_param(req, "verb", -1, argv[0]);
 481         if (version != NULL)
 482                 gctl_ro_param(req, "version", sizeof(*version), version);
 483         parse_arguments(cmd, req, &argc, &argv);
 484
 485         bzero(buf, sizeof(buf));
 486         if (cmd->gc_func != NULL) {
 487                 unsigned flags;
 488
 489                 flags = set_flags(cmd);
 490                 cmd->gc_func(req, flags);
 491                 errstr = req->error;
 492         } else {
 493                 gctl_rw_param(req, "output", sizeof(buf), buf);
 494                 errstr = gctl_issue(req);
 495         }
 496         if (errstr != NULL && errstr[0] != '\0') {
 497                 warnx("%s", errstr);
 498                 if (strncmp(errstr, "warning: ", strlen("warning: ")) != 0) {
 499                         gctl_free(req);
 500                         exit(EXIT_FAILURE);
 501                 }
 502         }
 503         if (buf[0] != '\0')
 504                 printf("%s", buf);
 505         gctl_free(req);
 506         if (verbose)
 507                 printf("Done.\n");
 508         exit(EXIT_SUCCESS);
 509 }
 510
 511 #ifndef STATIC_GEOM_CLASSES
 512 static const char *
 513 library_path(void)
 514 {
 515         const char *path;
 516
 517         path = getenv("GEOM_LIBRARY_PATH");
 518         if (path == NULL)
 519                 path = GEOM_CLASS_DIR;
 520         return (path);
 521 }
 522
 523 static void
 524 load_library(void)
 525 {
 526         char *curpath, path[MAXPATHLEN], *tofree, *totalpath;
 527         uint32_t *lib_version;
 528         void *dlh;
 529         int ret;
 530
 531         ret = 0;
 532         tofree = totalpath = strdup(library_path());
 533         if (totalpath == NULL)
 534                 err(EXIT_FAILURE, "Not enough memory for library path");
 535
 536         if (strchr(totalpath, ':') != NULL)
 537                 curpath = strsep(&totalpath, ":");
 538         else
 539                 curpath = totalpath;
 540         /* Traverse the paths to find one that contains the library we want. */
 541         while (curpath != NULL) {
 542                 snprintf(path, sizeof(path), "%s/geom_%s.so", curpath,
 543                     class_name);
 544                 ret = access(path, F_OK);
 545                 if (ret == -1) {
 546                         if (errno == ENOENT) {
 547                                 /*
 548                                  * If we cannot find library, try the next
 549                                  * path.
 550                                  */
 551                                 curpath = strsep(&totalpath, ":");
 552                                 continue;
 553                         }
 554                         err(EXIT_FAILURE, "Cannot access library");
 555                 }
 556                 break;
 557         }
 558         free(tofree);
 559         /* No library was found, but standard commands can still be used */
 560         if (ret == -1)
 561                 return;
 562         dlh = dlopen(path, RTLD_NOW);
 563         if (dlh == NULL)
 564                 errx(EXIT_FAILURE, "Cannot open library: %s.", dlerror());
 565         lib_version = dlsym(dlh, "lib_version");
 566         if (lib_version == NULL) {
 567                 warnx("Cannot find symbol %s: %s.", "lib_version", dlerror());
 568                 dlclose(dlh);
 569                 exit(EXIT_FAILURE);
 570         }
 571         if (*lib_version != G_LIB_VERSION) {
 572                 dlclose(dlh);
 573                 errx(EXIT_FAILURE, "%s and %s are not synchronized.",
 574                     getprogname(), path);
 575         }
 576         version = dlsym(dlh, "version");
 577         if (version == NULL) {
 578                 warnx("Cannot find symbol %s: %s.", "version", dlerror());
 579                 dlclose(dlh);
 580                 exit(EXIT_FAILURE);
 581         }
 582         class_commands = dlsym(dlh, "class_commands");
 583         if (class_commands == NULL) {
 584                 warnx("Cannot find symbol %s: %s.", "class_commands",
 585                     dlerror());
 586                 dlclose(dlh);
 587                 exit(EXIT_FAILURE);
 588         }
 589 }
 590 #endif  /* !STATIC_GEOM_CLASSES */
 591
 592 /*
 593  * Class name should be all capital letters.
 594  */
 595 static void
 596 set_class_name(void)
 597 {
 598         char *s1, *s2;
 599
 600         s1 = class_name;
 601         for (; *s1 != '\0'; s1++)
 602                 *s1 = tolower(*s1);
 603         gclass_name = malloc(strlen(class_name) + 1);
 604         if (gclass_name == NULL)
 605                 errx(EXIT_FAILURE, "No memory");
 606         s1 = gclass_name;
 607         s2 = class_name;
 608         for (; *s2 != '\0'; s2++)
 609                 *s1++ = toupper(*s2);
 610         *s1 = '\0';
 611 }
 612
 613 static void
 614 get_class(int *argc, char ***argv)
 615 {
 616
 617         snprintf(comm, sizeof(comm), "%s", basename((*argv)[0]));
 618         if (strcmp(comm, "geom") == 0) {
 619                 if (*argc < 2)
 620                         usage();
 621                 else if (*argc == 2) {
 622                         if (strcmp((*argv)[1], "-h") == 0 ||
 623                             strcmp((*argv)[1], "help") == 0) {
 624                                 usage();
 625                         }
 626                 }
 627                 strlcatf(comm, sizeof(comm), " %s", (*argv)[1]);
 628                 class_name = (*argv)[1];
 629                 *argc -= 2;
 630                 *argv += 2;
 631         } else if (*comm == 'g') {
 632                 class_name = comm + 1;
 633                 *argc -= 1;
 634                 *argv += 1;
 635         } else {
 636                 errx(EXIT_FAILURE, "Invalid utility name.");
 637         }
 638
 639 #ifndef STATIC_GEOM_CLASSES
 640         load_library();
 641 #else
 642         if (!strcasecmp(class_name, "part")) {
 643                 version = &gpart_version;
 644                 class_commands = gpart_class_commands;
 645         } else if (!strcasecmp(class_name, "label")) {
 646                 version = &glabel_version;
 647                 class_commands = glabel_class_commands;
 648         }
 649 #endif /* !STATIC_GEOM_CLASSES */
 650
 651         set_class_name();
 652
 653         /* If we can't load or list, it's not a class. */
 654         if (!std_available("load") && !std_available("list"))
 655                 errx(EXIT_FAILURE, "Invalid class name '%s'.", class_name);
 656
 657         if (*argc < 1)
 658                 usage();
 659 }
 660
 661 static struct ggeom *
 662 find_geom_by_provider(struct gmesh *mesh, const char *name)
 663 {
 664         struct gclass *classp;
 665         struct ggeom *gp;
 666         struct gprovider *pp;
 667
 668         LIST_FOREACH(classp, &mesh->lg_class, lg_class) {
 669                 LIST_FOREACH(gp, &classp->lg_geom, lg_geom) {
 670                         LIST_FOREACH(pp, &gp->lg_provider, lg_provider) {
 671                                 if (strcmp(pp->lg_name, name) == 0)
 672                                         return (gp);
 673                         }
 674                 }
 675         }
 676
 677         return (NULL);
 678 }
 679
 680 static int
 681 compute_tree_width_geom(struct gmesh *mesh, struct ggeom *gp, int indent)
 682 {
 683         struct gclass *classp2;
 684         struct ggeom *gp2;
 685         struct gconsumer *cp2;
 686         struct gprovider *pp;
 687         int max_width, width;
 688
 689         max_width = width = indent + strlen(gp->lg_name);
 690
 691         LIST_FOREACH(pp, &gp->lg_provider, lg_provider) {
 692                 LIST_FOREACH(classp2, &mesh->lg_class, lg_class) {
 693                         LIST_FOREACH(gp2, &classp2->lg_geom, lg_geom) {
 694                                 LIST_FOREACH(cp2,
 695                                     &gp2->lg_consumer, lg_consumer) {
 696                                         if (pp != cp2->lg_provider)
 697                                                 continue;
 698                                         width = compute_tree_width_geom(mesh,
 699                                             gp2, indent + 2);
 700                                         if (width > max_width)
 701                                                 max_width = width;
 702                                 }
 703                         }
 704                 }
 705         }
 706
 707         return (max_width);
 708 }
 709
 710 static int
 711 compute_tree_width(struct gmesh *mesh)
 712 {
 713         struct gclass *classp;
 714         struct ggeom *gp;
 715         int max_width, width;
 716
 717         max_width = width = 0;
 718
 719         LIST_FOREACH(classp, &mesh->lg_class, lg_class) {
 720                 LIST_FOREACH(gp, &classp->lg_geom, lg_geom) {
 721                         if (!LIST_EMPTY(&gp->lg_consumer))
 722                                 continue;
 723                         width = compute_tree_width_geom(mesh, gp, 0);
 724                         if (width > max_width)
 725                                 max_width = width;
 726                 }
 727         }
 728
 729         return (max_width);
 730 }
 731
 732 static void
 733 show_tree_geom(struct gmesh *mesh, struct ggeom *gp, int indent, int width)
 734 {
 735         struct gclass *classp2;
 736         struct ggeom *gp2;
 737         struct gconsumer *cp2;
 738         struct gprovider *pp;
 739
 740         if (LIST_EMPTY(&gp->lg_provider)) {
 741                 printf("%*s%-*.*s %-*.*s\n", indent, "",
 742                     width - indent, width - indent, gp->lg_name,
 743                     GEOM_CLASS_WIDTH, GEOM_CLASS_WIDTH, gp->lg_class->lg_name);
 744                 return;
 745         }
 746
 747         LIST_FOREACH(pp, &gp->lg_provider, lg_provider) {
 748                 printf("%*s%-*.*s %-*.*s %s\n", indent, "",
 749                     width - indent, width - indent, gp->lg_name,
 750                     GEOM_CLASS_WIDTH, GEOM_CLASS_WIDTH, gp->lg_class->lg_name,
 751                     pp->lg_name);
 752
 753                 LIST_FOREACH(classp2, &mesh->lg_class, lg_class) {
 754                         LIST_FOREACH(gp2, &classp2->lg_geom, lg_geom) {
 755                                 LIST_FOREACH(cp2,
 756                                     &gp2->lg_consumer, lg_consumer) {
 757                                         if (pp != cp2->lg_provider)
 758                                                 continue;
 759                                         show_tree_geom(mesh, gp2,
 760                                             indent + 2, width);
 761                                 }
 762                         }
 763                 }
 764         }
 765 }
 766
 767 static void
 768 show_tree(void)
 769 {
 770         struct gmesh mesh;
 771         struct gclass *classp;
 772         struct ggeom *gp;
 773         int error, width;
 774
 775         error = geom_gettree(&mesh);
 776         if (error != 0)
 777                 errc(EXIT_FAILURE, error, "Cannot get GEOM tree");
 778
 779         width = compute_tree_width(&mesh);
 780
 781         printf("%-*.*s %-*.*s %s\n",
 782             width, width, "Geom",
 783             GEOM_CLASS_WIDTH, GEOM_CLASS_WIDTH, "Class",
 784             "Provider");
 785
 786         LIST_FOREACH(classp, &mesh.lg_class, lg_class) {
 787                 LIST_FOREACH(gp, &classp->lg_geom, lg_geom) {
 788                         if (!LIST_EMPTY(&gp->lg_consumer))
 789                                 continue;
 790                         show_tree_geom(&mesh, gp, 0, width);
 791                 }
 792         }
 793 }
 794
 795 int
 796 main(int argc, char *argv[])
 797 {
 798         char *provider_name;
 799         bool tflag;
 800         int ch;
 801
 802         provider_name = NULL;
 803         tflag = false;
 804
 805         if (strcmp(getprogname(), "geom") == 0) {
 806                 while ((ch = getopt(argc, argv, "hp:t")) != -1) {
 807                         switch (ch) {
 808                         case 'p':
 809                                 provider_name = strdup(optarg);
 810                                 if (provider_name == NULL)
 811                                         err(1, "strdup");
 812                                 break;
 813                         case 't':
 814                                 tflag = true;
 815                                 break;
 816                         case 'h':
 817                         default:
 818                                 usage();
 819                         }
 820                 }
 821
 822                 /*
 823                  * Don't adjust argc and argv, it would break get_class().
 824                  */
 825         }
 826
 827         if (tflag && provider_name != NULL) {
 828                 errx(EXIT_FAILURE,
 829                     "At most one of -P and -t may be specified.");
 830         }
 831
 832         if (provider_name != NULL) {
 833                 list_one_geom_by_provider(provider_name);
 834                 return (0);
 835         }
 836
 837         if (tflag) {
 838                 show_tree();
 839                 return (0);
 840         }
 841
 842         get_class(&argc, &argv);
 843         run_command(argc, argv);
 844         /* NOTREACHED */
 845
 846         exit(EXIT_FAILURE);
 847 }
 848
 849 static struct gclass *
 850 find_class(struct gmesh *mesh, const char *name)
 851 {
 852         struct gclass *classp;
 853
 854         LIST_FOREACH(classp, &mesh->lg_class, lg_class) {
 855                 if (strcmp(classp->lg_name, name) == 0)
 856                         return (classp);
 857         }
 858         return (NULL);
 859 }
 860
 861 static struct ggeom *
 862 find_geom(struct gclass *classp, const char *name)
 863 {
 864         struct ggeom *gp;
 865
 866         if (strncmp(name, _PATH_DEV, sizeof(_PATH_DEV) - 1) == 0)
 867                 name += sizeof(_PATH_DEV) - 1;
 868
 869         LIST_FOREACH(gp, &classp->lg_geom, lg_geom) {
 870                 if (strcmp(gp->lg_name, name) == 0)
 871                         return (gp);
 872         }
 873         return (NULL);
 874 }
 875
 876 static void
 877 list_one_provider(struct gprovider *pp, const char *prefix)
 878 {
 879         struct gconfig *conf;
 880         char buf[5];
 881
 882         printf("Name: %s\n", pp->lg_name);
 883         humanize_number(buf, sizeof(buf), (int64_t)pp->lg_mediasize, "",
 884             HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);
 885         printf("%sMediasize: %jd (%s)\n", prefix, (intmax_t)pp->lg_mediasize,
 886             buf);
 887         printf("%sSectorsize: %u\n", prefix, pp->lg_sectorsize);
 888         if (pp->lg_stripesize > 0 || pp->lg_stripeoffset > 0) {
 889                 printf("%sStripesize: %ju\n", prefix, pp->lg_stripesize);
 890                 printf("%sStripeoffset: %ju\n", prefix, pp->lg_stripeoffset);
 891         }
 892         printf("%sMode: %s\n", prefix, pp->lg_mode);
 893         LIST_FOREACH(conf, &pp->lg_config, lg_config) {
 894                 printf("%s%s: %s\n", prefix, conf->lg_name, conf->lg_val);
 895         }
 896 }
 897
 898 static void
 899 list_one_consumer(struct gconsumer *cp, const char *prefix)
 900 {
 901         struct gprovider *pp;
 902         struct gconfig *conf;
 903
 904         pp = cp->lg_provider;
 905         if (pp == NULL)
 906                 printf("[no provider]\n");
 907         else {
 908                 char buf[5];
 909
 910                 printf("Name: %s\n", pp->lg_name);
 911                 humanize_number(buf, sizeof(buf), (int64_t)pp->lg_mediasize, "",
 912                     HN_AUTOSCALE, HN_B | HN_NOSPACE | HN_DECIMAL);
 913                 printf("%sMediasize: %jd (%s)\n", prefix,
 914                     (intmax_t)pp->lg_mediasize, buf);
 915                 printf("%sSectorsize: %u\n", prefix, pp->lg_sectorsize);
 916                 if (pp->lg_stripesize > 0 || pp->lg_stripeoffset > 0) {
 917                         printf("%sStripesize: %ju\n", prefix, pp->lg_stripesize);
 918                         printf("%sStripeoffset: %ju\n", prefix, pp->lg_stripeoffset);
 919                 }
 920                 printf("%sMode: %s\n", prefix, cp->lg_mode);
 921         }
 922         LIST_FOREACH(conf, &cp->lg_config, lg_config) {
 923                 printf("%s%s: %s\n", prefix, conf->lg_name, conf->lg_val);
 924         }
 925 }
 926
 927 static void
 928 list_one_geom(struct ggeom *gp)
 929 {
 930         struct gprovider *pp;
 931         struct gconsumer *cp;
 932         struct gconfig *conf;
 933         unsigned n;
 934
 935         printf("Geom name: %s\n", gp->lg_name);
 936         LIST_FOREACH(conf, &gp->lg_config, lg_config) {
 937                 printf("%s: %s\n", conf->lg_name, conf->lg_val);
 938         }
 939         if (!LIST_EMPTY(&gp->lg_provider)) {
 940                 printf("Providers:\n");
 941                 n = 1;
 942                 LIST_FOREACH(pp, &gp->lg_provider, lg_provider) {
 943                         printf("%u. ", n++);
 944                         list_one_provider(pp, "   ");
 945                 }
 946         }
 947         if (!LIST_EMPTY(&gp->lg_consumer)) {
 948                 printf("Consumers:\n");
 949                 n = 1;
 950                 LIST_FOREACH(cp, &gp->lg_consumer, lg_consumer) {
 951                         printf("%u. ", n++);
 952                         list_one_consumer(cp, "   ");
 953                 }
 954         }
 955         printf("\n");
 956 }
 957
 958 static void
 959 list_one_geom_by_provider(const char *provider_name)
 960 {
 961         struct gmesh mesh;
 962         struct ggeom *gp;
 963         int error;
 964
 965         error = geom_gettree(&mesh);
 966         if (error != 0)
 967                 errc(EXIT_FAILURE, error, "Cannot get GEOM tree");
 968
 969         gp = find_geom_by_provider(&mesh, provider_name);
 970         if (gp == NULL)
 971                 errx(EXIT_FAILURE, "Cannot find provider '%s'.", provider_name);
 972
 973         printf("Geom class: %s\n", gp->lg_class->lg_name);
 974         list_one_geom(gp);
 975 }
 976
 977 static void
 978 std_help(struct gctl_req *req __unused, unsigned flags __unused)
 979 {
 980
 981         usage();
 982 }
 983
 984 static int
 985 std_list_available(void)
 986 {
 987         struct gmesh mesh;
 988         struct gclass *classp;
 989         int error;
 990
 991         error = geom_gettree(&mesh);
 992         if (error != 0)
 993                 errc(EXIT_FAILURE, error, "Cannot get GEOM tree");
 994         classp = find_class(&mesh, gclass_name);
 995         geom_deletetree(&mesh);
 996         if (classp != NULL)
 997                 return (1);
 998         return (0);
 999 }
1000
1001 static void
1002 std_list(struct gctl_req *req, unsigned flags __unused)
1003 {
1004         struct gmesh mesh;
1005         struct gclass *classp;
1006         struct ggeom *gp;
1007         const char *name;
1008         int all, error, i, nargs;
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                 geom_deletetree(&mesh);
1016                 errx(EXIT_FAILURE, "Class '%s' not found.", gclass_name);
1017         }
1018         nargs = gctl_get_int(req, "nargs");
1019         all = gctl_get_int(req, "all");
1020         if (nargs > 0) {
1021                 for (i = 0; i < nargs; i++) {
1022                         name = gctl_get_ascii(req, "arg%d", i);
1023                         gp = find_geom(classp, name);
1024                         if (gp == NULL) {
1025                                 errx(EXIT_FAILURE, "Class '%s' does not have "
1026                                     "an instance named '%s'.",
1027                                     gclass_name, name);
1028                         }
1029                         list_one_geom(gp);
1030                 }
1031         } else {
1032                 LIST_FOREACH(gp, &classp->lg_geom, lg_geom) {
1033                         if (LIST_EMPTY(&gp->lg_provider) && !all)
1034                                 continue;
1035                         list_one_geom(gp);
1036                 }
1037         }
1038         geom_deletetree(&mesh);
1039 }
1040
1041 static int
1042 std_status_available(void)
1043 {
1044
1045         /* 'status' command is available when 'list' command is. */
1046         return (std_list_available());
1047 }
1048
1049 static void
1050 status_update_len(struct ggeom *gp, int *name_len, int *status_len)
1051 {
1052         struct gconfig *conf;
1053         int len;
1054
1055         assert(gp != NULL);
1056         assert(name_len != NULL);
1057         assert(status_len != NULL);
1058
1059         len = strlen(gp->lg_name);
1060         if (*name_len < len)
1061                 *name_len = len;
1062         LIST_FOREACH(conf, &gp->lg_config, lg_config) {
1063                 if (strcasecmp(conf->lg_name, "state") == 0) {
1064                         len = strlen(conf->lg_val);
1065                         if (*status_len < len)
1066                                 *status_len = len;
1067                 }
1068         }
1069 }
1070
1071 static void
1072 status_update_len_prs(struct ggeom *gp, int *name_len, int *status_len)
1073 {
1074         struct gprovider *pp;
1075         struct gconfig *conf;
1076         int len, glen;
1077
1078         assert(gp != NULL);
1079         assert(name_len != NULL);
1080         assert(status_len != NULL);
1081
1082         glen = 0;
1083         LIST_FOREACH(conf, &gp->lg_config, lg_config) {
1084                 if (strcasecmp(conf->lg_name, "state") == 0) {
1085                         glen = strlen(conf->lg_val);
1086                         break;
1087                 }
1088         }
1089         LIST_FOREACH(pp, &gp->lg_provider, lg_provider) {
1090                 len = strlen(pp->lg_name);
1091                 if (*name_len < len)
1092                         *name_len = len;
1093                 len = glen;
1094                 LIST_FOREACH(conf, &pp->lg_config, lg_config) {
1095                         if (strcasecmp(conf->lg_name, "state") == 0) {
1096                                 len = strlen(conf->lg_val);
1097                                 break;
1098                         }
1099                 }
1100                 if (*status_len < len)
1101                         *status_len = len;
1102         }
1103 }
1104
1105 static char *
1106 status_one_consumer(struct gconsumer *cp)
1107 {
1108         static char buf[256];
1109         struct gprovider *pp;
1110         struct gconfig *conf;
1111         const char *state, *syncr;
1112
1113         pp = cp->lg_provider;
1114         if (pp == NULL)
1115                 return (NULL);
1116         state = NULL;
1117         syncr = NULL;
1118         LIST_FOREACH(conf, &cp->lg_config, lg_config) {
1119                 if (strcasecmp(conf->lg_name, "state") == 0)
1120                         state = conf->lg_val;
1121                 if (strcasecmp(conf->lg_name, "synchronized") == 0)
1122                         syncr = conf->lg_val;
1123         }
1124         if (state == NULL && syncr == NULL)
1125                 snprintf(buf, sizeof(buf), "%s", pp->lg_name);
1126         else if (state != NULL && syncr != NULL) {
1127                 snprintf(buf, sizeof(buf), "%s (%s, %s)", pp->lg_name,
1128                     state, syncr);
1129         } else {
1130                 snprintf(buf, sizeof(buf), "%s (%s)", pp->lg_name,
1131                     state ? state : syncr);
1132         }
1133         return (buf);
1134 }
1135
1136 static void
1137 status_one_geom(struct ggeom *gp, int script, int name_len, int status_len)
1138 {
1139         struct gconsumer *cp;
1140         struct gconfig *conf;
1141         const char *name, *status, *component;
1142         int gotone;
1143
1144         name = gp->lg_name;
1145         status = "N/A";
1146         LIST_FOREACH(conf, &gp->lg_config, lg_config) {
1147                 if (strcasecmp(conf->lg_name, "state") == 0) {
1148                         status = conf->lg_val;
1149                         break;
1150                 }
1151         }
1152         gotone = 0;
1153         LIST_FOREACH(cp, &gp->lg_consumer, lg_consumer) {
1154                 component = status_one_consumer(cp);
1155                 if (component == NULL)
1156                         continue;
1157                 gotone = 1;
1158                 printf("%*s  %*s  %s\n", name_len, name, status_len, status,
1159                     component);
1160                 if (!script)
1161                         name = status = "";
1162         }
1163         if (!gotone) {
1164                 printf("%*s  %*s  %s\n", name_len, name, status_len, status,
1165                     "N/A");
1166         }
1167 }
1168
1169 static void
1170 status_one_geom_prs(struct ggeom *gp, int script, int name_len, int status_len)
1171 {
1172         struct gprovider *pp;
1173         struct gconsumer *cp;
1174         struct gconfig *conf;
1175         const char *name, *status, *component;
1176         int gotone;
1177
1178         LIST_FOREACH(pp, &gp->lg_provider, lg_provider) {
1179                 name = pp->lg_name;
1180                 status = "N/A";
1181                 LIST_FOREACH(conf, &gp->lg_config, lg_config) {
1182                         if (strcasecmp(conf->lg_name, "state") == 0) {
1183                                 status = conf->lg_val;
1184                                 break;
1185                         }
1186                 }
1187                 LIST_FOREACH(conf, &pp->lg_config, lg_config) {
1188                         if (strcasecmp(conf->lg_name, "state") == 0) {
1189                                 status = conf->lg_val;
1190                                 break;
1191                         }
1192                 }
1193                 gotone = 0;
1194                 LIST_FOREACH(cp, &gp->lg_consumer, lg_consumer) {
1195                         component = status_one_consumer(cp);
1196                         if (component == NULL)
1197                                 continue;
1198                         gotone = 1;
1199                         printf("%*s  %*s  %s\n", name_len, name,
1200                             status_len, status, component);
1201                         if (!script)
1202                                 name = status = "";
1203                 }
1204                 if (!gotone) {
1205                         printf("%*s  %*s  %s\n", name_len, name,
1206                             status_len, status, "N/A");
1207                 }
1208         }
1209 }
1210
1211 static void
1212 std_status(struct gctl_req *req, unsigned flags __unused)
1213 {
1214         struct gmesh mesh;
1215         struct gclass *classp;
1216         struct ggeom *gp;
1217         const char *name;
1218         int name_len, status_len;
1219         int all, error, geoms, i, n, nargs, script;
1220
1221         error = geom_gettree(&mesh);
1222         if (error != 0)
1223                 errc(EXIT_FAILURE, error, "Cannot get GEOM tree");
1224         classp = find_class(&mesh, gclass_name);
1225         if (classp == NULL)
1226                 errx(EXIT_FAILURE, "Class %s not found.", gclass_name);
1227         nargs = gctl_get_int(req, "nargs");
1228         all = gctl_get_int(req, "all");
1229         geoms = gctl_get_int(req, "geoms");
1230         script = gctl_get_int(req, "script");
1231         if (script) {
1232                 name_len = 0;
1233                 status_len = 0;
1234         } else {
1235                 name_len = strlen("Name");
1236                 status_len = strlen("Status");
1237         }
1238         if (nargs > 0) {
1239                 for (i = 0, n = 0; i < nargs; i++) {
1240                         name = gctl_get_ascii(req, "arg%d", i);
1241                         gp = find_geom(classp, name);
1242                         if (gp == NULL)
1243                                 errx(EXIT_FAILURE, "No such geom: %s.", name);
1244                         if (geoms) {
1245                                 status_update_len(gp,
1246                                     &name_len, &status_len);
1247                         } else {
1248                                 status_update_len_prs(gp,
1249                                     &name_len, &status_len);
1250                         }
1251                         n++;
1252                 }
1253                 if (n == 0)
1254                         goto end;
1255         } else {
1256                 n = 0;
1257                 LIST_FOREACH(gp, &classp->lg_geom, lg_geom) {
1258                         if (LIST_EMPTY(&gp->lg_provider) && !all)
1259                                 continue;
1260                         if (geoms) {
1261                                 status_update_len(gp,
1262                                     &name_len, &status_len);
1263                         } else {
1264                                 status_update_len_prs(gp,
1265                                     &name_len, &status_len);
1266                         }
1267                         n++;
1268                 }
1269                 if (n == 0)
1270                         goto end;
1271         }
1272         if (!script) {
1273                 printf("%*s  %*s  %s\n", name_len, "Name", status_len, "Status",
1274                     "Components");
1275         }
1276         if (nargs > 0) {
1277                 for (i = 0; i < nargs; i++) {
1278                         name = gctl_get_ascii(req, "arg%d", i);
1279                         gp = find_geom(classp, name);
1280                         if (gp == NULL)
1281                                 continue;
1282                         if (geoms) {
1283                                 status_one_geom(gp, script, name_len,
1284                                     status_len);
1285                         } else {
1286                                 status_one_geom_prs(gp, script, name_len,
1287                                     status_len);
1288                         }
1289                 }
1290         } else {
1291                 LIST_FOREACH(gp, &classp->lg_geom, lg_geom) {
1292                         if (LIST_EMPTY(&gp->lg_provider) && !all)
1293                                 continue;
1294                         if (geoms) {
1295                                 status_one_geom(gp, script, name_len,
1296                                     status_len);
1297                         } else {
1298                                 status_one_geom_prs(gp, script, name_len,
1299                                     status_len);
1300                         }
1301                 }
1302         }
1303 end:
1304         geom_deletetree(&mesh);
1305 }
1306
1307 static int
1308 std_load_available(void)
1309 {
1310         char name[MAXPATHLEN], paths[MAXPATHLEN * 8], *p;
1311         struct stat sb;
1312         size_t len;
1313
1314         snprintf(name, sizeof(name), "g_%s", class_name);
1315         /*
1316          * If already in kernel, "load" command is not available.
1317          */
1318         if (modfind(name) >= 0)
1319                 return (0);
1320         bzero(paths, sizeof(paths));
1321         len = sizeof(paths);
1322         if (sysctlbyname("kern.module_path", paths, &len, NULL, 0) < 0)
1323                 err(EXIT_FAILURE, "sysctl(kern.module_path)");
1324         for (p = strtok(paths, ";"); p != NULL; p = strtok(NULL, ";")) {
1325                 snprintf(name, sizeof(name), "%s/geom_%s.ko", p, class_name);
1326                 /*
1327                  * If geom_<name>.ko file exists, "load" command is available.
1328                  */
1329                 if (stat(name, &sb) == 0)
1330                         return (1);
1331         }
1332         return (0);
1333 }
1334
1335 static void
1336 std_load(struct gctl_req *req __unused, unsigned flags)
1337 {
1338
1339         /*
1340          * Do nothing special here, because of G_FLAG_LOADKLD flag,
1341          * module is already loaded.
1342          */
1343         if ((flags & G_FLAG_VERBOSE) != 0)
1344                 printf("Module available.\n");
1345 }
1346
1347 static int
1348 std_unload_available(void)
1349 {
1350         char name[64];
1351         int id;
1352
1353         snprintf(name, sizeof(name), "geom_%s", class_name);
1354         id = kldfind(name);
1355         if (id >= 0)
1356                 return (1);
1357         return (0);
1358 }
1359
1360 static void
1361 std_unload(struct gctl_req *req, unsigned flags __unused)
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                 gctl_error(req, "Could not find module: %s.", strerror(errno));
1370                 return;
1371         }
1372         if (kldunload(id) < 0) {
1373                 gctl_error(req, "Could not unload module: %s.",
1374                     strerror(errno));
1375                 return;
1376         }
1377 }
1378
1379 static int
1380 std_available(const char *name)
1381 {
1382
1383         if (strcmp(name, "help") == 0)
1384                 return (1);
1385         else if (strcmp(name, "list") == 0)
1386                 return (std_list_available());
1387         else if (strcmp(name, "status") == 0)
1388                 return (std_status_available());
1389         else if (strcmp(name, "load") == 0)
1390                 return (std_load_available());
1391         else if (strcmp(name, "unload") == 0)
1392                 return (std_unload_available());
1393         else
1394                 assert(!"Unknown standard command.");
1395         return (0);
1396 }