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