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