cmd/zpool/zpool_main.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 #include <assert.h>
  28 #include <ctype.h>
  29 #include <dirent.h>
  30 #include <errno.h>
  31 #include <fcntl.h>
  32 #include <libgen.h>
  33 #include <libintl.h>
  34 #include <libuutil.h>
  35 #include <locale.h>
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <string.h>
  39 #include <strings.h>
  40 #include <unistd.h>
  41 #include <priv.h>
  42 #include <pwd.h>
  43 #include <zone.h>
  44 #include <sys/fs/zfs.h>
  45
  46 #include <sys/stat.h>
  47
  48 #include <libzfs.h>
  49
  50 #include "zpool_util.h"
  51 #include "zfs_comutil.h"
  52
  53 static int zpool_do_create(int, char **);
  54 static int zpool_do_destroy(int, char **);
  55
  56 static int zpool_do_add(int, char **);
  57 static int zpool_do_remove(int, char **);
  58
  59 static int zpool_do_list(int, char **);
  60 static int zpool_do_iostat(int, char **);
  61 static int zpool_do_status(int, char **);
  62
  63 static int zpool_do_online(int, char **);
  64 static int zpool_do_offline(int, char **);
  65 static int zpool_do_clear(int, char **);
  66
  67 static int zpool_do_attach(int, char **);
  68 static int zpool_do_detach(int, char **);
  69 static int zpool_do_replace(int, char **);
  70
  71 static int zpool_do_scrub(int, char **);
  72
  73 static int zpool_do_import(int, char **);
  74 static int zpool_do_export(int, char **);
  75
  76 static int zpool_do_upgrade(int, char **);
  77
  78 static int zpool_do_history(int, char **);
  79
  80 static int zpool_do_get(int, char **);
  81 static int zpool_do_set(int, char **);
  82
  83 /*
  84  * These libumem hooks provide a reasonable set of defaults for the allocator's
  85  * debugging facilities.
  86  */
  87
  88 #ifdef DEBUG
  89 const char *
  90 _umem_debug_init(void)
  91 {
  92         return ("default,verbose"); /* $UMEM_DEBUG setting */
  93 }
  94
  95 const char *
  96 _umem_logging_init(void)
  97 {
  98         return ("fail,contents"); /* $UMEM_LOGGING setting */
  99 }
 100 #endif
 101
 102 typedef enum {
 103         HELP_ADD,
 104         HELP_ATTACH,
 105         HELP_CLEAR,
 106         HELP_CREATE,
 107         HELP_DESTROY,
 108         HELP_DETACH,
 109         HELP_EXPORT,
 110         HELP_HISTORY,
 111         HELP_IMPORT,
 112         HELP_IOSTAT,
 113         HELP_LIST,
 114         HELP_OFFLINE,
 115         HELP_ONLINE,
 116         HELP_REPLACE,
 117         HELP_REMOVE,
 118         HELP_SCRUB,
 119         HELP_STATUS,
 120         HELP_UPGRADE,
 121         HELP_GET,
 122         HELP_SET
 123 } zpool_help_t;
 124
 125
 126 typedef struct zpool_command {
 127         const char      *name;
 128         int             (*func)(int, char **);
 129         zpool_help_t    usage;
 130 } zpool_command_t;
 131
 132 /*
 133  * Master command table.  Each ZFS command has a name, associated function, and
 134  * usage message.  The usage messages need to be internationalized, so we have
 135  * to have a function to return the usage message based on a command index.
 136  *
 137  * These commands are organized according to how they are displayed in the usage
 138  * message.  An empty command (one with a NULL name) indicates an empty line in
 139  * the generic usage message.
 140  */
 141 static zpool_command_t command_table[] = {
 142         { "create",     zpool_do_create,        HELP_CREATE             },
 143         { "destroy",    zpool_do_destroy,       HELP_DESTROY            },
 144         { NULL },
 145         { "add",        zpool_do_add,           HELP_ADD                },
 146         { "remove",     zpool_do_remove,        HELP_REMOVE             },
 147         { NULL },
 148         { "list",       zpool_do_list,          HELP_LIST               },
 149         { "iostat",     zpool_do_iostat,        HELP_IOSTAT             },
 150         { "status",     zpool_do_status,        HELP_STATUS             },
 151         { NULL },
 152         { "online",     zpool_do_online,        HELP_ONLINE             },
 153         { "offline",    zpool_do_offline,       HELP_OFFLINE            },
 154         { "clear",      zpool_do_clear,         HELP_CLEAR              },
 155         { NULL },
 156         { "attach",     zpool_do_attach,        HELP_ATTACH             },
 157         { "detach",     zpool_do_detach,        HELP_DETACH             },
 158         { "replace",    zpool_do_replace,       HELP_REPLACE            },
 159         { NULL },
 160         { "scrub",      zpool_do_scrub,         HELP_SCRUB              },
 161         { NULL },
 162         { "import",     zpool_do_import,        HELP_IMPORT             },
 163         { "export",     zpool_do_export,        HELP_EXPORT             },
 164         { "upgrade",    zpool_do_upgrade,       HELP_UPGRADE            },
 165         { NULL },
 166         { "history",    zpool_do_history,       HELP_HISTORY            },
 167         { "get",        zpool_do_get,           HELP_GET                },
 168         { "set",        zpool_do_set,           HELP_SET                },
 169 };
 170
 171 #define NCOMMAND        (sizeof (command_table) / sizeof (command_table[0]))
 172
 173 zpool_command_t *current_command;
 174 static char history_str[HIS_MAX_RECORD_LEN];
 175
 176 static const char *
 177 get_usage(zpool_help_t idx) {
 178         switch (idx) {
 179         case HELP_ADD:
 180                 return (gettext("\tadd [-fn] <pool> <vdev> ...\n"));
 181         case HELP_ATTACH:
 182                 return (gettext("\tattach [-f] <pool> <device> "
 183                     "<new-device>\n"));
 184         case HELP_CLEAR:
 185                 return (gettext("\tclear <pool> [device]\n"));
 186         case HELP_CREATE:
 187                 return (gettext("\tcreate [-fn] [-o property=value] ... \n"
 188                     "\t    [-O file-system-property=value] ... \n"
 189                     "\t    [-m mountpoint] [-R root] <pool> <vdev> ...\n"));
 190         case HELP_DESTROY:
 191                 return (gettext("\tdestroy [-f] <pool>\n"));
 192         case HELP_DETACH:
 193                 return (gettext("\tdetach <pool> <device>\n"));
 194         case HELP_EXPORT:
 195                 return (gettext("\texport [-f] <pool> ...\n"));
 196         case HELP_HISTORY:
 197                 return (gettext("\thistory [-il] [<pool>] ...\n"));
 198         case HELP_IMPORT:
 199                 return (gettext("\timport [-d dir] [-D]\n"
 200                     "\timport [-o mntopts] [-o property=value] ... \n"
 201                     "\t    [-d dir | -c cachefile] [-D] [-f] [-R root] -a\n"
 202                     "\timport [-o mntopts] [-o property=value] ... \n"
 203                     "\t    [-d dir | -c cachefile] [-D] [-f] [-R root] "
 204                     "<pool | id> [newpool]\n"));
 205         case HELP_IOSTAT:
 206                 return (gettext("\tiostat [-v] [pool] ... [interval "
 207                     "[count]]\n"));
 208         case HELP_LIST:
 209                 return (gettext("\tlist [-H] [-o property[,...]] "
 210                     "[pool] ...\n"));
 211         case HELP_OFFLINE:
 212                 return (gettext("\toffline [-t] <pool> <device> ...\n"));
 213         case HELP_ONLINE:
 214                 return (gettext("\tonline <pool> <device> ...\n"));
 215         case HELP_REPLACE:
 216                 return (gettext("\treplace [-f] <pool> <device> "
 217                     "[new-device]\n"));
 218         case HELP_REMOVE:
 219                 return (gettext("\tremove <pool> <device> ...\n"));
 220         case HELP_SCRUB:
 221                 return (gettext("\tscrub [-s] <pool> ...\n"));
 222         case HELP_STATUS:
 223                 return (gettext("\tstatus [-vx] [pool] ...\n"));
 224         case HELP_UPGRADE:
 225                 return (gettext("\tupgrade\n"
 226                     "\tupgrade -v\n"
 227                     "\tupgrade [-V version] <-a | pool ...>\n"));
 228         case HELP_GET:
 229                 return (gettext("\tget <\"all\" | property[,...]> "
 230                     "<pool> ...\n"));
 231         case HELP_SET:
 232                 return (gettext("\tset <property=value> <pool> \n"));
 233         }
 234
 235         abort();
 236         /* NOTREACHED */
 237 }
 238
 239
 240 /*
 241  * Callback routine that will print out a pool property value.
 242  */
 243 static int
 244 print_prop_cb(int prop, void *cb)
 245 {
 246         FILE *fp = cb;
 247
 248         (void) fprintf(fp, "\t%-13s  ", zpool_prop_to_name(prop));
 249
 250         if (zpool_prop_readonly(prop))
 251                 (void) fprintf(fp, "  NO   ");
 252         else
 253                 (void) fprintf(fp, " YES    ");
 254
 255         if (zpool_prop_values(prop) == NULL)
 256                 (void) fprintf(fp, "-\n");
 257         else
 258                 (void) fprintf(fp, "%s\n", zpool_prop_values(prop));
 259
 260         return (ZPROP_CONT);
 261 }
 262
 263 /*
 264  * Display usage message.  If we're inside a command, display only the usage for
 265  * that command.  Otherwise, iterate over the entire command table and display
 266  * a complete usage message.
 267  */
 268 void
 269 usage(boolean_t requested)
 270 {
 271         FILE *fp = requested ? stdout : stderr;
 272
 273         if (current_command == NULL) {
 274                 int i;
 275
 276                 (void) fprintf(fp, gettext("usage: zpool command args ...\n"));
 277                 (void) fprintf(fp,
 278                     gettext("where 'command' is one of the following:\n\n"));
 279
 280                 for (i = 0; i < NCOMMAND; i++) {
 281                         if (command_table[i].name == NULL)
 282                                 (void) fprintf(fp, "\n");
 283                         else
 284                                 (void) fprintf(fp, "%s",
 285                                     get_usage(command_table[i].usage));
 286                 }
 287         } else {
 288                 (void) fprintf(fp, gettext("usage:\n"));
 289                 (void) fprintf(fp, "%s", get_usage(current_command->usage));
 290         }
 291
 292         if (current_command != NULL &&
 293             ((strcmp(current_command->name, "set") == 0) ||
 294             (strcmp(current_command->name, "get") == 0) ||
 295             (strcmp(current_command->name, "list") == 0))) {
 296
 297                 (void) fprintf(fp,
 298                     gettext("\nthe following properties are supported:\n"));
 299
 300                 (void) fprintf(fp, "\n\t%-13s  %s  %s\n\n",
 301                     "PROPERTY", "EDIT", "VALUES");
 302
 303                 /* Iterate over all properties */
 304                 (void) zprop_iter(print_prop_cb, fp, B_FALSE, B_TRUE,
 305                     ZFS_TYPE_POOL);
 306         }
 307
 308         /*
 309          * See comments at end of main().
 310          */
 311         if (getenv("ZFS_ABORT") != NULL) {
 312                 (void) printf("dumping core by request\n");
 313                 abort();
 314         }
 315
 316         exit(requested ? 0 : 2);
 317 }
 318
 319 void
 320 print_vdev_tree(zpool_handle_t *zhp, const char *name, nvlist_t *nv, int indent,
 321     boolean_t print_logs)
 322 {
 323         nvlist_t **child;
 324         uint_t c, children;
 325         char *vname;
 326
 327         if (name != NULL)
 328                 (void) printf("\t%*s%s\n", indent, "", name);
 329
 330         if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
 331             &child, &children) != 0)
 332                 return;
 333
 334         for (c = 0; c < children; c++) {
 335                 uint64_t is_log = B_FALSE;
 336
 337                 (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG,
 338                     &is_log);
 339                 if ((is_log && !print_logs) || (!is_log && print_logs))
 340                         continue;
 341
 342                 vname = zpool_vdev_name(g_zfs, zhp, child[c]);
 343                 print_vdev_tree(zhp, vname, child[c], indent + 2,
 344                     B_FALSE);
 345                 free(vname);
 346         }
 347 }
 348
 349 /*
 350  * Add a property pair (name, string-value) into a property nvlist.
 351  */
 352 static int
 353 add_prop_list(const char *propname, char *propval, nvlist_t **props,
 354     boolean_t poolprop)
 355 {
 356         zpool_prop_t prop = ZPROP_INVAL;
 357         zfs_prop_t fprop;
 358         nvlist_t *proplist;
 359         const char *normnm;
 360         char *strval;
 361
 362         if (*props == NULL &&
 363             nvlist_alloc(props, NV_UNIQUE_NAME, 0) != 0) {
 364                 (void) fprintf(stderr,
 365                     gettext("internal error: out of memory\n"));
 366                 return (1);
 367         }
 368
 369         proplist = *props;
 370
 371         if (poolprop) {
 372                 if ((prop = zpool_name_to_prop(propname)) == ZPROP_INVAL) {
 373                         (void) fprintf(stderr, gettext("property '%s' is "
 374                             "not a valid pool property\n"), propname);
 375                         return (2);
 376                 }
 377                 normnm = zpool_prop_to_name(prop);
 378         } else {
 379                 if ((fprop = zfs_name_to_prop(propname)) == ZPROP_INVAL) {
 380                         (void) fprintf(stderr, gettext("property '%s' is "
 381                             "not a valid file system property\n"), propname);
 382                         return (2);
 383                 }
 384                 normnm = zfs_prop_to_name(fprop);
 385         }
 386
 387         if (nvlist_lookup_string(proplist, normnm, &strval) == 0 &&
 388             prop != ZPOOL_PROP_CACHEFILE) {
 389                 (void) fprintf(stderr, gettext("property '%s' "
 390                     "specified multiple times\n"), propname);
 391                 return (2);
 392         }
 393
 394         if (nvlist_add_string(proplist, normnm, propval) != 0) {
 395                 (void) fprintf(stderr, gettext("internal "
 396                     "error: out of memory\n"));
 397                 return (1);
 398         }
 399
 400         return (0);
 401 }
 402
 403 /*
 404  * zpool add [-fn] <pool> <vdev> ...
 405  *
 406  *      -f      Force addition of devices, even if they appear in use
 407  *      -n      Do not add the devices, but display the resulting layout if
 408  *              they were to be added.
 409  *
 410  * Adds the given vdevs to 'pool'.  As with create, the bulk of this work is
 411  * handled by get_vdev_spec(), which constructs the nvlist needed to pass to
 412  * libzfs.
 413  */
 414 int
 415 zpool_do_add(int argc, char **argv)
 416 {
 417         boolean_t force = B_FALSE;
 418         boolean_t dryrun = B_FALSE;
 419         int c;
 420         nvlist_t *nvroot;
 421         char *poolname;
 422         int ret;
 423         zpool_handle_t *zhp;
 424         nvlist_t *config;
 425
 426         /* check options */
 427         while ((c = getopt(argc, argv, "fn")) != -1) {
 428                 switch (c) {
 429                 case 'f':
 430                         force = B_TRUE;
 431                         break;
 432                 case 'n':
 433                         dryrun = B_TRUE;
 434                         break;
 435                 case '?':
 436                         (void) fprintf(stderr, gettext("invalid option '%c'\n"),
 437                             optopt);
 438                         usage(B_FALSE);
 439                 }
 440         }
 441
 442         argc -= optind;
 443         argv += optind;
 444
 445         /* get pool name and check number of arguments */
 446         if (argc < 1) {
 447                 (void) fprintf(stderr, gettext("missing pool name argument\n"));
 448                 usage(B_FALSE);
 449         }
 450         if (argc < 2) {
 451                 (void) fprintf(stderr, gettext("missing vdev specification\n"));
 452                 usage(B_FALSE);
 453         }
 454
 455         poolname = argv[0];
 456
 457         argc--;
 458         argv++;
 459
 460         if ((zhp = zpool_open(g_zfs, poolname)) == NULL)
 461                 return (1);
 462
 463         if ((config = zpool_get_config(zhp, NULL)) == NULL) {
 464                 (void) fprintf(stderr, gettext("pool '%s' is unavailable\n"),
 465                     poolname);
 466                 zpool_close(zhp);
 467                 return (1);
 468         }
 469
 470         /* pass off to get_vdev_spec for processing */
 471         nvroot = make_root_vdev(zhp, force, !force, B_FALSE, dryrun,
 472             argc, argv);
 473         if (nvroot == NULL) {
 474                 zpool_close(zhp);
 475                 return (1);
 476         }
 477
 478         if (dryrun) {
 479                 nvlist_t *poolnvroot;
 480
 481                 verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
 482                     &poolnvroot) == 0);
 483
 484                 (void) printf(gettext("would update '%s' to the following "
 485                     "configuration:\n"), zpool_get_name(zhp));
 486
 487                 /* print original main pool and new tree */
 488                 print_vdev_tree(zhp, poolname, poolnvroot, 0, B_FALSE);
 489                 print_vdev_tree(zhp, NULL, nvroot, 0, B_FALSE);
 490
 491                 /* Do the same for the logs */
 492                 if (num_logs(poolnvroot) > 0) {
 493                         print_vdev_tree(zhp, "logs", poolnvroot, 0, B_TRUE);
 494                         print_vdev_tree(zhp, NULL, nvroot, 0, B_TRUE);
 495                 } else if (num_logs(nvroot) > 0) {
 496                         print_vdev_tree(zhp, "logs", nvroot, 0, B_TRUE);
 497                 }
 498
 499                 ret = 0;
 500         } else {
 501                 ret = (zpool_add(zhp, nvroot) != 0);
 502         }
 503
 504         nvlist_free(nvroot);
 505         zpool_close(zhp);
 506
 507         return (ret);
 508 }
 509
 510 /*
 511  * zpool remove <pool> <vdev> ...
 512  *
 513  * Removes the given vdev from the pool.  Currently, this only supports removing
 514  * spares and cache devices from the pool.  Eventually, we'll want to support
 515  * removing leaf vdevs (as an alias for 'detach') as well as toplevel vdevs.
 516  */
 517 int
 518 zpool_do_remove(int argc, char **argv)
 519 {
 520         char *poolname;
 521         int i, ret = 0;
 522         zpool_handle_t *zhp;
 523
 524         argc--;
 525         argv++;
 526
 527         /* get pool name and check number of arguments */
 528         if (argc < 1) {
 529                 (void) fprintf(stderr, gettext("missing pool name argument\n"));
 530                 usage(B_FALSE);
 531         }
 532         if (argc < 2) {
 533                 (void) fprintf(stderr, gettext("missing device\n"));
 534                 usage(B_FALSE);
 535         }
 536
 537         poolname = argv[0];
 538
 539         if ((zhp = zpool_open(g_zfs, poolname)) == NULL)
 540                 return (1);
 541
 542         for (i = 1; i < argc; i++) {
 543                 if (zpool_vdev_remove(zhp, argv[i]) != 0)
 544                         ret = 1;
 545         }
 546
 547         return (ret);
 548 }
 549
 550 /*
 551  * zpool create [-fn] [-o property=value] ...
 552  *              [-O file-system-property=value] ...
 553  *              [-R root] [-m mountpoint] <pool> <dev> ...
 554  *
 555  *      -f      Force creation, even if devices appear in use
 556  *      -n      Do not create the pool, but display the resulting layout if it
 557  *              were to be created.
 558  *      -R      Create a pool under an alternate root
 559  *      -m      Set default mountpoint for the root dataset.  By default it's
 560  *              '/<pool>'
 561  *      -o      Set property=value.
 562  *      -O      Set fsproperty=value in the pool's root file system
 563  *
 564  * Creates the named pool according to the given vdev specification.  The
 565  * bulk of the vdev processing is done in get_vdev_spec() in zpool_vdev.c.  Once
 566  * we get the nvlist back from get_vdev_spec(), we either print out the contents
 567  * (if '-n' was specified), or pass it to libzfs to do the creation.
 568  */
 569 int
 570 zpool_do_create(int argc, char **argv)
 571 {
 572         boolean_t force = B_FALSE;
 573         boolean_t dryrun = B_FALSE;
 574         int c;
 575         nvlist_t *nvroot = NULL;
 576         char *poolname;
 577         int ret = 1;
 578         char *altroot = NULL;
 579         char *mountpoint = NULL;
 580         nvlist_t *fsprops = NULL;
 581         nvlist_t *props = NULL;
 582         char *propval;
 583
 584         /* check options */
 585         while ((c = getopt(argc, argv, ":fnR:m:o:O:")) != -1) {
 586                 switch (c) {
 587                 case 'f':
 588                         force = B_TRUE;
 589                         break;
 590                 case 'n':
 591                         dryrun = B_TRUE;
 592                         break;
 593                 case 'R':
 594                         altroot = optarg;
 595                         if (add_prop_list(zpool_prop_to_name(
 596                             ZPOOL_PROP_ALTROOT), optarg, &props, B_TRUE))
 597                                 goto errout;
 598                         if (nvlist_lookup_string(props,
 599                             zpool_prop_to_name(ZPOOL_PROP_CACHEFILE),
 600                             &propval) == 0)
 601                                 break;
 602                         if (add_prop_list(zpool_prop_to_name(
 603                             ZPOOL_PROP_CACHEFILE), "none", &props, B_TRUE))
 604                                 goto errout;
 605                         break;
 606                 case 'm':
 607                         mountpoint = optarg;
 608                         break;
 609                 case 'o':
 610                         if ((propval = strchr(optarg, '=')) == NULL) {
 611                                 (void) fprintf(stderr, gettext("missing "
 612                                     "'=' for -o option\n"));
 613                                 goto errout;
 614                         }
 615                         *propval = '\0';
 616                         propval++;
 617
 618                         if (add_prop_list(optarg, propval, &props, B_TRUE))
 619                                 goto errout;
 620                         break;
 621                 case 'O':
 622                         if ((propval = strchr(optarg, '=')) == NULL) {
 623                                 (void) fprintf(stderr, gettext("missing "
 624                                     "'=' for -O option\n"));
 625                                 goto errout;
 626                         }
 627                         *propval = '\0';
 628                         propval++;
 629
 630                         if (add_prop_list(optarg, propval, &fsprops, B_FALSE))
 631                                 goto errout;
 632                         break;
 633                 case ':':
 634                         (void) fprintf(stderr, gettext("missing argument for "
 635                             "'%c' option\n"), optopt);
 636                         goto badusage;
 637                 case '?':
 638                         (void) fprintf(stderr, gettext("invalid option '%c'\n"),
 639                             optopt);
 640                         goto badusage;
 641                 }
 642         }
 643
 644         argc -= optind;
 645         argv += optind;
 646
 647         /* get pool name and check number of arguments */
 648         if (argc < 1) {
 649                 (void) fprintf(stderr, gettext("missing pool name argument\n"));
 650                 goto badusage;
 651         }
 652         if (argc < 2) {
 653                 (void) fprintf(stderr, gettext("missing vdev specification\n"));
 654                 goto badusage;
 655         }
 656
 657         poolname = argv[0];
 658
 659         /*
 660          * As a special case, check for use of '/' in the name, and direct the
 661          * user to use 'zfs create' instead.
 662          */
 663         if (strchr(poolname, '/') != NULL) {
 664                 (void) fprintf(stderr, gettext("cannot create '%s': invalid "
 665                     "character '/' in pool name\n"), poolname);
 666                 (void) fprintf(stderr, gettext("use 'zfs create' to "
 667                     "create a dataset\n"));
 668                 goto errout;
 669         }
 670
 671         /* pass off to get_vdev_spec for bulk processing */
 672         nvroot = make_root_vdev(NULL, force, !force, B_FALSE, dryrun,
 673             argc - 1, argv + 1);
 674         if (nvroot == NULL)
 675                 goto errout;
 676
 677         /* make_root_vdev() allows 0 toplevel children if there are spares */
 678         if (!zfs_allocatable_devs(nvroot)) {
 679                 (void) fprintf(stderr, gettext("invalid vdev "
 680                     "specification: at least one toplevel vdev must be "
 681                     "specified\n"));
 682                 goto errout;
 683         }
 684
 685
 686         if (altroot != NULL && altroot[0] != '/') {
 687                 (void) fprintf(stderr, gettext("invalid alternate root '%s': "
 688                     "must be an absolute path\n"), altroot);
 689                 goto errout;
 690         }
 691
 692         /*
 693          * Check the validity of the mountpoint and direct the user to use the
 694          * '-m' mountpoint option if it looks like its in use.
 695          */
 696         if (mountpoint == NULL ||
 697             (strcmp(mountpoint, ZFS_MOUNTPOINT_LEGACY) != 0 &&
 698             strcmp(mountpoint, ZFS_MOUNTPOINT_NONE) != 0)) {
 699                 char buf[MAXPATHLEN];
 700                 DIR *dirp;
 701
 702                 if (mountpoint && mountpoint[0] != '/') {
 703                         (void) fprintf(stderr, gettext("invalid mountpoint "
 704                             "'%s': must be an absolute path, 'legacy', or "
 705                             "'none'\n"), mountpoint);
 706                         goto errout;
 707                 }
 708
 709                 if (mountpoint == NULL) {
 710                         if (altroot != NULL)
 711                                 (void) snprintf(buf, sizeof (buf), "%s/%s",
 712                                     altroot, poolname);
 713                         else
 714                                 (void) snprintf(buf, sizeof (buf), "/%s",
 715                                     poolname);
 716                 } else {
 717                         if (altroot != NULL)
 718                                 (void) snprintf(buf, sizeof (buf), "%s%s",
 719                                     altroot, mountpoint);
 720                         else
 721                                 (void) snprintf(buf, sizeof (buf), "%s",
 722                                     mountpoint);
 723                 }
 724
 725                 if ((dirp = opendir(buf)) == NULL && errno != ENOENT) {
 726                         (void) fprintf(stderr, gettext("mountpoint '%s' : "
 727                             "%s\n"), buf, strerror(errno));
 728                         (void) fprintf(stderr, gettext("use '-m' "
 729                             "option to provide a different default\n"));
 730                         goto errout;
 731                 } else if (dirp) {
 732                         int count = 0;
 733
 734                         while (count < 3 && readdir(dirp) != NULL)
 735                                 count++;
 736                         (void) closedir(dirp);
 737
 738                         if (count > 2) {
 739                                 (void) fprintf(stderr, gettext("mountpoint "
 740                                     "'%s' exists and is not empty\n"), buf);
 741                                 (void) fprintf(stderr, gettext("use '-m' "
 742                                     "option to provide a "
 743                                     "different default\n"));
 744                                 goto errout;
 745                         }
 746                 }
 747         }
 748
 749         if (dryrun) {
 750                 /*
 751                  * For a dry run invocation, print out a basic message and run
 752                  * through all the vdevs in the list and print out in an
 753                  * appropriate hierarchy.
 754                  */
 755                 (void) printf(gettext("would create '%s' with the "
 756                     "following layout:\n\n"), poolname);
 757
 758                 print_vdev_tree(NULL, poolname, nvroot, 0, B_FALSE);
 759                 if (num_logs(nvroot) > 0)
 760                         print_vdev_tree(NULL, "logs", nvroot, 0, B_TRUE);
 761
 762                 ret = 0;
 763         } else {
 764                 /*
 765                  * Hand off to libzfs.
 766                  */
 767                 if (zpool_create(g_zfs, poolname,
 768                     nvroot, props, fsprops) == 0) {
 769                         zfs_handle_t *pool = zfs_open(g_zfs, poolname,
 770                             ZFS_TYPE_FILESYSTEM);
 771                         if (pool != NULL) {
 772                                 if (mountpoint != NULL)
 773                                         verify(zfs_prop_set(pool,
 774                                             zfs_prop_to_name(
 775                                             ZFS_PROP_MOUNTPOINT),
 776                                             mountpoint) == 0);
 777                                 if (zfs_mount(pool, NULL, 0) == 0)
 778                                         ret = zfs_shareall(pool);
 779                                 zfs_close(pool);
 780                         }
 781                 } else if (libzfs_errno(g_zfs) == EZFS_INVALIDNAME) {
 782                         (void) fprintf(stderr, gettext("pool name may have "
 783                             "been omitted\n"));
 784                 }
 785         }
 786
 787 errout:
 788         nvlist_free(nvroot);
 789         nvlist_free(fsprops);
 790         nvlist_free(props);
 791         return (ret);
 792 badusage:
 793         nvlist_free(fsprops);
 794         nvlist_free(props);
 795         usage(B_FALSE);
 796         return (2);
 797 }
 798
 799 /*
 800  * zpool destroy <pool>
 801  *
 802  *      -f      Forcefully unmount any datasets
 803  *
 804  * Destroy the given pool.  Automatically unmounts any datasets in the pool.
 805  */
 806 int
 807 zpool_do_destroy(int argc, char **argv)
 808 {
 809         boolean_t force = B_FALSE;
 810         int c;
 811         char *pool;
 812         zpool_handle_t *zhp;
 813         int ret;
 814
 815         /* check options */
 816         while ((c = getopt(argc, argv, "f")) != -1) {
 817                 switch (c) {
 818                 case 'f':
 819                         force = B_TRUE;
 820                         break;
 821                 case '?':
 822                         (void) fprintf(stderr, gettext("invalid option '%c'\n"),
 823                             optopt);
 824                         usage(B_FALSE);
 825                 }
 826         }
 827
 828         argc -= optind;
 829         argv += optind;
 830
 831         /* check arguments */
 832         if (argc < 1) {
 833                 (void) fprintf(stderr, gettext("missing pool argument\n"));
 834                 usage(B_FALSE);
 835         }
 836         if (argc > 1) {
 837                 (void) fprintf(stderr, gettext("too many arguments\n"));
 838                 usage(B_FALSE);
 839         }
 840
 841         pool = argv[0];
 842
 843         if ((zhp = zpool_open_canfail(g_zfs, pool)) == NULL) {
 844                 /*
 845                  * As a special case, check for use of '/' in the name, and
 846                  * direct the user to use 'zfs destroy' instead.
 847                  */
 848                 if (strchr(pool, '/') != NULL)
 849                         (void) fprintf(stderr, gettext("use 'zfs destroy' to "
 850                             "destroy a dataset\n"));
 851                 return (1);
 852         }
 853
 854         if (zpool_disable_datasets(zhp, force) != 0) {
 855                 (void) fprintf(stderr, gettext("could not destroy '%s': "
 856                     "could not unmount datasets\n"), zpool_get_name(zhp));
 857                 return (1);
 858         }
 859
 860         ret = (zpool_destroy(zhp) != 0);
 861
 862         zpool_close(zhp);
 863
 864         return (ret);
 865 }
 866
 867 /*
 868  * zpool export [-f] <pool> ...
 869  *
 870  *      -f      Forcefully unmount datasets
 871  *
 872  * Export the given pools.  By default, the command will attempt to cleanly
 873  * unmount any active datasets within the pool.  If the '-f' flag is specified,
 874  * then the datasets will be forcefully unmounted.
 875  */
 876 int
 877 zpool_do_export(int argc, char **argv)
 878 {
 879         boolean_t force = B_FALSE;
 880         int c;
 881         zpool_handle_t *zhp;
 882         int ret;
 883         int i;
 884
 885         /* check options */
 886         while ((c = getopt(argc, argv, "f")) != -1) {
 887                 switch (c) {
 888                 case 'f':
 889                         force = B_TRUE;
 890                         break;
 891                 case '?':
 892                         (void) fprintf(stderr, gettext("invalid option '%c'\n"),
 893                             optopt);
 894                         usage(B_FALSE);
 895                 }
 896         }
 897
 898         argc -= optind;
 899         argv += optind;
 900
 901         /* check arguments */
 902         if (argc < 1) {
 903                 (void) fprintf(stderr, gettext("missing pool argument\n"));
 904                 usage(B_FALSE);
 905         }
 906
 907         ret = 0;
 908         for (i = 0; i < argc; i++) {
 909                 if ((zhp = zpool_open_canfail(g_zfs, argv[i])) == NULL) {
 910                         ret = 1;
 911                         continue;
 912                 }
 913
 914                 if (zpool_disable_datasets(zhp, force) != 0) {
 915                         ret = 1;
 916                         zpool_close(zhp);
 917                         continue;
 918                 }
 919
 920                 if (zpool_export(zhp, force) != 0)
 921                         ret = 1;
 922
 923                 zpool_close(zhp);
 924         }
 925
 926         return (ret);
 927 }
 928
 929 /*
 930  * Given a vdev configuration, determine the maximum width needed for the device
 931  * name column.
 932  */
 933 static int
 934 max_width(zpool_handle_t *zhp, nvlist_t *nv, int depth, int max)
 935 {
 936         char *name = zpool_vdev_name(g_zfs, zhp, nv);
 937         nvlist_t **child;
 938         uint_t c, children;
 939         int ret;
 940
 941         if (strlen(name) + depth > max)
 942                 max = strlen(name) + depth;
 943
 944         free(name);
 945
 946         if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES,
 947             &child, &children) == 0) {
 948                 for (c = 0; c < children; c++)
 949                         if ((ret = max_width(zhp, child[c], depth + 2,
 950                             max)) > max)
 951                                 max = ret;
 952         }
 953
 954         if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE,
 955             &child, &children) == 0) {
 956                 for (c = 0; c < children; c++)
 957                         if ((ret = max_width(zhp, child[c], depth + 2,
 958                             max)) > max)
 959                                 max = ret;
 960         }
 961
 962         if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
 963             &child, &children) == 0) {
 964                 for (c = 0; c < children; c++)
 965                         if ((ret = max_width(zhp, child[c], depth + 2,
 966                             max)) > max)
 967                                 max = ret;
 968         }
 969
 970
 971         return (max);
 972 }
 973
 974
 975 /*
 976  * Print the configuration of an exported pool.  Iterate over all vdevs in the
 977  * pool, printing out the name and status for each one.
 978  */
 979 void
 980 print_import_config(const char *name, nvlist_t *nv, int namewidth, int depth,
 981     boolean_t print_logs)
 982 {
 983         nvlist_t **child;
 984         uint_t c, children;
 985         vdev_stat_t *vs;
 986         char *type, *vname;
 987
 988         verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) == 0);
 989         if (strcmp(type, VDEV_TYPE_MISSING) == 0)
 990                 return;
 991
 992         verify(nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_STATS,
 993             (uint64_t **)&vs, &c) == 0);
 994
 995         (void) printf("\t%*s%-*s", depth, "", namewidth - depth, name);
 996         (void) printf("  %s", zpool_state_to_name(vs->vs_state, vs->vs_aux));
 997
 998         if (vs->vs_aux != 0) {
 999                 (void) printf("  ");
1000
1001                 switch (vs->vs_aux) {
1002                 case VDEV_AUX_OPEN_FAILED:
1003                         (void) printf(gettext("cannot open"));
1004                         break;
1005
1006                 case VDEV_AUX_BAD_GUID_SUM:
1007                         (void) printf(gettext("missing device"));
1008                         break;
1009
1010                 case VDEV_AUX_NO_REPLICAS:
1011                         (void) printf(gettext("insufficient replicas"));
1012                         break;
1013
1014                 case VDEV_AUX_VERSION_NEWER:
1015                         (void) printf(gettext("newer version"));
1016                         break;
1017
1018                 case VDEV_AUX_ERR_EXCEEDED:
1019                         (void) printf(gettext("too many errors"));
1020                         break;
1021
1022                 default:
1023                         (void) printf(gettext("corrupted data"));
1024                         break;
1025                 }
1026         }
1027         (void) printf("\n");
1028
1029         if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
1030             &child, &children) != 0)
1031                 return;
1032
1033         for (c = 0; c < children; c++) {
1034                 uint64_t is_log = B_FALSE;
1035
1036                 (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG,
1037                     &is_log);
1038                 if ((is_log && !print_logs) || (!is_log && print_logs))
1039                         continue;
1040
1041                 vname = zpool_vdev_name(g_zfs, NULL, child[c]);
1042                 print_import_config(vname, child[c],
1043                     namewidth, depth + 2, B_FALSE);
1044                 free(vname);
1045         }
1046
1047         if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE,
1048             &child, &children) == 0) {
1049                 (void) printf(gettext("\tcache\n"));
1050                 for (c = 0; c < children; c++) {
1051                         vname = zpool_vdev_name(g_zfs, NULL, child[c]);
1052                         (void) printf("\t  %s\n", vname);
1053                         free(vname);
1054                 }
1055         }
1056
1057         if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES,
1058             &child, &children) == 0) {
1059                 (void) printf(gettext("\tspares\n"));
1060                 for (c = 0; c < children; c++) {
1061                         vname = zpool_vdev_name(g_zfs, NULL, child[c]);
1062                         (void) printf("\t  %s\n", vname);
1063                         free(vname);
1064                 }
1065         }
1066 }
1067
1068 /*
1069  * Display the status for the given pool.
1070  */
1071 static void
1072 show_import(nvlist_t *config)
1073 {
1074         uint64_t pool_state;
1075         vdev_stat_t *vs;
1076         char *name;
1077         uint64_t guid;
1078         char *msgid;
1079         nvlist_t *nvroot;
1080         int reason;
1081         const char *health;
1082         uint_t vsc;
1083         int namewidth;
1084
1085         verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME,
1086             &name) == 0);
1087         verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID,
1088             &guid) == 0);
1089         verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE,
1090             &pool_state) == 0);
1091         verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
1092             &nvroot) == 0);
1093
1094         verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_STATS,
1095             (uint64_t **)&vs, &vsc) == 0);
1096         health = zpool_state_to_name(vs->vs_state, vs->vs_aux);
1097
1098         reason = zpool_import_status(config, &msgid);
1099
1100         (void) printf(gettext("  pool: %s\n"), name);
1101         (void) printf(gettext("    id: %llu\n"), (u_longlong_t)guid);
1102         (void) printf(gettext(" state: %s"), health);
1103         if (pool_state == POOL_STATE_DESTROYED)
1104                 (void) printf(gettext(" (DESTROYED)"));
1105         (void) printf("\n");
1106
1107         switch (reason) {
1108         case ZPOOL_STATUS_MISSING_DEV_R:
1109         case ZPOOL_STATUS_MISSING_DEV_NR:
1110         case ZPOOL_STATUS_BAD_GUID_SUM:
1111                 (void) printf(gettext("status: One or more devices are missing "
1112                     "from the system.\n"));
1113                 break;
1114
1115         case ZPOOL_STATUS_CORRUPT_LABEL_R:
1116         case ZPOOL_STATUS_CORRUPT_LABEL_NR:
1117                 (void) printf(gettext("status: One or more devices contains "
1118                     "corrupted data.\n"));
1119                 break;
1120
1121         case ZPOOL_STATUS_CORRUPT_DATA:
1122                 (void) printf(gettext("status: The pool data is corrupted.\n"));
1123                 break;
1124
1125         case ZPOOL_STATUS_OFFLINE_DEV:
1126                 (void) printf(gettext("status: One or more devices "
1127                     "are offlined.\n"));
1128                 break;
1129
1130         case ZPOOL_STATUS_CORRUPT_POOL:
1131                 (void) printf(gettext("status: The pool metadata is "
1132                     "corrupted.\n"));
1133                 break;
1134
1135         case ZPOOL_STATUS_VERSION_OLDER:
1136                 (void) printf(gettext("status: The pool is formatted using an "
1137                     "older on-disk version.\n"));
1138                 break;
1139
1140         case ZPOOL_STATUS_VERSION_NEWER:
1141                 (void) printf(gettext("status: The pool is formatted using an "
1142                     "incompatible version.\n"));
1143                 break;
1144
1145         case ZPOOL_STATUS_HOSTID_MISMATCH:
1146                 (void) printf(gettext("status: The pool was last accessed by "
1147                     "another system.\n"));
1148                 break;
1149
1150         case ZPOOL_STATUS_FAULTED_DEV_R:
1151         case ZPOOL_STATUS_FAULTED_DEV_NR:
1152                 (void) printf(gettext("status: One or more devices are "
1153                     "faulted.\n"));
1154                 break;
1155
1156         case ZPOOL_STATUS_BAD_LOG:
1157                 (void) printf(gettext("status: An intent log record cannot be "
1158                     "read.\n"));
1159                 break;
1160
1161         default:
1162                 /*
1163                  * No other status can be seen when importing pools.
1164                  */
1165                 assert(reason == ZPOOL_STATUS_OK);
1166         }
1167
1168         /*
1169          * Print out an action according to the overall state of the pool.
1170          */
1171         if (vs->vs_state == VDEV_STATE_HEALTHY) {
1172                 if (reason == ZPOOL_STATUS_VERSION_OLDER)
1173                         (void) printf(gettext("action: The pool can be "
1174                             "imported using its name or numeric identifier, "
1175                             "though\n\tsome features will not be available "
1176                             "without an explicit 'zpool upgrade'.\n"));
1177                 else if (reason == ZPOOL_STATUS_HOSTID_MISMATCH)
1178                         (void) printf(gettext("action: The pool can be "
1179                             "imported using its name or numeric "
1180                             "identifier and\n\tthe '-f' flag.\n"));
1181                 else
1182                         (void) printf(gettext("action: The pool can be "
1183                             "imported using its name or numeric "
1184                             "identifier.\n"));
1185         } else if (vs->vs_state == VDEV_STATE_DEGRADED) {
1186                 (void) printf(gettext("action: The pool can be imported "
1187                     "despite missing or damaged devices.  The\n\tfault "
1188                     "tolerance of the pool may be compromised if imported.\n"));
1189         } else {
1190                 switch (reason) {
1191                 case ZPOOL_STATUS_VERSION_NEWER:
1192                         (void) printf(gettext("action: The pool cannot be "
1193                             "imported.  Access the pool on a system running "
1194                             "newer\n\tsoftware, or recreate the pool from "
1195                             "backup.\n"));
1196                         break;
1197                 case ZPOOL_STATUS_MISSING_DEV_R:
1198                 case ZPOOL_STATUS_MISSING_DEV_NR:
1199                 case ZPOOL_STATUS_BAD_GUID_SUM:
1200                         (void) printf(gettext("action: The pool cannot be "
1201                             "imported. Attach the missing\n\tdevices and try "
1202                             "again.\n"));
1203                         break;
1204                 default:
1205                         (void) printf(gettext("action: The pool cannot be "
1206                             "imported due to damaged devices or data.\n"));
1207                 }
1208         }
1209
1210         /*
1211          * If the state is "closed" or "can't open", and the aux state
1212          * is "corrupt data":
1213          */
1214         if (((vs->vs_state == VDEV_STATE_CLOSED) ||
1215             (vs->vs_state == VDEV_STATE_CANT_OPEN)) &&
1216             (vs->vs_aux == VDEV_AUX_CORRUPT_DATA)) {
1217                 if (pool_state == POOL_STATE_DESTROYED)
1218                         (void) printf(gettext("\tThe pool was destroyed, "
1219                             "but can be imported using the '-Df' flags.\n"));
1220                 else if (pool_state != POOL_STATE_EXPORTED)
1221                         (void) printf(gettext("\tThe pool may be active on "
1222                             "another system, but can be imported using\n\t"
1223                             "the '-f' flag.\n"));
1224         }
1225
1226         if (msgid != NULL)
1227                 (void) printf(gettext("   see: http://www.sun.com/msg/%s\n"),
1228                     msgid);
1229
1230         (void) printf(gettext("config:\n\n"));
1231
1232         namewidth = max_width(NULL, nvroot, 0, 0);
1233         if (namewidth < 10)
1234                 namewidth = 10;
1235
1236         print_import_config(name, nvroot, namewidth, 0, B_FALSE);
1237         if (num_logs(nvroot) > 0) {
1238                 (void) printf(gettext("\tlogs\n"));
1239                 print_import_config(name, nvroot, namewidth, 0, B_TRUE);
1240         }
1241
1242         if (reason == ZPOOL_STATUS_BAD_GUID_SUM) {
1243                 (void) printf(gettext("\n\tAdditional devices are known to "
1244                     "be part of this pool, though their\n\texact "
1245                     "configuration cannot be determined.\n"));
1246         }
1247 }
1248
1249 /*
1250  * Perform the import for the given configuration.  This passes the heavy
1251  * lifting off to zpool_import_props(), and then mounts the datasets contained
1252  * within the pool.
1253  */
1254 static int
1255 do_import(nvlist_t *config, const char *newname, const char *mntopts,
1256     int force, nvlist_t *props, boolean_t allowfaulted)
1257 {
1258         zpool_handle_t *zhp;
1259         char *name;
1260         uint64_t state;
1261         uint64_t version;
1262         int error = 0;
1263
1264         verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME,
1265             &name) == 0);
1266
1267         verify(nvlist_lookup_uint64(config,
1268             ZPOOL_CONFIG_POOL_STATE, &state) == 0);
1269         verify(nvlist_lookup_uint64(config,
1270             ZPOOL_CONFIG_VERSION, &version) == 0);
1271         if (version > SPA_VERSION) {
1272                 (void) fprintf(stderr, gettext("cannot import '%s': pool "
1273                     "is formatted using a newer ZFS version\n"), name);
1274                 return (1);
1275         } else if (state != POOL_STATE_EXPORTED && !force) {
1276                 uint64_t hostid;
1277
1278                 if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_HOSTID,
1279                     &hostid) == 0) {
1280                         if ((unsigned long)hostid != gethostid()) {
1281                                 char *hostname;
1282                                 uint64_t timestamp;
1283                                 time_t t;
1284
1285                                 verify(nvlist_lookup_string(config,
1286                                     ZPOOL_CONFIG_HOSTNAME, &hostname) == 0);
1287                                 verify(nvlist_lookup_uint64(config,
1288                                     ZPOOL_CONFIG_TIMESTAMP, &timestamp) == 0);
1289                                 t = timestamp;
1290                                 (void) fprintf(stderr, gettext("cannot import "
1291                                     "'%s': pool may be in use from other "
1292                                     "system, it was last accessed by %s "
1293                                     "(hostid: 0x%lx) on %s"), name, hostname,
1294                                     (unsigned long)hostid,
1295                                     asctime(localtime(&t)));
1296                                 (void) fprintf(stderr, gettext("use '-f' to "
1297                                     "import anyway\n"));
1298                                 return (1);
1299                         }
1300                 } else {
1301                         (void) fprintf(stderr, gettext("cannot import '%s': "
1302                             "pool may be in use from other system\n"), name);
1303                         (void) fprintf(stderr, gettext("use '-f' to import "
1304                             "anyway\n"));
1305                         return (1);
1306                 }
1307         }
1308
1309         if (zpool_import_props(g_zfs, config, newname, props,
1310             allowfaulted) != 0)
1311                 return (1);
1312
1313         if (newname != NULL)
1314                 name = (char *)newname;
1315
1316         verify((zhp = zpool_open_canfail(g_zfs, name)) != NULL);
1317
1318         if (zpool_enable_datasets(zhp, mntopts, 0) != 0) {
1319                 zpool_close(zhp);
1320                 return (1);
1321         }
1322
1323         zpool_close(zhp);
1324         return (error);
1325 }
1326
1327 /*
1328  * zpool import [-d dir] [-D]
1329  *       import [-o mntopts] [-o prop=value] ... [-R root] [-D]
1330  *              [-d dir | -c cachefile] [-f] -a
1331  *       import [-o mntopts] [-o prop=value] ... [-R root] [-D]
1332  *              [-d dir | -c cachefile] [-f] <pool | id> [newpool]
1333  *
1334  *       -c     Read pool information from a cachefile instead of searching
1335  *              devices.
1336  *
1337  *       -d     Scan in a specific directory, other than /dev/dsk.  More than
1338  *              one directory can be specified using multiple '-d' options.
1339  *
1340  *       -D     Scan for previously destroyed pools or import all or only
1341  *              specified destroyed pools.
1342  *
1343  *       -R     Temporarily import the pool, with all mountpoints relative to
1344  *              the given root.  The pool will remain exported when the machine
1345  *              is rebooted.
1346  *
1347  *       -f     Force import, even if it appears that the pool is active.
1348  *
1349  *       -F     Import even in the presence of faulted vdevs.  This is an
1350  *              intentionally undocumented option for testing purposes, and
1351  *              treats the pool configuration as complete, leaving any bad
1352  *              vdevs in the FAULTED state.
1353  *
1354  *       -a     Import all pools found.
1355  *
1356  *       -o     Set property=value and/or temporary mount options (without '=').
1357  *
1358  * The import command scans for pools to import, and import pools based on pool
1359  * name and GUID.  The pool can also be renamed as part of the import process.
1360  */
1361 int
1362 zpool_do_import(int argc, char **argv)
1363 {
1364         char **searchdirs = NULL;
1365         int nsearch = 0;
1366         int c;
1367         int err;
1368         nvlist_t *pools = NULL;
1369         boolean_t do_all = B_FALSE;
1370         boolean_t do_destroyed = B_FALSE;
1371         char *mntopts = NULL;
1372         boolean_t do_force = B_FALSE;
1373         nvpair_t *elem;
1374         nvlist_t *config;
1375         uint64_t searchguid = 0;
1376         char *searchname = NULL;
1377         char *propval;
1378         nvlist_t *found_config;
1379         nvlist_t *props = NULL;
1380         boolean_t first;
1381         boolean_t allow_faulted = B_FALSE;
1382         uint64_t pool_state;
1383         char *cachefile = NULL;
1384
1385         /* check options */
1386         while ((c = getopt(argc, argv, ":ac:d:DfFo:p:R:")) != -1) {
1387                 switch (c) {
1388                 case 'a':
1389                         do_all = B_TRUE;
1390                         break;
1391                 case 'c':
1392                         cachefile = optarg;
1393                         break;
1394                 case 'd':
1395                         if (searchdirs == NULL) {
1396                                 searchdirs = safe_malloc(sizeof (char *));
1397                         } else {
1398                                 char **tmp = safe_malloc((nsearch + 1) *
1399                                     sizeof (char *));
1400                                 bcopy(searchdirs, tmp, nsearch *
1401                                     sizeof (char *));
1402                                 free(searchdirs);
1403                                 searchdirs = tmp;
1404                         }
1405                         searchdirs[nsearch++] = optarg;
1406                         break;
1407                 case 'D':
1408                         do_destroyed = B_TRUE;
1409                         break;
1410                 case 'f':
1411                         do_force = B_TRUE;
1412                         break;
1413                 case 'F':
1414                         allow_faulted = B_TRUE;
1415                         break;
1416                 case 'o':
1417                         if ((propval = strchr(optarg, '=')) != NULL) {
1418                                 *propval = '\0';
1419                                 propval++;
1420                                 if (add_prop_list(optarg, propval,
1421                                     &props, B_TRUE))
1422                                         goto error;
1423                         } else {
1424                                 mntopts = optarg;
1425                         }
1426                         break;
1427                 case 'R':
1428                         if (add_prop_list(zpool_prop_to_name(
1429                             ZPOOL_PROP_ALTROOT), optarg, &props, B_TRUE))
1430                                 goto error;
1431                         if (nvlist_lookup_string(props,
1432                             zpool_prop_to_name(ZPOOL_PROP_CACHEFILE),
1433                             &propval) == 0)
1434                                 break;
1435                         if (add_prop_list(zpool_prop_to_name(
1436                             ZPOOL_PROP_CACHEFILE), "none", &props, B_TRUE))
1437                                 goto error;
1438                         break;
1439                 case ':':
1440                         (void) fprintf(stderr, gettext("missing argument for "
1441                             "'%c' option\n"), optopt);
1442                         usage(B_FALSE);
1443                         break;
1444                 case '?':
1445                         (void) fprintf(stderr, gettext("invalid option '%c'\n"),
1446                             optopt);
1447                         usage(B_FALSE);
1448                 }
1449         }
1450
1451         argc -= optind;
1452         argv += optind;
1453
1454         if (cachefile && nsearch != 0) {
1455                 (void) fprintf(stderr, gettext("-c is incompatible with -d\n"));
1456                 usage(B_FALSE);
1457         }
1458
1459         if (searchdirs == NULL) {
1460                 searchdirs = safe_malloc(sizeof (char *));
1461                 searchdirs[0] = "/dev/dsk";
1462                 nsearch = 1;
1463         }
1464
1465         /* check argument count */
1466         if (do_all) {
1467                 if (argc != 0) {
1468                         (void) fprintf(stderr, gettext("too many arguments\n"));
1469                         usage(B_FALSE);
1470                 }
1471         } else {
1472                 if (argc > 2) {
1473                         (void) fprintf(stderr, gettext("too many arguments\n"));
1474                         usage(B_FALSE);
1475                 }
1476
1477                 /*
1478                  * Check for the SYS_CONFIG privilege.  We do this explicitly
1479                  * here because otherwise any attempt to discover pools will
1480                  * silently fail.
1481                  */
1482                 if (argc == 0 && !priv_ineffect(PRIV_SYS_CONFIG)) {
1483                         (void) fprintf(stderr, gettext("cannot "
1484                             "discover pools: permission denied\n"));
1485                         free(searchdirs);
1486                         return (1);
1487                 }
1488         }
1489
1490         /*
1491          * Depending on the arguments given, we do one of the following:
1492          *
1493          *      <none>  Iterate through all pools and display information about
1494          *              each one.
1495          *
1496          *      -a      Iterate through all pools and try to import each one.
1497          *
1498          *      <id>    Find the pool that corresponds to the given GUID/pool
1499          *              name and import that one.
1500          *
1501          *      -D      Above options applies only to destroyed pools.
1502          */
1503         if (argc != 0) {
1504                 char *endptr;
1505
1506                 errno = 0;
1507                 searchguid = strtoull(argv[0], &endptr, 10);
1508                 if (errno != 0 || *endptr != '\0')
1509                         searchname = argv[0];
1510                 found_config = NULL;
1511         }
1512
1513         if (cachefile) {
1514                 pools = zpool_find_import_cached(g_zfs, cachefile, searchname,
1515                     searchguid);
1516         } else if (searchname != NULL) {
1517                 pools = zpool_find_import_byname(g_zfs, nsearch, searchdirs,
1518                     searchname);
1519         } else {
1520                 /*
1521                  * It's OK to search by guid even if searchguid is 0.
1522                  */
1523                 pools = zpool_find_import_byguid(g_zfs, nsearch, searchdirs,
1524                     searchguid);
1525         }
1526
1527         if (pools == NULL) {
1528                 if (argc != 0) {
1529                         (void) fprintf(stderr, gettext("cannot import '%s': "
1530                             "no such pool available\n"), argv[0]);
1531                 }
1532                 free(searchdirs);
1533                 return (1);
1534         }
1535
1536         /*
1537          * At this point we have a list of import candidate configs. Even if
1538          * we were searching by pool name or guid, we still need to
1539          * post-process the list to deal with pool state and possible
1540          * duplicate names.
1541          */
1542         err = 0;
1543         elem = NULL;
1544         first = B_TRUE;
1545         while ((elem = nvlist_next_nvpair(pools, elem)) != NULL) {
1546
1547                 verify(nvpair_value_nvlist(elem, &config) == 0);
1548
1549                 verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE,
1550                     &pool_state) == 0);
1551                 if (!do_destroyed && pool_state == POOL_STATE_DESTROYED)
1552                         continue;
1553                 if (do_destroyed && pool_state != POOL_STATE_DESTROYED)
1554                         continue;
1555
1556                 if (argc == 0) {
1557                         if (first)
1558                                 first = B_FALSE;
1559                         else if (!do_all)
1560                                 (void) printf("\n");
1561
1562                         if (do_all)
1563                                 err |= do_import(config, NULL, mntopts,
1564                                     do_force, props, allow_faulted);
1565                         else
1566                                 show_import(config);
1567                 } else if (searchname != NULL) {
1568                         char *name;
1569
1570                         /*
1571                          * We are searching for a pool based on name.
1572                          */
1573                         verify(nvlist_lookup_string(config,
1574                             ZPOOL_CONFIG_POOL_NAME, &name) == 0);
1575
1576                         if (strcmp(name, searchname) == 0) {
1577                                 if (found_config != NULL) {
1578                                         (void) fprintf(stderr, gettext(
1579                                             "cannot import '%s': more than "
1580                                             "one matching pool\n"), searchname);
1581                                         (void) fprintf(stderr, gettext(
1582                                             "import by numeric ID instead\n"));
1583                                         err = B_TRUE;
1584                                 }
1585                                 found_config = config;
1586                         }
1587                 } else {
1588                         uint64_t guid;
1589
1590                         /*
1591                          * Search for a pool by guid.
1592                          */
1593                         verify(nvlist_lookup_uint64(config,
1594                             ZPOOL_CONFIG_POOL_GUID, &guid) == 0);
1595
1596                         if (guid == searchguid)
1597                                 found_config = config;
1598                 }
1599         }
1600
1601         /*
1602          * If we were searching for a specific pool, verify that we found a
1603          * pool, and then do the import.
1604          */
1605         if (argc != 0 && err == 0) {
1606                 if (found_config == NULL) {
1607                         (void) fprintf(stderr, gettext("cannot import '%s': "
1608                             "no such pool available\n"), argv[0]);
1609                         err = B_TRUE;
1610                 } else {
1611                         err |= do_import(found_config, argc == 1 ? NULL :
1612                             argv[1], mntopts, do_force, props, allow_faulted);
1613                 }
1614         }
1615
1616         /*
1617          * If we were just looking for pools, report an error if none were
1618          * found.
1619          */
1620         if (argc == 0 && first)
1621                 (void) fprintf(stderr,
1622                     gettext("no pools available to import\n"));
1623
1624 error:
1625         nvlist_free(props);
1626         nvlist_free(pools);
1627         free(searchdirs);
1628
1629         return (err ? 1 : 0);
1630 }
1631
1632 typedef struct iostat_cbdata {
1633         zpool_list_t *cb_list;
1634         int cb_verbose;
1635         int cb_iteration;
1636         int cb_namewidth;
1637 } iostat_cbdata_t;
1638
1639 static void
1640 print_iostat_separator(iostat_cbdata_t *cb)
1641 {
1642         int i = 0;
1643
1644         for (i = 0; i < cb->cb_namewidth; i++)
1645                 (void) printf("-");
1646         (void) printf("  -----  -----  -----  -----  -----  -----\n");
1647 }
1648
1649 static void
1650 print_iostat_header(iostat_cbdata_t *cb)
1651 {
1652         (void) printf("%*s     capacity     operations    bandwidth\n",
1653             cb->cb_namewidth, "");
1654         (void) printf("%-*s   used  avail   read  write   read  write\n",
1655             cb->cb_namewidth, "pool");
1656         print_iostat_separator(cb);
1657 }
1658
1659 /*
1660  * Display a single statistic.
1661  */
1662 static void
1663 print_one_stat(uint64_t value)
1664 {
1665         char buf[64];
1666
1667         zfs_nicenum(value, buf, sizeof (buf));
1668         (void) printf("  %5s", buf);
1669 }
1670
1671 /*
1672  * Print out all the statistics for the given vdev.  This can either be the
1673  * toplevel configuration, or called recursively.  If 'name' is NULL, then this
1674  * is a verbose output, and we don't want to display the toplevel pool stats.
1675  */
1676 void
1677 print_vdev_stats(zpool_handle_t *zhp, const char *name, nvlist_t *oldnv,
1678     nvlist_t *newnv, iostat_cbdata_t *cb, int depth)
1679 {
1680         nvlist_t **oldchild, **newchild;
1681         uint_t c, children;
1682         vdev_stat_t *oldvs, *newvs;
1683         vdev_stat_t zerovs = { 0 };
1684         uint64_t tdelta;
1685         double scale;
1686         char *vname;
1687
1688         if (oldnv != NULL) {
1689                 verify(nvlist_lookup_uint64_array(oldnv, ZPOOL_CONFIG_STATS,
1690                     (uint64_t **)&oldvs, &c) == 0);
1691         } else {
1692                 oldvs = &zerovs;
1693         }
1694
1695         verify(nvlist_lookup_uint64_array(newnv, ZPOOL_CONFIG_STATS,
1696             (uint64_t **)&newvs, &c) == 0);
1697
1698         if (strlen(name) + depth > cb->cb_namewidth)
1699                 (void) printf("%*s%s", depth, "", name);
1700         else
1701                 (void) printf("%*s%s%*s", depth, "", name,
1702                     (int)(cb->cb_namewidth - strlen(name) - depth), "");
1703
1704         tdelta = newvs->vs_timestamp - oldvs->vs_timestamp;
1705
1706         if (tdelta == 0)
1707                 scale = 1.0;
1708         else
1709                 scale = (double)NANOSEC / tdelta;
1710
1711         /* only toplevel vdevs have capacity stats */
1712         if (newvs->vs_space == 0) {
1713                 (void) printf("      -      -");
1714         } else {
1715                 print_one_stat(newvs->vs_alloc);
1716                 print_one_stat(newvs->vs_space - newvs->vs_alloc);
1717         }
1718
1719         print_one_stat((uint64_t)(scale * (newvs->vs_ops[ZIO_TYPE_READ] -
1720             oldvs->vs_ops[ZIO_TYPE_READ])));
1721
1722         print_one_stat((uint64_t)(scale * (newvs->vs_ops[ZIO_TYPE_WRITE] -
1723             oldvs->vs_ops[ZIO_TYPE_WRITE])));
1724
1725         print_one_stat((uint64_t)(scale * (newvs->vs_bytes[ZIO_TYPE_READ] -
1726             oldvs->vs_bytes[ZIO_TYPE_READ])));
1727
1728         print_one_stat((uint64_t)(scale * (newvs->vs_bytes[ZIO_TYPE_WRITE] -
1729             oldvs->vs_bytes[ZIO_TYPE_WRITE])));
1730
1731         (void) printf("\n");
1732
1733         if (!cb->cb_verbose)
1734                 return;
1735
1736         if (nvlist_lookup_nvlist_array(newnv, ZPOOL_CONFIG_CHILDREN,
1737             &newchild, &children) != 0)
1738                 return;
1739
1740         if (oldnv && nvlist_lookup_nvlist_array(oldnv, ZPOOL_CONFIG_CHILDREN,
1741             &oldchild, &c) != 0)
1742                 return;
1743
1744         for (c = 0; c < children; c++) {
1745                 vname = zpool_vdev_name(g_zfs, zhp, newchild[c]);
1746                 print_vdev_stats(zhp, vname, oldnv ? oldchild[c] : NULL,
1747                     newchild[c], cb, depth + 2);
1748                 free(vname);
1749         }
1750
1751         /*
1752          * Include level 2 ARC devices in iostat output
1753          */
1754         if (nvlist_lookup_nvlist_array(newnv, ZPOOL_CONFIG_L2CACHE,
1755             &newchild, &children) != 0)
1756                 return;
1757
1758         if (oldnv && nvlist_lookup_nvlist_array(oldnv, ZPOOL_CONFIG_L2CACHE,
1759             &oldchild, &c) != 0)
1760                 return;
1761
1762         if (children > 0) {
1763                 (void) printf("%-*s      -      -      -      -      -      "
1764                     "-\n", cb->cb_namewidth, "cache");
1765                 for (c = 0; c < children; c++) {
1766                         vname = zpool_vdev_name(g_zfs, zhp, newchild[c]);
1767                         print_vdev_stats(zhp, vname, oldnv ? oldchild[c] : NULL,
1768                             newchild[c], cb, depth + 2);
1769                         free(vname);
1770                 }
1771         }
1772 }
1773
1774 static int
1775 refresh_iostat(zpool_handle_t *zhp, void *data)
1776 {
1777         iostat_cbdata_t *cb = data;
1778         boolean_t missing;
1779
1780         /*
1781          * If the pool has disappeared, remove it from the list and continue.
1782          */
1783         if (zpool_refresh_stats(zhp, &missing) != 0)
1784                 return (-1);
1785
1786         if (missing)
1787                 pool_list_remove(cb->cb_list, zhp);
1788
1789         return (0);
1790 }
1791
1792 /*
1793  * Callback to print out the iostats for the given pool.
1794  */
1795 int
1796 print_iostat(zpool_handle_t *zhp, void *data)
1797 {
1798         iostat_cbdata_t *cb = data;
1799         nvlist_t *oldconfig, *newconfig;
1800         nvlist_t *oldnvroot, *newnvroot;
1801
1802         newconfig = zpool_get_config(zhp, &oldconfig);
1803
1804         if (cb->cb_iteration == 1)
1805                 oldconfig = NULL;
1806
1807         verify(nvlist_lookup_nvlist(newconfig, ZPOOL_CONFIG_VDEV_TREE,
1808             &newnvroot) == 0);
1809
1810         if (oldconfig == NULL)
1811                 oldnvroot = NULL;
1812         else
1813                 verify(nvlist_lookup_nvlist(oldconfig, ZPOOL_CONFIG_VDEV_TREE,
1814                     &oldnvroot) == 0);
1815
1816         /*
1817          * Print out the statistics for the pool.
1818          */
1819         print_vdev_stats(zhp, zpool_get_name(zhp), oldnvroot, newnvroot, cb, 0);
1820
1821         if (cb->cb_verbose)
1822                 print_iostat_separator(cb);
1823
1824         return (0);
1825 }
1826
1827 int
1828 get_namewidth(zpool_handle_t *zhp, void *data)
1829 {
1830         iostat_cbdata_t *cb = data;
1831         nvlist_t *config, *nvroot;
1832
1833         if ((config = zpool_get_config(zhp, NULL)) != NULL) {
1834                 verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
1835                     &nvroot) == 0);
1836                 if (!cb->cb_verbose)
1837                         cb->cb_namewidth = strlen(zpool_get_name(zhp));
1838                 else
1839                         cb->cb_namewidth = max_width(zhp, nvroot, 0, 0);
1840         }
1841
1842         /*
1843          * The width must fall into the range [10,38].  The upper limit is the
1844          * maximum we can have and still fit in 80 columns.
1845          */
1846         if (cb->cb_namewidth < 10)
1847                 cb->cb_namewidth = 10;
1848         if (cb->cb_namewidth > 38)
1849                 cb->cb_namewidth = 38;
1850
1851         return (0);
1852 }
1853
1854 /*
1855  * zpool iostat [-v] [pool] ... [interval [count]]
1856  *
1857  *      -v      Display statistics for individual vdevs
1858  *
1859  * This command can be tricky because we want to be able to deal with pool
1860  * creation/destruction as well as vdev configuration changes.  The bulk of this
1861  * processing is handled by the pool_list_* routines in zpool_iter.c.  We rely
1862  * on pool_list_update() to detect the addition of new pools.  Configuration
1863  * changes are all handled within libzfs.
1864  */
1865 int
1866 zpool_do_iostat(int argc, char **argv)
1867 {
1868         int c;
1869         int ret;
1870         int npools;
1871         unsigned long interval = 0, count = 0;
1872         zpool_list_t *list;
1873         boolean_t verbose = B_FALSE;
1874         iostat_cbdata_t cb;
1875
1876         /* check options */
1877         while ((c = getopt(argc, argv, "v")) != -1) {
1878                 switch (c) {
1879                 case 'v':
1880                         verbose = B_TRUE;
1881                         break;
1882                 case '?':
1883                         (void) fprintf(stderr, gettext("invalid option '%c'\n"),
1884                             optopt);
1885                         usage(B_FALSE);
1886                 }
1887         }
1888
1889         argc -= optind;
1890         argv += optind;
1891
1892         /*
1893          * Determine if the last argument is an integer or a pool name
1894          */
1895         if (argc > 0 && isdigit(argv[argc - 1][0])) {
1896                 char *end;
1897
1898                 errno = 0;
1899                 interval = strtoul(argv[argc - 1], &end, 10);
1900
1901                 if (*end == '\0' && errno == 0) {
1902                         if (interval == 0) {
1903                                 (void) fprintf(stderr, gettext("interval "
1904                                     "cannot be zero\n"));
1905                                 usage(B_FALSE);
1906                         }
1907
1908                         /*
1909                          * Ignore the last parameter
1910                          */
1911                         argc--;
1912                 } else {
1913                         /*
1914                          * If this is not a valid number, just plow on.  The
1915                          * user will get a more informative error message later
1916                          * on.
1917                          */
1918                         interval = 0;
1919                 }
1920         }
1921
1922         /*
1923          * If the last argument is also an integer, then we have both a count
1924          * and an integer.
1925          */
1926         if (argc > 0 && isdigit(argv[argc - 1][0])) {
1927                 char *end;
1928
1929                 errno = 0;
1930                 count = interval;
1931                 interval = strtoul(argv[argc - 1], &end, 10);
1932
1933                 if (*end == '\0' && errno == 0) {
1934                         if (interval == 0) {
1935                                 (void) fprintf(stderr, gettext("interval "
1936                                     "cannot be zero\n"));
1937                                 usage(B_FALSE);
1938                         }
1939
1940                         /*
1941                          * Ignore the last parameter
1942                          */
1943                         argc--;
1944                 } else {
1945                         interval = 0;
1946                 }
1947         }
1948
1949         /*
1950          * Construct the list of all interesting pools.
1951          */
1952         ret = 0;
1953         if ((list = pool_list_get(argc, argv, NULL, &ret)) == NULL)
1954                 return (1);
1955
1956         if (pool_list_count(list) == 0 && argc != 0) {
1957                 pool_list_free(list);
1958                 return (1);
1959         }
1960
1961         if (pool_list_count(list) == 0 && interval == 0) {
1962                 pool_list_free(list);
1963                 (void) fprintf(stderr, gettext("no pools available\n"));
1964                 return (1);
1965         }
1966
1967         /*
1968          * Enter the main iostat loop.
1969          */
1970         cb.cb_list = list;
1971         cb.cb_verbose = verbose;
1972         cb.cb_iteration = 0;
1973         cb.cb_namewidth = 0;
1974
1975         for (;;) {
1976                 pool_list_update(list);
1977
1978                 if ((npools = pool_list_count(list)) == 0)
1979                         break;
1980
1981                 /*
1982                  * Refresh all statistics.  This is done as an explicit step
1983                  * before calculating the maximum name width, so that any
1984                  * configuration changes are properly accounted for.
1985                  */
1986                 (void) pool_list_iter(list, B_FALSE, refresh_iostat, &cb);
1987
1988                 /*
1989                  * Iterate over all pools to determine the maximum width
1990                  * for the pool / device name column across all pools.
1991                  */
1992                 cb.cb_namewidth = 0;
1993                 (void) pool_list_iter(list, B_FALSE, get_namewidth, &cb);
1994
1995                 /*
1996                  * If it's the first time, or verbose mode, print the header.
1997                  */
1998                 if (++cb.cb_iteration == 1 || verbose)
1999                         print_iostat_header(&cb);
2000
2001                 (void) pool_list_iter(list, B_FALSE, print_iostat, &cb);
2002
2003                 /*
2004                  * If there's more than one pool, and we're not in verbose mode
2005                  * (which prints a separator for us), then print a separator.
2006                  */
2007                 if (npools > 1 && !verbose)
2008                         print_iostat_separator(&cb);
2009
2010                 if (verbose)
2011                         (void) printf("\n");
2012
2013                 /*
2014                  * Flush the output so that redirection to a file isn't buffered
2015                  * indefinitely.
2016                  */
2017                 (void) fflush(stdout);
2018
2019                 if (interval == 0)
2020                         break;
2021
2022                 if (count != 0 && --count == 0)
2023                         break;
2024
2025                 (void) sleep(interval);
2026         }
2027
2028         pool_list_free(list);
2029
2030         return (ret);
2031 }
2032
2033 typedef struct list_cbdata {
2034         boolean_t       cb_scripted;
2035         boolean_t       cb_first;
2036         zprop_list_t    *cb_proplist;
2037 } list_cbdata_t;
2038
2039 /*
2040  * Given a list of columns to display, output appropriate headers for each one.
2041  */
2042 static void
2043 print_header(zprop_list_t *pl)
2044 {
2045         const char *header;
2046         boolean_t first = B_TRUE;
2047         boolean_t right_justify;
2048
2049         for (; pl != NULL; pl = pl->pl_next) {
2050                 if (pl->pl_prop == ZPROP_INVAL)
2051                         continue;
2052
2053                 if (!first)
2054                         (void) printf("  ");
2055                 else
2056                         first = B_FALSE;
2057
2058                 header = zpool_prop_column_name(pl->pl_prop);
2059                 right_justify = zpool_prop_align_right(pl->pl_prop);
2060
2061                 if (pl->pl_next == NULL && !right_justify)
2062                         (void) printf("%s", header);
2063                 else if (right_justify)
2064                         (void) printf("%*s", pl->pl_width, header);
2065                 else
2066                         (void) printf("%-*s", pl->pl_width, header);
2067         }
2068
2069         (void) printf("\n");
2070 }
2071
2072 /*
2073  * Given a pool and a list of properties, print out all the properties according
2074  * to the described layout.
2075  */
2076 static void
2077 print_pool(zpool_handle_t *zhp, zprop_list_t *pl, int scripted)
2078 {
2079         boolean_t first = B_TRUE;
2080         char property[ZPOOL_MAXPROPLEN];
2081         char *propstr;
2082         boolean_t right_justify;
2083         int width;
2084
2085         for (; pl != NULL; pl = pl->pl_next) {
2086                 if (!first) {
2087                         if (scripted)
2088                                 (void) printf("\t");
2089                         else
2090                                 (void) printf("  ");
2091                 } else {
2092                         first = B_FALSE;
2093                 }
2094
2095                 right_justify = B_FALSE;
2096                 if (pl->pl_prop != ZPROP_INVAL) {
2097                         if (zpool_get_prop(zhp, pl->pl_prop, property,
2098                             sizeof (property), NULL) != 0)
2099                                 propstr = "-";
2100                         else
2101                                 propstr = property;
2102
2103                         right_justify = zpool_prop_align_right(pl->pl_prop);
2104                 } else {
2105                         propstr = "-";
2106                 }
2107
2108                 width = pl->pl_width;
2109
2110                 /*
2111                  * If this is being called in scripted mode, or if this is the
2112                  * last column and it is left-justified, don't include a width
2113                  * format specifier.
2114                  */
2115                 if (scripted || (pl->pl_next == NULL && !right_justify))
2116                         (void) printf("%s", propstr);
2117                 else if (right_justify)
2118                         (void) printf("%*s", width, propstr);
2119                 else
2120                         (void) printf("%-*s", width, propstr);
2121         }
2122
2123         (void) printf("\n");
2124 }
2125
2126 /*
2127  * Generic callback function to list a pool.
2128  */
2129 int
2130 list_callback(zpool_handle_t *zhp, void *data)
2131 {
2132         list_cbdata_t *cbp = data;
2133
2134         if (cbp->cb_first) {
2135                 if (!cbp->cb_scripted)
2136                         print_header(cbp->cb_proplist);
2137                 cbp->cb_first = B_FALSE;
2138         }
2139
2140         print_pool(zhp, cbp->cb_proplist, cbp->cb_scripted);
2141
2142         return (0);
2143 }
2144
2145 /*
2146  * zpool list [-H] [-o prop[,prop]*] [pool] ...
2147  *
2148  *      -H      Scripted mode.  Don't display headers, and separate properties
2149  *              by a single tab.
2150  *      -o      List of properties to display.  Defaults to
2151  *              "name,size,used,available,capacity,health,altroot"
2152  *
2153  * List all pools in the system, whether or not they're healthy.  Output space
2154  * statistics for each one, as well as health status summary.
2155  */
2156 int
2157 zpool_do_list(int argc, char **argv)
2158 {
2159         int c;
2160         int ret;
2161         list_cbdata_t cb = { 0 };
2162         static char default_props[] =
2163             "name,size,used,available,capacity,health,altroot";
2164         char *props = default_props;
2165
2166         /* check options */
2167         while ((c = getopt(argc, argv, ":Ho:")) != -1) {
2168                 switch (c) {
2169                 case 'H':
2170                         cb.cb_scripted = B_TRUE;
2171                         break;
2172                 case 'o':
2173                         props = optarg;
2174                         break;
2175                 case ':':
2176                         (void) fprintf(stderr, gettext("missing argument for "
2177                             "'%c' option\n"), optopt);
2178                         usage(B_FALSE);
2179                         break;
2180                 case '?':
2181                         (void) fprintf(stderr, gettext("invalid option '%c'\n"),
2182                             optopt);
2183                         usage(B_FALSE);
2184                 }
2185         }
2186
2187         argc -= optind;
2188         argv += optind;
2189
2190         if (zprop_get_list(g_zfs, props, &cb.cb_proplist, ZFS_TYPE_POOL) != 0)
2191                 usage(B_FALSE);
2192
2193         cb.cb_first = B_TRUE;
2194
2195         ret = for_each_pool(argc, argv, B_TRUE, &cb.cb_proplist,
2196             list_callback, &cb);
2197
2198         zprop_free_list(cb.cb_proplist);
2199
2200         if (argc == 0 && cb.cb_first && !cb.cb_scripted) {
2201                 (void) printf(gettext("no pools available\n"));
2202                 return (0);
2203         }
2204
2205         return (ret);
2206 }
2207
2208 static nvlist_t *
2209 zpool_get_vdev_by_name(nvlist_t *nv, char *name)
2210 {
2211         nvlist_t **child;
2212         uint_t c, children;
2213         nvlist_t *match;
2214         char *path;
2215
2216         if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
2217             &child, &children) != 0) {
2218                 verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) == 0);
2219                 if (strncmp(name, "/dev/dsk/", 9) == 0)
2220                         name += 9;
2221                 if (strncmp(path, "/dev/dsk/", 9) == 0)
2222                         path += 9;
2223                 if (strcmp(name, path) == 0)
2224                         return (nv);
2225                 return (NULL);
2226         }
2227
2228         for (c = 0; c < children; c++)
2229                 if ((match = zpool_get_vdev_by_name(child[c], name)) != NULL)
2230                         return (match);
2231
2232         return (NULL);
2233 }
2234
2235 static int
2236 zpool_do_attach_or_replace(int argc, char **argv, int replacing)
2237 {
2238         boolean_t force = B_FALSE;
2239         int c;
2240         nvlist_t *nvroot;
2241         char *poolname, *old_disk, *new_disk;
2242         zpool_handle_t *zhp;
2243         int ret;
2244
2245         /* check options */
2246         while ((c = getopt(argc, argv, "f")) != -1) {
2247                 switch (c) {
2248                 case 'f':
2249                         force = B_TRUE;
2250                         break;
2251                 case '?':
2252                         (void) fprintf(stderr, gettext("invalid option '%c'\n"),
2253                             optopt);
2254                         usage(B_FALSE);
2255                 }
2256         }
2257
2258         argc -= optind;
2259         argv += optind;
2260
2261         /* get pool name and check number of arguments */
2262         if (argc < 1) {
2263                 (void) fprintf(stderr, gettext("missing pool name argument\n"));
2264                 usage(B_FALSE);
2265         }
2266
2267         poolname = argv[0];
2268
2269         if (argc < 2) {
2270                 (void) fprintf(stderr,
2271                     gettext("missing <device> specification\n"));
2272                 usage(B_FALSE);
2273         }
2274
2275         old_disk = argv[1];
2276
2277         if (argc < 3) {
2278                 if (!replacing) {
2279                         (void) fprintf(stderr,
2280                             gettext("missing <new_device> specification\n"));
2281                         usage(B_FALSE);
2282                 }
2283                 new_disk = old_disk;
2284                 argc -= 1;
2285                 argv += 1;
2286         } else {
2287                 new_disk = argv[2];
2288                 argc -= 2;
2289                 argv += 2;
2290         }
2291
2292         if (argc > 1) {
2293                 (void) fprintf(stderr, gettext("too many arguments\n"));
2294                 usage(B_FALSE);
2295         }
2296
2297         if ((zhp = zpool_open(g_zfs, poolname)) == NULL)
2298                 return (1);
2299
2300         if (zpool_get_config(zhp, NULL) == NULL) {
2301                 (void) fprintf(stderr, gettext("pool '%s' is unavailable\n"),
2302                     poolname);
2303                 zpool_close(zhp);
2304                 return (1);
2305         }
2306
2307         nvroot = make_root_vdev(zhp, force, B_FALSE, replacing, B_FALSE,
2308             argc, argv);
2309         if (nvroot == NULL) {
2310                 zpool_close(zhp);
2311                 return (1);
2312         }
2313
2314         ret = zpool_vdev_attach(zhp, old_disk, new_disk, nvroot, replacing);
2315
2316         nvlist_free(nvroot);
2317         zpool_close(zhp);
2318
2319         return (ret);
2320 }
2321
2322 /*
2323  * zpool replace [-f] <pool> <device> <new_device>
2324  *
2325  *      -f      Force attach, even if <new_device> appears to be in use.
2326  *
2327  * Replace <device> with <new_device>.
2328  */
2329 /* ARGSUSED */
2330 int
2331 zpool_do_replace(int argc, char **argv)
2332 {
2333         return (zpool_do_attach_or_replace(argc, argv, B_TRUE));
2334 }
2335
2336 /*
2337  * zpool attach [-f] <pool> <device> <new_device>
2338  *
2339  *      -f      Force attach, even if <new_device> appears to be in use.
2340  *
2341  * Attach <new_device> to the mirror containing <device>.  If <device> is not
2342  * part of a mirror, then <device> will be transformed into a mirror of
2343  * <device> and <new_device>.  In either case, <new_device> will begin life
2344  * with a DTL of [0, now], and will immediately begin to resilver itself.
2345  */
2346 int
2347 zpool_do_attach(int argc, char **argv)
2348 {
2349         return (zpool_do_attach_or_replace(argc, argv, B_FALSE));
2350 }
2351
2352 /*
2353  * zpool detach [-f] <pool> <device>
2354  *
2355  *      -f      Force detach of <device>, even if DTLs argue against it
2356  *              (not supported yet)
2357  *
2358  * Detach a device from a mirror.  The operation will be refused if <device>
2359  * is the last device in the mirror, or if the DTLs indicate that this device
2360  * has the only valid copy of some data.
2361  */
2362 /* ARGSUSED */
2363 int
2364 zpool_do_detach(int argc, char **argv)
2365 {
2366         int c;
2367         char *poolname, *path;
2368         zpool_handle_t *zhp;
2369         int ret;
2370
2371         /* check options */
2372         while ((c = getopt(argc, argv, "f")) != -1) {
2373                 switch (c) {
2374                 case 'f':
2375                 case '?':
2376                         (void) fprintf(stderr, gettext("invalid option '%c'\n"),
2377                             optopt);
2378                         usage(B_FALSE);
2379                 }
2380         }
2381
2382         argc -= optind;
2383         argv += optind;
2384
2385         /* get pool name and check number of arguments */
2386         if (argc < 1) {
2387                 (void) fprintf(stderr, gettext("missing pool name argument\n"));
2388                 usage(B_FALSE);
2389         }
2390
2391         if (argc < 2) {
2392                 (void) fprintf(stderr,
2393                     gettext("missing <device> specification\n"));
2394                 usage(B_FALSE);
2395         }
2396
2397         poolname = argv[0];
2398         path = argv[1];
2399
2400         if ((zhp = zpool_open(g_zfs, poolname)) == NULL)
2401                 return (1);
2402
2403         ret = zpool_vdev_detach(zhp, path);
2404
2405         zpool_close(zhp);
2406
2407         return (ret);
2408 }
2409
2410 /*
2411  * zpool online <pool> <device> ...
2412  */
2413 int
2414 zpool_do_online(int argc, char **argv)
2415 {
2416         int c, i;
2417         char *poolname;
2418         zpool_handle_t *zhp;
2419         int ret = 0;
2420         vdev_state_t newstate;
2421
2422         /* check options */
2423         while ((c = getopt(argc, argv, "t")) != -1) {
2424                 switch (c) {
2425                 case 't':
2426                 case '?':
2427                         (void) fprintf(stderr, gettext("invalid option '%c'\n"),
2428                             optopt);
2429                         usage(B_FALSE);
2430                 }
2431         }
2432
2433         argc -= optind;
2434         argv += optind;
2435
2436         /* get pool name and check number of arguments */
2437         if (argc < 1) {
2438                 (void) fprintf(stderr, gettext("missing pool name\n"));
2439                 usage(B_FALSE);
2440         }
2441         if (argc < 2) {
2442                 (void) fprintf(stderr, gettext("missing device name\n"));
2443                 usage(B_FALSE);
2444         }
2445
2446         poolname = argv[0];
2447
2448         if ((zhp = zpool_open(g_zfs, poolname)) == NULL)
2449                 return (1);
2450
2451         for (i = 1; i < argc; i++) {
2452                 if (zpool_vdev_online(zhp, argv[i], 0, &newstate) == 0) {
2453                         if (newstate != VDEV_STATE_HEALTHY) {
2454                                 (void) printf(gettext("warning: device '%s' "
2455                                     "onlined, but remains in faulted state\n"),
2456                                     argv[i]);
2457                                 if (newstate == VDEV_STATE_FAULTED)
2458                                         (void) printf(gettext("use 'zpool "
2459                                             "clear' to restore a faulted "
2460                                             "device\n"));
2461                                 else
2462                                         (void) printf(gettext("use 'zpool "
2463                                             "replace' to replace devices "
2464                                             "that are no longer present\n"));
2465                         }
2466                 } else {
2467                         ret = 1;
2468                 }
2469         }
2470
2471         zpool_close(zhp);
2472
2473         return (ret);
2474 }
2475
2476 /*
2477  * zpool offline [-ft] <pool> <device> ...
2478  *
2479  *      -f      Force the device into the offline state, even if doing
2480  *              so would appear to compromise pool availability.
2481  *              (not supported yet)
2482  *
2483  *      -t      Only take the device off-line temporarily.  The offline
2484  *              state will not be persistent across reboots.
2485  */
2486 /* ARGSUSED */
2487 int
2488 zpool_do_offline(int argc, char **argv)
2489 {
2490         int c, i;
2491         char *poolname;
2492         zpool_handle_t *zhp;
2493         int ret = 0;
2494         boolean_t istmp = B_FALSE;
2495
2496         /* check options */
2497         while ((c = getopt(argc, argv, "ft")) != -1) {
2498                 switch (c) {
2499                 case 't':
2500                         istmp = B_TRUE;
2501                         break;
2502                 case 'f':
2503                 case '?':
2504                         (void) fprintf(stderr, gettext("invalid option '%c'\n"),
2505                             optopt);
2506                         usage(B_FALSE);
2507                 }
2508         }
2509
2510         argc -= optind;
2511         argv += optind;
2512
2513         /* get pool name and check number of arguments */
2514         if (argc < 1) {
2515                 (void) fprintf(stderr, gettext("missing pool name\n"));
2516                 usage(B_FALSE);
2517         }
2518         if (argc < 2) {
2519                 (void) fprintf(stderr, gettext("missing device name\n"));
2520                 usage(B_FALSE);
2521         }
2522
2523         poolname = argv[0];
2524
2525         if ((zhp = zpool_open(g_zfs, poolname)) == NULL)
2526                 return (1);
2527
2528         for (i = 1; i < argc; i++) {
2529                 if (zpool_vdev_offline(zhp, argv[i], istmp) != 0)
2530                         ret = 1;
2531         }
2532
2533         zpool_close(zhp);
2534
2535         return (ret);
2536 }
2537
2538 /*
2539  * zpool clear <pool> [device]
2540  *
2541  * Clear all errors associated with a pool or a particular device.
2542  */
2543 int
2544 zpool_do_clear(int argc, char **argv)
2545 {
2546         int ret = 0;
2547         zpool_handle_t *zhp;
2548         char *pool, *device;
2549
2550         if (argc < 2) {
2551                 (void) fprintf(stderr, gettext("missing pool name\n"));
2552                 usage(B_FALSE);
2553         }
2554
2555         if (argc > 3) {
2556                 (void) fprintf(stderr, gettext("too many arguments\n"));
2557                 usage(B_FALSE);
2558         }
2559
2560         pool = argv[1];
2561         device = argc == 3 ? argv[2] : NULL;
2562
2563         if ((zhp = zpool_open_canfail(g_zfs, pool)) == NULL)
2564                 return (1);
2565
2566         if (zpool_clear(zhp, device) != 0)
2567                 ret = 1;
2568
2569         zpool_close(zhp);
2570
2571         return (ret);
2572 }
2573
2574 typedef struct scrub_cbdata {
2575         int     cb_type;
2576         int     cb_argc;
2577         char    **cb_argv;
2578 } scrub_cbdata_t;
2579
2580 int
2581 scrub_callback(zpool_handle_t *zhp, void *data)
2582 {
2583         scrub_cbdata_t *cb = data;
2584         int err;
2585
2586         /*
2587          * Ignore faulted pools.
2588          */
2589         if (zpool_get_state(zhp) == POOL_STATE_UNAVAIL) {
2590                 (void) fprintf(stderr, gettext("cannot scrub '%s': pool is "
2591                     "currently unavailable\n"), zpool_get_name(zhp));
2592                 return (1);
2593         }
2594
2595         err = zpool_scrub(zhp, cb->cb_type);
2596
2597         return (err != 0);
2598 }
2599
2600 /*
2601  * zpool scrub [-s] <pool> ...
2602  *
2603  *      -s      Stop.  Stops any in-progress scrub.
2604  */
2605 int
2606 zpool_do_scrub(int argc, char **argv)
2607 {
2608         int c;
2609         scrub_cbdata_t cb;
2610
2611         cb.cb_type = POOL_SCRUB_EVERYTHING;
2612
2613         /* check options */
2614         while ((c = getopt(argc, argv, "s")) != -1) {
2615                 switch (c) {
2616                 case 's':
2617                         cb.cb_type = POOL_SCRUB_NONE;
2618                         break;
2619                 case '?':
2620                         (void) fprintf(stderr, gettext("invalid option '%c'\n"),
2621                             optopt);
2622                         usage(B_FALSE);
2623                 }
2624         }
2625
2626         cb.cb_argc = argc;
2627         cb.cb_argv = argv;
2628         argc -= optind;
2629         argv += optind;
2630
2631         if (argc < 1) {
2632                 (void) fprintf(stderr, gettext("missing pool name argument\n"));
2633                 usage(B_FALSE);
2634         }
2635
2636         return (for_each_pool(argc, argv, B_TRUE, NULL, scrub_callback, &cb));
2637 }
2638
2639 typedef struct status_cbdata {
2640         int             cb_count;
2641         boolean_t       cb_allpools;
2642         boolean_t       cb_verbose;
2643         boolean_t       cb_explain;
2644         boolean_t       cb_first;
2645 } status_cbdata_t;
2646
2647 /*
2648  * Print out detailed scrub status.
2649  */
2650 void
2651 print_scrub_status(nvlist_t *nvroot)
2652 {
2653         vdev_stat_t *vs;
2654         uint_t vsc;
2655         time_t start, end, now;
2656         double fraction_done;
2657         uint64_t examined, total, minutes_left, minutes_taken;
2658         char *scrub_type;
2659
2660         verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_STATS,
2661             (uint64_t **)&vs, &vsc) == 0);
2662
2663         /*
2664          * If there's never been a scrub, there's not much to say.
2665          */
2666         if (vs->vs_scrub_end == 0 && vs->vs_scrub_type == POOL_SCRUB_NONE) {
2667                 (void) printf(gettext("none requested\n"));
2668                 return;
2669         }
2670
2671         scrub_type = (vs->vs_scrub_type == POOL_SCRUB_RESILVER) ?
2672             "resilver" : "scrub";
2673
2674         start = vs->vs_scrub_start;
2675         end = vs->vs_scrub_end;
2676         now = time(NULL);
2677         examined = vs->vs_scrub_examined;
2678         total = vs->vs_alloc;
2679
2680         if (end != 0) {
2681                 minutes_taken = (uint64_t)((end - start) / 60);
2682
2683                 (void) printf(gettext("%s %s after %lluh%um with %llu errors "
2684                     "on %s"),
2685                     scrub_type, vs->vs_scrub_complete ? "completed" : "stopped",
2686                     (u_longlong_t)(minutes_taken / 60),
2687                     (uint_t)(minutes_taken % 60),
2688                     (u_longlong_t)vs->vs_scrub_errors, ctime(&end));
2689                 return;
2690         }
2691
2692         if (examined == 0)
2693                 examined = 1;
2694         if (examined > total)
2695                 total = examined;
2696
2697         fraction_done = (double)examined / total;
2698         minutes_left = (uint64_t)((now - start) *
2699             (1 - fraction_done) / fraction_done / 60);
2700         minutes_taken = (uint64_t)((now - start) / 60);
2701
2702         (void) printf(gettext("%s in progress for %lluh%um, %.2f%% done, "
2703             "%lluh%um to go\n"),
2704             scrub_type, (u_longlong_t)(minutes_taken / 60),
2705             (uint_t)(minutes_taken % 60), 100 * fraction_done,
2706             (u_longlong_t)(minutes_left / 60), (uint_t)(minutes_left % 60));
2707 }
2708
2709 typedef struct spare_cbdata {
2710         uint64_t        cb_guid;
2711         zpool_handle_t  *cb_zhp;
2712 } spare_cbdata_t;
2713
2714 static boolean_t
2715 find_vdev(nvlist_t *nv, uint64_t search)
2716 {
2717         uint64_t guid;
2718         nvlist_t **child;
2719         uint_t c, children;
2720
2721         if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &guid) == 0 &&
2722             search == guid)
2723                 return (B_TRUE);
2724
2725         if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
2726             &child, &children) == 0) {
2727                 for (c = 0; c < children; c++)
2728                         if (find_vdev(child[c], search))
2729                                 return (B_TRUE);
2730         }
2731
2732         return (B_FALSE);
2733 }
2734
2735 static int
2736 find_spare(zpool_handle_t *zhp, void *data)
2737 {
2738         spare_cbdata_t *cbp = data;
2739         nvlist_t *config, *nvroot;
2740
2741         config = zpool_get_config(zhp, NULL);
2742         verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
2743             &nvroot) == 0);
2744
2745         if (find_vdev(nvroot, cbp->cb_guid)) {
2746                 cbp->cb_zhp = zhp;
2747                 return (1);
2748         }
2749
2750         zpool_close(zhp);
2751         return (0);
2752 }
2753
2754 /*
2755  * Print out configuration state as requested by status_callback.
2756  */
2757 void
2758 print_status_config(zpool_handle_t *zhp, const char *name, nvlist_t *nv,
2759     int namewidth, int depth, boolean_t isspare, boolean_t print_logs)
2760 {
2761         nvlist_t **child;
2762         uint_t c, children;
2763         vdev_stat_t *vs;
2764         char rbuf[6], wbuf[6], cbuf[6], repaired[7];
2765         char *vname;
2766         uint64_t notpresent;
2767         spare_cbdata_t cb;
2768         char *state;
2769
2770         verify(nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_STATS,
2771             (uint64_t **)&vs, &c) == 0);
2772
2773         if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
2774             &child, &children) != 0)
2775                 children = 0;
2776
2777         state = zpool_state_to_name(vs->vs_state, vs->vs_aux);
2778         if (isspare) {
2779                 /*
2780                  * For hot spares, we use the terms 'INUSE' and 'AVAILABLE' for
2781                  * online drives.
2782                  */
2783                 if (vs->vs_aux == VDEV_AUX_SPARED)
2784                         state = "INUSE";
2785                 else if (vs->vs_state == VDEV_STATE_HEALTHY)
2786                         state = "AVAIL";
2787         }
2788
2789         (void) printf("\t%*s%-*s  %-8s", depth, "", namewidth - depth,
2790             name, state);
2791
2792         if (!isspare) {
2793                 zfs_nicenum(vs->vs_read_errors, rbuf, sizeof (rbuf));
2794                 zfs_nicenum(vs->vs_write_errors, wbuf, sizeof (wbuf));
2795                 zfs_nicenum(vs->vs_checksum_errors, cbuf, sizeof (cbuf));
2796                 (void) printf(" %5s %5s %5s", rbuf, wbuf, cbuf);
2797         }
2798
2799         if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NOT_PRESENT,
2800             &notpresent) == 0) {
2801                 char *path;
2802                 verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) == 0);
2803                 (void) printf("  was %s", path);
2804         } else if (vs->vs_aux != 0) {
2805                 (void) printf("  ");
2806
2807                 switch (vs->vs_aux) {
2808                 case VDEV_AUX_OPEN_FAILED:
2809                         (void) printf(gettext("cannot open"));
2810                         break;
2811
2812                 case VDEV_AUX_BAD_GUID_SUM:
2813                         (void) printf(gettext("missing device"));
2814                         break;
2815
2816                 case VDEV_AUX_NO_REPLICAS:
2817                         (void) printf(gettext("insufficient replicas"));
2818                         break;
2819
2820                 case VDEV_AUX_VERSION_NEWER:
2821                         (void) printf(gettext("newer version"));
2822                         break;
2823
2824                 case VDEV_AUX_SPARED:
2825                         verify(nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID,
2826                             &cb.cb_guid) == 0);
2827                         if (zpool_iter(g_zfs, find_spare, &cb) == 1) {
2828                                 if (strcmp(zpool_get_name(cb.cb_zhp),
2829                                     zpool_get_name(zhp)) == 0)
2830                                         (void) printf(gettext("currently in "
2831                                             "use"));
2832                                 else
2833                                         (void) printf(gettext("in use by "
2834                                             "pool '%s'"),
2835                                             zpool_get_name(cb.cb_zhp));
2836                                 zpool_close(cb.cb_zhp);
2837                         } else {
2838                                 (void) printf(gettext("currently in use"));
2839                         }
2840                         break;
2841
2842                 case VDEV_AUX_ERR_EXCEEDED:
2843                         (void) printf(gettext("too many errors"));
2844                         break;
2845
2846                 case VDEV_AUX_IO_FAILURE:
2847                         (void) printf(gettext("experienced I/O failures"));
2848                         break;
2849
2850                 case VDEV_AUX_BAD_LOG:
2851                         (void) printf(gettext("bad intent log"));
2852                         break;
2853
2854                 default:
2855                         (void) printf(gettext("corrupted data"));
2856                         break;
2857                 }
2858         } else if (vs->vs_scrub_repaired != 0 && children == 0) {
2859                 /*
2860                  * Report bytes resilvered/repaired on leaf devices.
2861                  */
2862                 zfs_nicenum(vs->vs_scrub_repaired, repaired, sizeof (repaired));
2863                 (void) printf(gettext("  %s %s"), repaired,
2864                     (vs->vs_scrub_type == POOL_SCRUB_RESILVER) ?
2865                     "resilvered" : "repaired");
2866         }
2867
2868         (void) printf("\n");
2869
2870         for (c = 0; c < children; c++) {
2871                 uint64_t is_log = B_FALSE;
2872
2873                 (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG,
2874                     &is_log);
2875                 if ((is_log && !print_logs) || (!is_log && print_logs))
2876                         continue;
2877                 vname = zpool_vdev_name(g_zfs, zhp, child[c]);
2878                 print_status_config(zhp, vname, child[c],
2879                     namewidth, depth + 2, isspare, B_FALSE);
2880                 free(vname);
2881         }
2882 }
2883
2884 static void
2885 print_error_log(zpool_handle_t *zhp)
2886 {
2887         nvlist_t *nverrlist = NULL;
2888         nvpair_t *elem;
2889         char *pathname;
2890         size_t len = MAXPATHLEN * 2;
2891
2892         if (zpool_get_errlog(zhp, &nverrlist) != 0) {
2893                 (void) printf("errors: List of errors unavailable "
2894                     "(insufficient privileges)\n");
2895                 return;
2896         }
2897
2898         (void) printf("errors: Permanent errors have been "
2899             "detected in the following files:\n\n");
2900
2901         pathname = safe_malloc(len);
2902         elem = NULL;
2903         while ((elem = nvlist_next_nvpair(nverrlist, elem)) != NULL) {
2904                 nvlist_t *nv;
2905                 uint64_t dsobj, obj;
2906
2907                 verify(nvpair_value_nvlist(elem, &nv) == 0);
2908                 verify(nvlist_lookup_uint64(nv, ZPOOL_ERR_DATASET,
2909                     &dsobj) == 0);
2910                 verify(nvlist_lookup_uint64(nv, ZPOOL_ERR_OBJECT,
2911                     &obj) == 0);
2912                 zpool_obj_to_path(zhp, dsobj, obj, pathname, len);
2913                 (void) printf("%7s %s\n", "", pathname);
2914         }
2915         free(pathname);
2916         nvlist_free(nverrlist);
2917 }
2918
2919 static void
2920 print_spares(zpool_handle_t *zhp, nvlist_t **spares, uint_t nspares,
2921     int namewidth)
2922 {
2923         uint_t i;
2924         char *name;
2925
2926         if (nspares == 0)
2927                 return;
2928
2929         (void) printf(gettext("\tspares\n"));
2930
2931         for (i = 0; i < nspares; i++) {
2932                 name = zpool_vdev_name(g_zfs, zhp, spares[i]);
2933                 print_status_config(zhp, name, spares[i],
2934                     namewidth, 2, B_TRUE, B_FALSE);
2935                 free(name);
2936         }
2937 }
2938
2939 static void
2940 print_l2cache(zpool_handle_t *zhp, nvlist_t **l2cache, uint_t nl2cache,
2941     int namewidth)
2942 {
2943         uint_t i;
2944         char *name;
2945
2946         if (nl2cache == 0)
2947                 return;
2948
2949         (void) printf(gettext("\tcache\n"));
2950
2951         for (i = 0; i < nl2cache; i++) {
2952                 name = zpool_vdev_name(g_zfs, zhp, l2cache[i]);
2953                 print_status_config(zhp, name, l2cache[i],
2954                     namewidth, 2, B_FALSE, B_FALSE);
2955                 free(name);
2956         }
2957 }
2958
2959 /*
2960  * Display a summary of pool status.  Displays a summary such as:
2961  *
2962  *        pool: tank
2963  *      status: DEGRADED
2964  *      reason: One or more devices ...
2965  *         see: http://www.sun.com/msg/ZFS-xxxx-01
2966  *      config:
2967  *              mirror          DEGRADED
2968  *                c1t0d0        OK
2969  *                c2t0d0        UNAVAIL
2970  *
2971  * When given the '-v' option, we print out the complete config.  If the '-e'
2972  * option is specified, then we print out error rate information as well.
2973  */
2974 int
2975 status_callback(zpool_handle_t *zhp, void *data)
2976 {
2977         status_cbdata_t *cbp = data;
2978         nvlist_t *config, *nvroot;
2979         char *msgid;
2980         int reason;
2981         const char *health;
2982         uint_t c;
2983         vdev_stat_t *vs;
2984
2985         config = zpool_get_config(zhp, NULL);
2986         reason = zpool_get_status(zhp, &msgid);
2987
2988         cbp->cb_count++;
2989
2990         /*
2991          * If we were given 'zpool status -x', only report those pools with
2992          * problems.
2993          */
2994         if (reason == ZPOOL_STATUS_OK && cbp->cb_explain) {
2995                 if (!cbp->cb_allpools) {
2996                         (void) printf(gettext("pool '%s' is healthy\n"),
2997                             zpool_get_name(zhp));
2998                         if (cbp->cb_first)
2999                                 cbp->cb_first = B_FALSE;
3000                 }
3001                 return (0);
3002         }
3003
3004         if (cbp->cb_first)
3005                 cbp->cb_first = B_FALSE;
3006         else
3007                 (void) printf("\n");
3008
3009         verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
3010             &nvroot) == 0);
3011         verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_STATS,
3012             (uint64_t **)&vs, &c) == 0);
3013         health = zpool_state_to_name(vs->vs_state, vs->vs_aux);
3014
3015         (void) printf(gettext("  pool: %s\n"), zpool_get_name(zhp));
3016         (void) printf(gettext(" state: %s\n"), health);
3017
3018         switch (reason) {
3019         case ZPOOL_STATUS_MISSING_DEV_R:
3020                 (void) printf(gettext("status: One or more devices could not "
3021                     "be opened.  Sufficient replicas exist for\n\tthe pool to "
3022                     "continue functioning in a degraded state.\n"));
3023                 (void) printf(gettext("action: Attach the missing device and "
3024                     "online it using 'zpool online'.\n"));
3025                 break;
3026
3027         case ZPOOL_STATUS_MISSING_DEV_NR:
3028                 (void) printf(gettext("status: One or more devices could not "
3029                     "be opened.  There are insufficient\n\treplicas for the "
3030                     "pool to continue functioning.\n"));
3031                 (void) printf(gettext("action: Attach the missing device and "
3032                     "online it using 'zpool online'.\n"));
3033                 break;
3034
3035         case ZPOOL_STATUS_CORRUPT_LABEL_R:
3036                 (void) printf(gettext("status: One or more devices could not "
3037                     "be used because the label is missing or\n\tinvalid.  "
3038                     "Sufficient replicas exist for the pool to continue\n\t"
3039                     "functioning in a degraded state.\n"));
3040                 (void) printf(gettext("action: Replace the device using "
3041                     "'zpool replace'.\n"));
3042                 break;
3043
3044         case ZPOOL_STATUS_CORRUPT_LABEL_NR:
3045                 (void) printf(gettext("status: One or more devices could not "
3046                     "be used because the label is missing \n\tor invalid.  "
3047                     "There are insufficient replicas for the pool to "
3048                     "continue\n\tfunctioning.\n"));
3049                 (void) printf(gettext("action: Destroy and re-create the pool "
3050                     "from a backup source.\n"));
3051                 break;
3052
3053         case ZPOOL_STATUS_FAILING_DEV:
3054                 (void) printf(gettext("status: One or more devices has "
3055                     "experienced an unrecoverable error.  An\n\tattempt was "
3056                     "made to correct the error.  Applications are "
3057                     "unaffected.\n"));
3058                 (void) printf(gettext("action: Determine if the device needs "
3059                     "to be replaced, and clear the errors\n\tusing "
3060                     "'zpool clear' or replace the device with 'zpool "
3061                     "replace'.\n"));
3062                 break;
3063
3064         case ZPOOL_STATUS_OFFLINE_DEV:
3065                 (void) printf(gettext("status: One or more devices has "
3066                     "been taken offline by the administrator.\n\tSufficient "
3067                     "replicas exist for the pool to continue functioning in "
3068                     "a\n\tdegraded state.\n"));
3069                 (void) printf(gettext("action: Online the device using "
3070                     "'zpool online' or replace the device with\n\t'zpool "
3071                     "replace'.\n"));
3072                 break;
3073
3074         case ZPOOL_STATUS_RESILVERING:
3075                 (void) printf(gettext("status: One or more devices is "
3076                     "currently being resilvered.  The pool will\n\tcontinue "
3077                     "to function, possibly in a degraded state.\n"));
3078                 (void) printf(gettext("action: Wait for the resilver to "
3079                     "complete.\n"));
3080                 break;
3081
3082         case ZPOOL_STATUS_CORRUPT_DATA:
3083                 (void) printf(gettext("status: One or more devices has "
3084                     "experienced an error resulting in data\n\tcorruption.  "
3085                     "Applications may be affected.\n"));
3086                 (void) printf(gettext("action: Restore the file in question "
3087                     "if possible.  Otherwise restore the\n\tentire pool from "
3088                     "backup.\n"));
3089                 break;
3090
3091         case ZPOOL_STATUS_CORRUPT_POOL:
3092                 (void) printf(gettext("status: The pool metadata is corrupted "
3093                     "and the pool cannot be opened.\n"));
3094                 (void) printf(gettext("action: Destroy and re-create the pool "
3095                     "from a backup source.\n"));
3096                 break;
3097
3098         case ZPOOL_STATUS_VERSION_OLDER:
3099                 (void) printf(gettext("status: The pool is formatted using an "
3100                     "older on-disk format.  The pool can\n\tstill be used, but "
3101                     "some features are unavailable.\n"));
3102                 (void) printf(gettext("action: Upgrade the pool using 'zpool "
3103                     "upgrade'.  Once this is done, the\n\tpool will no longer "
3104                     "be accessible on older software versions.\n"));
3105                 break;
3106
3107         case ZPOOL_STATUS_VERSION_NEWER:
3108                 (void) printf(gettext("status: The pool has been upgraded to a "
3109                     "newer, incompatible on-disk version.\n\tThe pool cannot "
3110                     "be accessed on this system.\n"));
3111                 (void) printf(gettext("action: Access the pool from a system "
3112                     "running more recent software, or\n\trestore the pool from "
3113                     "backup.\n"));
3114                 break;
3115
3116         case ZPOOL_STATUS_FAULTED_DEV_R:
3117                 (void) printf(gettext("status: One or more devices are "
3118                     "faulted in response to persistent errors.\n\tSufficient "
3119                     "replicas exist for the pool to continue functioning "
3120                     "in a\n\tdegraded state.\n"));
3121                 (void) printf(gettext("action: Replace the faulted device, "
3122                     "or use 'zpool clear' to mark the device\n\trepaired.\n"));
3123                 break;
3124
3125         case ZPOOL_STATUS_FAULTED_DEV_NR:
3126                 (void) printf(gettext("status: One or more devices are "
3127                     "faulted in response to persistent errors.  There are "
3128                     "insufficient replicas for the pool to\n\tcontinue "
3129                     "functioning.\n"));
3130                 (void) printf(gettext("action: Destroy and re-create the pool "
3131                     "from a backup source.  Manually marking the device\n"
3132                     "\trepaired using 'zpool clear' may allow some data "
3133                     "to be recovered.\n"));
3134                 break;
3135
3136         case ZPOOL_STATUS_IO_FAILURE_WAIT:
3137         case ZPOOL_STATUS_IO_FAILURE_CONTINUE:
3138                 (void) printf(gettext("status: One or more devices are "
3139                     "faulted in response to IO failures.\n"));
3140                 (void) printf(gettext("action: Make sure the affected devices "
3141                     "are connected, then run 'zpool clear'.\n"));
3142                 break;
3143
3144         case ZPOOL_STATUS_BAD_LOG:
3145                 (void) printf(gettext("status: An intent log record "
3146                     "could not be read.\n"
3147                     "\tWaiting for adminstrator intervention to fix the "
3148                     "faulted pool.\n"));
3149                 (void) printf(gettext("action: Either restore the affected "
3150                     "device(s) and run 'zpool online',\n"
3151                     "\tor ignore the intent log records by running "
3152                     "'zpool clear'.\n"));
3153                 break;
3154
3155         default:
3156                 /*
3157                  * The remaining errors can't actually be generated, yet.
3158                  */
3159                 assert(reason == ZPOOL_STATUS_OK);
3160         }
3161
3162         if (msgid != NULL)
3163                 (void) printf(gettext("   see: http://www.sun.com/msg/%s\n"),
3164                     msgid);
3165
3166         if (config != NULL) {
3167                 int namewidth;
3168                 uint64_t nerr;
3169                 nvlist_t **spares, **l2cache;
3170                 uint_t nspares, nl2cache;
3171
3172
3173                 (void) printf(gettext(" scrub: "));
3174                 print_scrub_status(nvroot);
3175
3176                 namewidth = max_width(zhp, nvroot, 0, 0);
3177                 if (namewidth < 10)
3178                         namewidth = 10;
3179
3180                 (void) printf(gettext("config:\n\n"));
3181                 (void) printf(gettext("\t%-*s  %-8s %5s %5s %5s\n"), namewidth,
3182                     "NAME", "STATE", "READ", "WRITE", "CKSUM");
3183                 print_status_config(zhp, zpool_get_name(zhp), nvroot,
3184                     namewidth, 0, B_FALSE, B_FALSE);
3185                 if (num_logs(nvroot) > 0)
3186                         print_status_config(zhp, "logs", nvroot, namewidth, 0,
3187                             B_FALSE, B_TRUE);
3188
3189                 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE,
3190                     &l2cache, &nl2cache) == 0)
3191                         print_l2cache(zhp, l2cache, nl2cache, namewidth);
3192
3193                 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES,
3194                     &spares, &nspares) == 0)
3195                         print_spares(zhp, spares, nspares, namewidth);
3196
3197                 if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_ERRCOUNT,
3198                     &nerr) == 0) {
3199                         nvlist_t *nverrlist = NULL;
3200
3201                         /*
3202                          * If the approximate error count is small, get a
3203                          * precise count by fetching the entire log and
3204                          * uniquifying the results.
3205                          */
3206                         if (nerr > 0 && nerr < 100 && !cbp->cb_verbose &&
3207                             zpool_get_errlog(zhp, &nverrlist) == 0) {
3208                                 nvpair_t *elem;
3209
3210                                 elem = NULL;
3211                                 nerr = 0;
3212                                 while ((elem = nvlist_next_nvpair(nverrlist,
3213                                     elem)) != NULL) {
3214                                         nerr++;
3215                                 }
3216                         }
3217                         nvlist_free(nverrlist);
3218
3219                         (void) printf("\n");
3220
3221                         if (nerr == 0)
3222                                 (void) printf(gettext("errors: No known data "
3223                                     "errors\n"));
3224                         else if (!cbp->cb_verbose)
3225                                 (void) printf(gettext("errors: %llu data "
3226                                     "errors, use '-v' for a list\n"),
3227                                     (u_longlong_t)nerr);
3228                         else
3229                                 print_error_log(zhp);
3230                 }
3231         } else {
3232                 (void) printf(gettext("config: The configuration cannot be "
3233                     "determined.\n"));
3234         }
3235
3236         return (0);
3237 }
3238
3239 /*
3240  * zpool status [-vx] [pool] ...
3241  *
3242  *      -v      Display complete error logs
3243  *      -x      Display only pools with potential problems
3244  *
3245  * Describes the health status of all pools or some subset.
3246  */
3247 int
3248 zpool_do_status(int argc, char **argv)
3249 {
3250         int c;
3251         int ret;
3252         status_cbdata_t cb = { 0 };
3253
3254         /* check options */
3255         while ((c = getopt(argc, argv, "vx")) != -1) {
3256                 switch (c) {
3257                 case 'v':
3258                         cb.cb_verbose = B_TRUE;
3259                         break;
3260                 case 'x':
3261                         cb.cb_explain = B_TRUE;
3262                         break;
3263                 case '?':
3264                         (void) fprintf(stderr, gettext("invalid option '%c'\n"),
3265                             optopt);
3266                         usage(B_FALSE);
3267                 }
3268         }
3269
3270         argc -= optind;
3271         argv += optind;
3272
3273         cb.cb_first = B_TRUE;
3274
3275         if (argc == 0)
3276                 cb.cb_allpools = B_TRUE;
3277
3278         ret = for_each_pool(argc, argv, B_TRUE, NULL, status_callback, &cb);
3279
3280         if (argc == 0 && cb.cb_count == 0)
3281                 (void) printf(gettext("no pools available\n"));
3282         else if (cb.cb_explain && cb.cb_first && cb.cb_allpools)
3283                 (void) printf(gettext("all pools are healthy\n"));
3284
3285         return (ret);
3286 }
3287
3288 typedef struct upgrade_cbdata {
3289         int     cb_all;
3290         int     cb_first;
3291         int     cb_newer;
3292         int     cb_argc;
3293         uint64_t cb_version;
3294         char    **cb_argv;
3295 } upgrade_cbdata_t;
3296
3297 static int
3298 upgrade_cb(zpool_handle_t *zhp, void *arg)
3299 {
3300         upgrade_cbdata_t *cbp = arg;
3301         nvlist_t *config;
3302         uint64_t version;
3303         int ret = 0;
3304
3305         config = zpool_get_config(zhp, NULL);
3306         verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION,
3307             &version) == 0);
3308
3309         if (!cbp->cb_newer && version < SPA_VERSION) {
3310                 if (!cbp->cb_all) {
3311                         if (cbp->cb_first) {
3312                                 (void) printf(gettext("The following pools are "
3313                                     "out of date, and can be upgraded.  After "
3314                                     "being\nupgraded, these pools will no "
3315                                     "longer be accessible by older software "
3316                                     "versions.\n\n"));
3317                                 (void) printf(gettext("VER  POOL\n"));
3318                                 (void) printf(gettext("---  ------------\n"));
3319                                 cbp->cb_first = B_FALSE;
3320                         }
3321
3322                         (void) printf("%2llu   %s\n", (u_longlong_t)version,
3323                             zpool_get_name(zhp));
3324                 } else {
3325                         cbp->cb_first = B_FALSE;
3326                         ret = zpool_upgrade(zhp, cbp->cb_version);
3327                         if (!ret) {
3328                                 (void) printf(gettext("Successfully upgraded "
3329                                     "'%s'\n\n"), zpool_get_name(zhp));
3330                         }
3331                 }
3332         } else if (cbp->cb_newer && version > SPA_VERSION) {
3333                 assert(!cbp->cb_all);
3334
3335                 if (cbp->cb_first) {
3336                         (void) printf(gettext("The following pools are "
3337                             "formatted using a newer software version and\n"
3338                             "cannot be accessed on the current system.\n\n"));
3339                         (void) printf(gettext("VER  POOL\n"));
3340                         (void) printf(gettext("---  ------------\n"));
3341                         cbp->cb_first = B_FALSE;
3342                 }
3343
3344                 (void) printf("%2llu   %s\n", (u_longlong_t)version,
3345                     zpool_get_name(zhp));
3346         }
3347
3348         zpool_close(zhp);
3349         return (ret);
3350 }
3351
3352 /* ARGSUSED */
3353 static int
3354 upgrade_one(zpool_handle_t *zhp, void *data)
3355 {
3356         upgrade_cbdata_t *cbp = data;
3357         uint64_t cur_version;
3358         int ret;
3359
3360         if (strcmp("log", zpool_get_name(zhp)) == 0) {
3361                 (void) printf(gettext("'log' is now a reserved word\n"
3362                     "Pool 'log' must be renamed using export and import"
3363                     " to upgrade.\n"));
3364                 return (1);
3365         }
3366
3367         cur_version = zpool_get_prop_int(zhp, ZPOOL_PROP_VERSION, NULL);
3368         if (cur_version > cbp->cb_version) {
3369                 (void) printf(gettext("Pool '%s' is already formatted "
3370                     "using more current version '%llu'.\n"),
3371                     zpool_get_name(zhp), cur_version);
3372                 return (0);
3373         }
3374         if (cur_version == cbp->cb_version) {
3375                 (void) printf(gettext("Pool '%s' is already formatted "
3376                     "using the current version.\n"), zpool_get_name(zhp));
3377                 return (0);
3378         }
3379
3380         ret = zpool_upgrade(zhp, cbp->cb_version);
3381
3382         if (!ret) {
3383                 (void) printf(gettext("Successfully upgraded '%s' "
3384                     "from version %llu to version %llu\n\n"),
3385                     zpool_get_name(zhp), (u_longlong_t)cur_version,
3386                     (u_longlong_t)cbp->cb_version);
3387         }
3388
3389         return (ret != 0);
3390 }
3391
3392 /*
3393  * zpool upgrade
3394  * zpool upgrade -v
3395  * zpool upgrade [-V version] <-a | pool ...>
3396  *
3397  * With no arguments, display downrev'd ZFS pool available for upgrade.
3398  * Individual pools can be upgraded by specifying the pool, and '-a' will
3399  * upgrade all pools.
3400  */
3401 int
3402 zpool_do_upgrade(int argc, char **argv)
3403 {
3404         int c;
3405         upgrade_cbdata_t cb = { 0 };
3406         int ret = 0;
3407         boolean_t showversions = B_FALSE;
3408         char *end;
3409
3410
3411         /* check options */
3412         while ((c = getopt(argc, argv, "avV:")) != -1) {
3413                 switch (c) {
3414                 case 'a':
3415                         cb.cb_all = B_TRUE;
3416                         break;
3417                 case 'v':
3418                         showversions = B_TRUE;
3419                         break;
3420                 case 'V':
3421                         cb.cb_version = strtoll(optarg, &end, 10);
3422                         if (*end != '\0' || cb.cb_version > SPA_VERSION ||
3423                             cb.cb_version < SPA_VERSION_1) {
3424                                 (void) fprintf(stderr,
3425                                     gettext("invalid version '%s'\n"), optarg);
3426                                 usage(B_FALSE);
3427                         }
3428                         break;
3429                 case '?':
3430                         (void) fprintf(stderr, gettext("invalid option '%c'\n"),
3431                             optopt);
3432                         usage(B_FALSE);
3433                 }
3434         }
3435
3436         cb.cb_argc = argc;
3437         cb.cb_argv = argv;
3438         argc -= optind;
3439         argv += optind;
3440
3441         if (cb.cb_version == 0) {
3442                 cb.cb_version = SPA_VERSION;
3443         } else if (!cb.cb_all && argc == 0) {
3444                 (void) fprintf(stderr, gettext("-V option is "
3445                     "incompatible with other arguments\n"));
3446                 usage(B_FALSE);
3447         }
3448
3449         if (showversions) {
3450                 if (cb.cb_all || argc != 0) {
3451                         (void) fprintf(stderr, gettext("-v option is "
3452                             "incompatible with other arguments\n"));
3453                         usage(B_FALSE);
3454                 }
3455         } else if (cb.cb_all) {
3456                 if (argc != 0) {
3457                         (void) fprintf(stderr, gettext("-a option should not "
3458                             "be used along with a pool name\n"));
3459                         usage(B_FALSE);
3460                 }
3461         }
3462
3463         (void) printf(gettext("This system is currently running "
3464             "ZFS pool version %llu.\n\n"), SPA_VERSION);
3465         cb.cb_first = B_TRUE;
3466         if (showversions) {
3467                 (void) printf(gettext("The following versions are "
3468                     "supported:\n\n"));
3469                 (void) printf(gettext("VER  DESCRIPTION\n"));
3470                 (void) printf("---  -----------------------------------------"
3471                     "---------------\n");
3472                 (void) printf(gettext(" 1   Initial ZFS version\n"));
3473                 (void) printf(gettext(" 2   Ditto blocks "
3474                     "(replicated metadata)\n"));
3475                 (void) printf(gettext(" 3   Hot spares and double parity "
3476                     "RAID-Z\n"));
3477                 (void) printf(gettext(" 4   zpool history\n"));
3478                 (void) printf(gettext(" 5   Compression using the gzip "
3479                     "algorithm\n"));
3480                 (void) printf(gettext(" 6   bootfs pool property\n"));
3481                 (void) printf(gettext(" 7   Separate intent log devices\n"));
3482                 (void) printf(gettext(" 8   Delegated administration\n"));
3483                 (void) printf(gettext(" 9   refquota and refreservation "
3484                     "properties\n"));
3485                 (void) printf(gettext(" 10  Cache devices\n"));
3486                 (void) printf(gettext(" 11  Improved scrub performance\n"));
3487                 (void) printf(gettext(" 12  Snapshot properties\n"));
3488                 (void) printf(gettext(" 13  snapused property\n"));
3489                 (void) printf(gettext(" 14  passthrough-x aclinherit "
3490                     "support\n"));
3491                 (void) printf(gettext("For more information on a particular "
3492                     "version, including supported releases, see:\n\n"));
3493                 (void) printf("http://www.opensolaris.org/os/community/zfs/"
3494                     "version/N\n\n");
3495                 (void) printf(gettext("Where 'N' is the version number.\n"));
3496         } else if (argc == 0) {
3497                 int notfound;
3498
3499                 ret = zpool_iter(g_zfs, upgrade_cb, &cb);
3500                 notfound = cb.cb_first;
3501
3502                 if (!cb.cb_all && ret == 0) {
3503                         if (!cb.cb_first)
3504                                 (void) printf("\n");
3505                         cb.cb_first = B_TRUE;
3506                         cb.cb_newer = B_TRUE;
3507                         ret = zpool_iter(g_zfs, upgrade_cb, &cb);
3508                         if (!cb.cb_first) {
3509                                 notfound = B_FALSE;
3510                                 (void) printf("\n");
3511                         }
3512                 }
3513
3514                 if (ret == 0) {
3515                         if (notfound)
3516                                 (void) printf(gettext("All pools are formatted "
3517                                     "using this version.\n"));
3518                         else if (!cb.cb_all)
3519                                 (void) printf(gettext("Use 'zpool upgrade -v' "
3520                                     "for a list of available versions and "
3521                                     "their associated\nfeatures.\n"));
3522                 }
3523         } else {
3524                 ret = for_each_pool(argc, argv, B_FALSE, NULL,
3525                     upgrade_one, &cb);
3526         }
3527
3528         return (ret);
3529 }
3530
3531 typedef struct hist_cbdata {
3532         boolean_t first;
3533         int longfmt;
3534         int internal;
3535 } hist_cbdata_t;
3536
3537 char *hist_event_table[LOG_END] = {
3538         "invalid event",
3539         "pool create",
3540         "vdev add",
3541         "pool remove",
3542         "pool destroy",
3543         "pool export",
3544         "pool import",
3545         "vdev attach",
3546         "vdev replace",
3547         "vdev detach",
3548         "vdev online",
3549         "vdev offline",
3550         "vdev upgrade",
3551         "pool clear",
3552         "pool scrub",
3553         "pool property set",
3554         "create",
3555         "clone",
3556         "destroy",
3557         "destroy_begin_sync",
3558         "inherit",
3559         "property set",
3560         "quota set",
3561         "permission update",
3562         "permission remove",
3563         "permission who remove",
3564         "promote",
3565         "receive",
3566         "rename",
3567         "reservation set",
3568         "replay_inc_sync",
3569         "replay_full_sync",
3570         "rollback",
3571         "snapshot",
3572         "filesystem version upgrade",
3573         "refquota set",
3574         "refreservation set",
3575         "pool scrub done",
3576 };
3577
3578 /*
3579  * Print out the command history for a specific pool.
3580  */
3581 static int
3582 get_history_one(zpool_handle_t *zhp, void *data)
3583 {
3584         nvlist_t *nvhis;
3585         nvlist_t **records;
3586         uint_t numrecords;
3587         char *cmdstr;
3588         char *pathstr;
3589         uint64_t dst_time;
3590         time_t tsec;
3591         struct tm t;
3592         char tbuf[30];
3593         int ret, i;
3594         uint64_t who;
3595         struct passwd *pwd;
3596         char *hostname;
3597         char *zonename;
3598         char internalstr[MAXPATHLEN];
3599         hist_cbdata_t *cb = (hist_cbdata_t *)data;
3600         uint64_t txg;
3601         uint64_t ievent;
3602
3603         cb->first = B_FALSE;
3604
3605         (void) printf(gettext("History for '%s':\n"), zpool_get_name(zhp));
3606
3607         if ((ret = zpool_get_history(zhp, &nvhis)) != 0)
3608                 return (ret);
3609
3610         verify(nvlist_lookup_nvlist_array(nvhis, ZPOOL_HIST_RECORD,
3611             &records, &numrecords) == 0);
3612         for (i = 0; i < numrecords; i++) {
3613                 if (nvlist_lookup_uint64(records[i], ZPOOL_HIST_TIME,
3614                     &dst_time) != 0)
3615                         continue;
3616
3617                 /* is it an internal event or a standard event? */
3618                 if (nvlist_lookup_string(records[i], ZPOOL_HIST_CMD,
3619                     &cmdstr) != 0) {
3620                         if (cb->internal == 0)
3621                                 continue;
3622
3623                         if (nvlist_lookup_uint64(records[i],
3624                             ZPOOL_HIST_INT_EVENT, &ievent) != 0)
3625                                 continue;
3626                         verify(nvlist_lookup_uint64(records[i],
3627                             ZPOOL_HIST_TXG, &txg) == 0);
3628                         verify(nvlist_lookup_string(records[i],
3629                             ZPOOL_HIST_INT_STR, &pathstr) == 0);
3630                         if (ievent >= LOG_END)
3631                                 continue;
3632                         (void) snprintf(internalstr,
3633                             sizeof (internalstr),
3634                             "[internal %s txg:%lld] %s",
3635                             hist_event_table[ievent], txg,
3636                             pathstr);
3637                         cmdstr = internalstr;
3638                 }
3639                 tsec = dst_time;
3640                 (void) localtime_r(&tsec, &t);
3641                 (void) strftime(tbuf, sizeof (tbuf), "%F.%T", &t);
3642                 (void) printf("%s %s", tbuf, cmdstr);
3643
3644                 if (!cb->longfmt) {
3645                         (void) printf("\n");
3646                         continue;
3647                 }
3648                 (void) printf(" [");
3649                 if (nvlist_lookup_uint64(records[i],
3650                     ZPOOL_HIST_WHO, &who) == 0) {
3651                         pwd = getpwuid((uid_t)who);
3652                         if (pwd)
3653                                 (void) printf("user %s on",
3654                                     pwd->pw_name);
3655                         else
3656                                 (void) printf("user %d on",
3657                                     (int)who);
3658                 } else {
3659                         (void) printf(gettext("no info]\n"));
3660                         continue;
3661                 }
3662                 if (nvlist_lookup_string(records[i],
3663                     ZPOOL_HIST_HOST, &hostname) == 0) {
3664                         (void) printf(" %s", hostname);
3665                 }
3666                 if (nvlist_lookup_string(records[i],
3667                     ZPOOL_HIST_ZONE, &zonename) == 0) {
3668                         (void) printf(":%s", zonename);
3669                 }
3670
3671                 (void) printf("]");
3672                 (void) printf("\n");
3673         }
3674         (void) printf("\n");
3675         nvlist_free(nvhis);
3676
3677         return (ret);
3678 }
3679
3680 /*
3681  * zpool history <pool>
3682  *
3683  * Displays the history of commands that modified pools.
3684  */
3685
3686
3687 int
3688 zpool_do_history(int argc, char **argv)
3689 {
3690         hist_cbdata_t cbdata = { 0 };
3691         int ret;
3692         int c;
3693
3694         cbdata.first = B_TRUE;
3695         /* check options */
3696         while ((c = getopt(argc, argv, "li")) != -1) {
3697                 switch (c) {
3698                 case 'l':
3699                         cbdata.longfmt = 1;
3700                         break;
3701                 case 'i':
3702                         cbdata.internal = 1;
3703                         break;
3704                 case '?':
3705                         (void) fprintf(stderr, gettext("invalid option '%c'\n"),
3706                             optopt);
3707                         usage(B_FALSE);
3708                 }
3709         }
3710         argc -= optind;
3711         argv += optind;
3712
3713         ret = for_each_pool(argc, argv, B_FALSE,  NULL, get_history_one,
3714             &cbdata);
3715
3716         if (argc == 0 && cbdata.first == B_TRUE) {
3717                 (void) printf(gettext("no pools available\n"));
3718                 return (0);
3719         }
3720
3721         return (ret);
3722 }
3723
3724 static int
3725 get_callback(zpool_handle_t *zhp, void *data)
3726 {
3727         zprop_get_cbdata_t *cbp = (zprop_get_cbdata_t *)data;
3728         char value[MAXNAMELEN];
3729         zprop_source_t srctype;
3730         zprop_list_t *pl;
3731
3732         for (pl = cbp->cb_proplist; pl != NULL; pl = pl->pl_next) {
3733
3734                 /*
3735                  * Skip the special fake placeholder. This will also skip
3736                  * over the name property when 'all' is specified.
3737                  */
3738                 if (pl->pl_prop == ZPOOL_PROP_NAME &&
3739                     pl == cbp->cb_proplist)
3740                         continue;
3741
3742                 if (zpool_get_prop(zhp, pl->pl_prop,
3743                     value, sizeof (value), &srctype) != 0)
3744                         continue;
3745
3746                 zprop_print_one_property(zpool_get_name(zhp), cbp,
3747                     zpool_prop_to_name(pl->pl_prop), value, srctype, NULL);
3748         }
3749         return (0);
3750 }
3751
3752 int
3753 zpool_do_get(int argc, char **argv)
3754 {
3755         zprop_get_cbdata_t cb = { 0 };
3756         zprop_list_t fake_name = { 0 };
3757         int ret;
3758
3759         if (argc < 3)
3760                 usage(B_FALSE);
3761
3762         cb.cb_first = B_TRUE;
3763         cb.cb_sources = ZPROP_SRC_ALL;
3764         cb.cb_columns[0] = GET_COL_NAME;
3765         cb.cb_columns[1] = GET_COL_PROPERTY;
3766         cb.cb_columns[2] = GET_COL_VALUE;
3767         cb.cb_columns[3] = GET_COL_SOURCE;
3768         cb.cb_type = ZFS_TYPE_POOL;
3769
3770         if (zprop_get_list(g_zfs, argv[1],  &cb.cb_proplist,
3771             ZFS_TYPE_POOL) != 0)
3772                 usage(B_FALSE);
3773
3774         if (cb.cb_proplist != NULL) {
3775                 fake_name.pl_prop = ZPOOL_PROP_NAME;
3776                 fake_name.pl_width = strlen(gettext("NAME"));
3777                 fake_name.pl_next = cb.cb_proplist;
3778                 cb.cb_proplist = &fake_name;
3779         }
3780
3781         ret = for_each_pool(argc - 2, argv + 2, B_TRUE, &cb.cb_proplist,
3782             get_callback, &cb);
3783
3784         if (cb.cb_proplist == &fake_name)
3785                 zprop_free_list(fake_name.pl_next);
3786         else
3787                 zprop_free_list(cb.cb_proplist);
3788
3789         return (ret);
3790 }
3791
3792 typedef struct set_cbdata {
3793         char *cb_propname;
3794         char *cb_value;
3795         boolean_t cb_any_successful;
3796 } set_cbdata_t;
3797
3798 int
3799 set_callback(zpool_handle_t *zhp, void *data)
3800 {
3801         int error;
3802         set_cbdata_t *cb = (set_cbdata_t *)data;
3803
3804         error = zpool_set_prop(zhp, cb->cb_propname, cb->cb_value);
3805
3806         if (!error)
3807                 cb->cb_any_successful = B_TRUE;
3808
3809         return (error);
3810 }
3811
3812 int
3813 zpool_do_set(int argc, char **argv)
3814 {
3815         set_cbdata_t cb = { 0 };
3816         int error;
3817
3818         if (argc > 1 && argv[1][0] == '-') {
3819                 (void) fprintf(stderr, gettext("invalid option '%c'\n"),
3820                     argv[1][1]);
3821                 usage(B_FALSE);
3822         }
3823
3824         if (argc < 2) {
3825                 (void) fprintf(stderr, gettext("missing property=value "
3826                     "argument\n"));
3827                 usage(B_FALSE);
3828         }
3829
3830         if (argc < 3) {
3831                 (void) fprintf(stderr, gettext("missing pool name\n"));
3832                 usage(B_FALSE);
3833         }
3834
3835         if (argc > 3) {
3836                 (void) fprintf(stderr, gettext("too many pool names\n"));
3837                 usage(B_FALSE);
3838         }
3839
3840         cb.cb_propname = argv[1];
3841         cb.cb_value = strchr(cb.cb_propname, '=');
3842         if (cb.cb_value == NULL) {
3843                 (void) fprintf(stderr, gettext("missing value in "
3844                     "property=value argument\n"));
3845                 usage(B_FALSE);
3846         }
3847
3848         *(cb.cb_value) = '\0';
3849         cb.cb_value++;
3850
3851         error = for_each_pool(argc - 2, argv + 2, B_TRUE, NULL,
3852             set_callback, &cb);
3853
3854         return (error);
3855 }
3856
3857 static int
3858 find_command_idx(char *command, int *idx)
3859 {
3860         int i;
3861
3862         for (i = 0; i < NCOMMAND; i++) {
3863                 if (command_table[i].name == NULL)
3864                         continue;
3865
3866                 if (strcmp(command, command_table[i].name) == 0) {
3867                         *idx = i;
3868                         return (0);
3869                 }
3870         }
3871         return (1);
3872 }
3873
3874 int
3875 main(int argc, char **argv)
3876 {
3877         int ret;
3878         int i;
3879         char *cmdname;
3880
3881         (void) setlocale(LC_ALL, "");
3882         (void) textdomain(TEXT_DOMAIN);
3883
3884         if ((g_zfs = libzfs_init()) == NULL) {
3885                 (void) fprintf(stderr, gettext("internal error: failed to "
3886                     "initialize ZFS library\n"));
3887                 return (1);
3888         }
3889
3890         libzfs_print_on_error(g_zfs, B_TRUE);
3891
3892         opterr = 0;
3893
3894         /*
3895          * Make sure the user has specified some command.
3896          */
3897         if (argc < 2) {
3898                 (void) fprintf(stderr, gettext("missing command\n"));
3899                 usage(B_FALSE);
3900         }
3901
3902         cmdname = argv[1];
3903
3904         /*
3905          * Special case '-?'
3906          */
3907         if (strcmp(cmdname, "-?") == 0)
3908                 usage(B_TRUE);
3909
3910         zpool_set_history_str("zpool", argc, argv, history_str);
3911         verify(zpool_stage_history(g_zfs, history_str) == 0);
3912
3913         /*
3914          * Run the appropriate command.
3915          */
3916         if (find_command_idx(cmdname, &i) == 0) {
3917                 current_command = &command_table[i];
3918                 ret = command_table[i].func(argc - 1, argv + 1);
3919         } else if (strchr(cmdname, '=')) {
3920                 verify(find_command_idx("set", &i) == 0);
3921                 current_command = &command_table[i];
3922                 ret = command_table[i].func(argc, argv);
3923         } else if (strcmp(cmdname, "freeze") == 0 && argc == 3) {
3924                 /*
3925                  * 'freeze' is a vile debugging abomination, so we treat
3926                  * it as such.
3927                  */
3928                 char buf[16384];
3929                 int fd = open(ZFS_DEV, O_RDWR);
3930                 (void) strcpy((void *)buf, argv[2]);
3931                 return (!!ioctl(fd, ZFS_IOC_POOL_FREEZE, buf));
3932         } else {
3933                 (void) fprintf(stderr, gettext("unrecognized "
3934                     "command '%s'\n"), cmdname);
3935                 usage(B_FALSE);
3936         }
3937
3938         libzfs_fini(g_zfs);
3939
3940         /*
3941          * The 'ZFS_ABORT' environment variable causes us to dump core on exit
3942          * for the purposes of running ::findleaks.
3943          */
3944         if (getenv("ZFS_ABORT") != NULL) {
3945                 (void) printf("dumping core by request\n");
3946                 abort();
3947         }
3948
3949         return (ret);
3950 }