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