lib/libzfs/libzfs_pool.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 (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
  25  * Copyright (c) 2011 by Delphix. All rights reserved.
  26  */
  27
  28 #include <ctype.h>
  29 #include <errno.h>
  30 #include <devid.h>
  31 #include <fcntl.h>
  32 #include <libintl.h>
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <strings.h>
  36 #include <unistd.h>
  37 #include <zone.h>
  38 #include <sys/stat.h>
  39 #include <sys/efi_partition.h>
  40 #include <sys/vtoc.h>
  41 #include <sys/zfs_ioctl.h>
  42 #include <dlfcn.h>
  43
  44 #include "zfs_namecheck.h"
  45 #include "zfs_prop.h"
  46 #include "libzfs_impl.h"
  47 #include "zfs_comutil.h"
  48
  49 static int read_efi_label(nvlist_t *config, diskaddr_t *sb);
  50
  51 typedef struct prop_flags {
  52         int create:1;   /* Validate property on creation */
  53         int import:1;   /* Validate property on import */
  54 } prop_flags_t;
  55
  56 /*
  57  * ====================================================================
  58  *   zpool property functions
  59  * ====================================================================
  60  */
  61
  62 static int
  63 zpool_get_all_props(zpool_handle_t *zhp)
  64 {
  65         zfs_cmd_t zc = { "\0", "\0", "\0", "\0", 0 };
  66         libzfs_handle_t *hdl = zhp->zpool_hdl;
  67
  68         (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
  69
  70         if (zcmd_alloc_dst_nvlist(hdl, &zc, 0) != 0)
  71                 return (-1);
  72
  73         while (ioctl(hdl->libzfs_fd, ZFS_IOC_POOL_GET_PROPS, &zc) != 0) {
  74                 if (errno == ENOMEM) {
  75                         if (zcmd_expand_dst_nvlist(hdl, &zc) != 0) {
  76                                 zcmd_free_nvlists(&zc);
  77                                 return (-1);
  78                         }
  79                 } else {
  80                         zcmd_free_nvlists(&zc);
  81                         return (-1);
  82                 }
  83         }
  84
  85         if (zcmd_read_dst_nvlist(hdl, &zc, &zhp->zpool_props) != 0) {
  86                 zcmd_free_nvlists(&zc);
  87                 return (-1);
  88         }
  89
  90         zcmd_free_nvlists(&zc);
  91
  92         return (0);
  93 }
  94
  95 static int
  96 zpool_props_refresh(zpool_handle_t *zhp)
  97 {
  98         nvlist_t *old_props;
  99
 100         old_props = zhp->zpool_props;
 101
 102         if (zpool_get_all_props(zhp) != 0)
 103                 return (-1);
 104
 105         nvlist_free(old_props);
 106         return (0);
 107 }
 108
 109 static char *
 110 zpool_get_prop_string(zpool_handle_t *zhp, zpool_prop_t prop,
 111     zprop_source_t *src)
 112 {
 113         nvlist_t *nv, *nvl;
 114         uint64_t ival;
 115         char *value;
 116         zprop_source_t source;
 117
 118         nvl = zhp->zpool_props;
 119         if (nvlist_lookup_nvlist(nvl, zpool_prop_to_name(prop), &nv) == 0) {
 120                 verify(nvlist_lookup_uint64(nv, ZPROP_SOURCE, &ival) == 0);
 121                 source = ival;
 122                 verify(nvlist_lookup_string(nv, ZPROP_VALUE, &value) == 0);
 123         } else {
 124                 source = ZPROP_SRC_DEFAULT;
 125                 if ((value = (char *)zpool_prop_default_string(prop)) == NULL)
 126                         value = "-";
 127         }
 128
 129         if (src)
 130                 *src = source;
 131
 132         return (value);
 133 }
 134
 135 uint64_t
 136 zpool_get_prop_int(zpool_handle_t *zhp, zpool_prop_t prop, zprop_source_t *src)
 137 {
 138         nvlist_t *nv, *nvl;
 139         uint64_t value;
 140         zprop_source_t source;
 141
 142         if (zhp->zpool_props == NULL && zpool_get_all_props(zhp)) {
 143                 /*
 144                  * zpool_get_all_props() has most likely failed because
 145                  * the pool is faulted, but if all we need is the top level
 146                  * vdev's guid then get it from the zhp config nvlist.
 147                  */
 148                 if ((prop == ZPOOL_PROP_GUID) &&
 149                     (nvlist_lookup_nvlist(zhp->zpool_config,
 150                     ZPOOL_CONFIG_VDEV_TREE, &nv) == 0) &&
 151                     (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &value)
 152                     == 0)) {
 153                         return (value);
 154                 }
 155                 return (zpool_prop_default_numeric(prop));
 156         }
 157
 158         nvl = zhp->zpool_props;
 159         if (nvlist_lookup_nvlist(nvl, zpool_prop_to_name(prop), &nv) == 0) {
 160                 verify(nvlist_lookup_uint64(nv, ZPROP_SOURCE, &value) == 0);
 161                 source = value;
 162                 verify(nvlist_lookup_uint64(nv, ZPROP_VALUE, &value) == 0);
 163         } else {
 164                 source = ZPROP_SRC_DEFAULT;
 165                 value = zpool_prop_default_numeric(prop);
 166         }
 167
 168         if (src)
 169                 *src = source;
 170
 171         return (value);
 172 }
 173
 174 /*
 175  * Map VDEV STATE to printed strings.
 176  */
 177 char *
 178 zpool_state_to_name(vdev_state_t state, vdev_aux_t aux)
 179 {
 180         switch (state) {
 181         default:
 182                 break;
 183         case VDEV_STATE_CLOSED:
 184         case VDEV_STATE_OFFLINE:
 185                 return (gettext("OFFLINE"));
 186         case VDEV_STATE_REMOVED:
 187                 return (gettext("REMOVED"));
 188         case VDEV_STATE_CANT_OPEN:
 189                 if (aux == VDEV_AUX_CORRUPT_DATA || aux == VDEV_AUX_BAD_LOG)
 190                         return (gettext("FAULTED"));
 191                 else if (aux == VDEV_AUX_SPLIT_POOL)
 192                         return (gettext("SPLIT"));
 193                 else
 194                         return (gettext("UNAVAIL"));
 195         case VDEV_STATE_FAULTED:
 196                 return (gettext("FAULTED"));
 197         case VDEV_STATE_DEGRADED:
 198                 return (gettext("DEGRADED"));
 199         case VDEV_STATE_HEALTHY:
 200                 return (gettext("ONLINE"));
 201         }
 202
 203         return (gettext("UNKNOWN"));
 204 }
 205
 206 /*
 207  * Get a zpool property value for 'prop' and return the value in
 208  * a pre-allocated buffer.
 209  */
 210 int
 211 zpool_get_prop(zpool_handle_t *zhp, zpool_prop_t prop, char *buf, size_t len,
 212     zprop_source_t *srctype)
 213 {
 214         uint64_t intval;
 215         const char *strval;
 216         zprop_source_t src = ZPROP_SRC_NONE;
 217         nvlist_t *nvroot;
 218         vdev_stat_t *vs;
 219         uint_t vsc;
 220
 221         if (zpool_get_state(zhp) == POOL_STATE_UNAVAIL) {
 222                 switch (prop) {
 223                 case ZPOOL_PROP_NAME:
 224                         (void) strlcpy(buf, zpool_get_name(zhp), len);
 225                         break;
 226
 227                 case ZPOOL_PROP_HEALTH:
 228                         (void) strlcpy(buf, "FAULTED", len);
 229                         break;
 230
 231                 case ZPOOL_PROP_GUID:
 232                         intval = zpool_get_prop_int(zhp, prop, &src);
 233                         (void) snprintf(buf, len, "%llu", (u_longlong_t)intval);
 234                         break;
 235
 236                 case ZPOOL_PROP_ALTROOT:
 237                 case ZPOOL_PROP_CACHEFILE:
 238                         if (zhp->zpool_props != NULL ||
 239                             zpool_get_all_props(zhp) == 0) {
 240                                 (void) strlcpy(buf,
 241                                     zpool_get_prop_string(zhp, prop, &src),
 242                                     len);
 243                                 if (srctype != NULL)
 244                                         *srctype = src;
 245                                 return (0);
 246                         }
 247                         /* FALLTHROUGH */
 248                 default:
 249                         (void) strlcpy(buf, "-", len);
 250                         break;
 251                 }
 252
 253                 if (srctype != NULL)
 254                         *srctype = src;
 255                 return (0);
 256         }
 257
 258         if (zhp->zpool_props == NULL && zpool_get_all_props(zhp) &&
 259             prop != ZPOOL_PROP_NAME)
 260                 return (-1);
 261
 262         switch (zpool_prop_get_type(prop)) {
 263         case PROP_TYPE_STRING:
 264                 (void) strlcpy(buf, zpool_get_prop_string(zhp, prop, &src),
 265                     len);
 266                 break;
 267
 268         case PROP_TYPE_NUMBER:
 269                 intval = zpool_get_prop_int(zhp, prop, &src);
 270
 271                 switch (prop) {
 272                 case ZPOOL_PROP_SIZE:
 273                 case ZPOOL_PROP_ALLOCATED:
 274                 case ZPOOL_PROP_FREE:
 275                 case ZPOOL_PROP_ASHIFT:
 276                         (void) zfs_nicenum(intval, buf, len);
 277                         break;
 278
 279                 case ZPOOL_PROP_CAPACITY:
 280                         (void) snprintf(buf, len, "%llu%%",
 281                             (u_longlong_t)intval);
 282                         break;
 283
 284                 case ZPOOL_PROP_DEDUPRATIO:
 285                         (void) snprintf(buf, len, "%llu.%02llux",
 286                             (u_longlong_t)(intval / 100),
 287                             (u_longlong_t)(intval % 100));
 288                         break;
 289
 290                 case ZPOOL_PROP_HEALTH:
 291                         verify(nvlist_lookup_nvlist(zpool_get_config(zhp, NULL),
 292                             ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0);
 293                         verify(nvlist_lookup_uint64_array(nvroot,
 294                             ZPOOL_CONFIG_VDEV_STATS, (uint64_t **)&vs, &vsc)
 295                             == 0);
 296
 297                         (void) strlcpy(buf, zpool_state_to_name(intval,
 298                             vs->vs_aux), len);
 299                         break;
 300                 default:
 301                         (void) snprintf(buf, len, "%llu", (u_longlong_t)intval);
 302                 }
 303                 break;
 304
 305         case PROP_TYPE_INDEX:
 306                 intval = zpool_get_prop_int(zhp, prop, &src);
 307                 if (zpool_prop_index_to_string(prop, intval, &strval)
 308                     != 0)
 309                         return (-1);
 310                 (void) strlcpy(buf, strval, len);
 311                 break;
 312
 313         default:
 314                 abort();
 315         }
 316
 317         if (srctype)
 318                 *srctype = src;
 319
 320         return (0);
 321 }
 322
 323 /*
 324  * Check if the bootfs name has the same pool name as it is set to.
 325  * Assuming bootfs is a valid dataset name.
 326  */
 327 static boolean_t
 328 bootfs_name_valid(const char *pool, char *bootfs)
 329 {
 330         int len = strlen(pool);
 331
 332         if (!zfs_name_valid(bootfs, ZFS_TYPE_FILESYSTEM|ZFS_TYPE_SNAPSHOT))
 333                 return (B_FALSE);
 334
 335         if (strncmp(pool, bootfs, len) == 0 &&
 336             (bootfs[len] == '/' || bootfs[len] == '\0'))
 337                 return (B_TRUE);
 338
 339         return (B_FALSE);
 340 }
 341
 342 /*
 343  * Inspect the configuration to determine if any of the devices contain
 344  * an EFI label.
 345  */
 346 static boolean_t
 347 pool_uses_efi(nvlist_t *config)
 348 {
 349         nvlist_t **child;
 350         uint_t c, children;
 351
 352         if (nvlist_lookup_nvlist_array(config, ZPOOL_CONFIG_CHILDREN,
 353             &child, &children) != 0)
 354                 return (read_efi_label(config, NULL) >= 0);
 355
 356         for (c = 0; c < children; c++) {
 357                 if (pool_uses_efi(child[c]))
 358                         return (B_TRUE);
 359         }
 360         return (B_FALSE);
 361 }
 362
 363 static boolean_t
 364 pool_is_bootable(zpool_handle_t *zhp)
 365 {
 366         char bootfs[ZPOOL_MAXNAMELEN];
 367
 368         return (zpool_get_prop(zhp, ZPOOL_PROP_BOOTFS, bootfs,
 369             sizeof (bootfs), NULL) == 0 && strncmp(bootfs, "-",
 370             sizeof (bootfs)) != 0);
 371 }
 372
 373
 374 /*
 375  * Given an nvlist of zpool properties to be set, validate that they are
 376  * correct, and parse any numeric properties (index, boolean, etc) if they are
 377  * specified as strings.
 378  */
 379 static nvlist_t *
 380 zpool_valid_proplist(libzfs_handle_t *hdl, const char *poolname,
 381     nvlist_t *props, uint64_t version, prop_flags_t flags, char *errbuf)
 382 {
 383         nvpair_t *elem;
 384         nvlist_t *retprops;
 385         zpool_prop_t prop;
 386         char *strval;
 387         uint64_t intval;
 388         char *slash;
 389         struct stat64 statbuf;
 390         zpool_handle_t *zhp;
 391         nvlist_t *nvroot;
 392
 393         if (nvlist_alloc(&retprops, NV_UNIQUE_NAME, 0) != 0) {
 394                 (void) no_memory(hdl);
 395                 return (NULL);
 396         }
 397
 398         elem = NULL;
 399         while ((elem = nvlist_next_nvpair(props, elem)) != NULL) {
 400                 const char *propname = nvpair_name(elem);
 401
 402                 /*
 403                  * Make sure this property is valid and applies to this type.
 404                  */
 405                 if ((prop = zpool_name_to_prop(propname)) == ZPROP_INVAL) {
 406                         zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 407                             "invalid property '%s'"), propname);
 408                         (void) zfs_error(hdl, EZFS_BADPROP, errbuf);
 409                         goto error;
 410                 }
 411
 412                 if (zpool_prop_readonly(prop)) {
 413                         zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "'%s' "
 414                             "is readonly"), propname);
 415                         (void) zfs_error(hdl, EZFS_PROPREADONLY, errbuf);
 416                         goto error;
 417                 }
 418
 419                 if (zprop_parse_value(hdl, elem, prop, ZFS_TYPE_POOL, retprops,
 420                     &strval, &intval, errbuf) != 0)
 421                         goto error;
 422
 423                 /*
 424                  * Perform additional checking for specific properties.
 425                  */
 426                 switch (prop) {
 427                 default:
 428                         break;
 429                 case ZPOOL_PROP_VERSION:
 430                         if (intval < version || intval > SPA_VERSION) {
 431                                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 432                                     "property '%s' number %d is invalid."),
 433                                     propname, intval);
 434                                 (void) zfs_error(hdl, EZFS_BADVERSION, errbuf);
 435                                 goto error;
 436                         }
 437                         break;
 438
 439                 case ZPOOL_PROP_ASHIFT:
 440                         if (!flags.create) {
 441                                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 442                                     "property '%s' can only be set at "
 443                                     "creation time"), propname);
 444                                 (void) zfs_error(hdl, EZFS_BADPROP, errbuf);
 445                                 goto error;
 446                         }
 447
 448                         if (intval != 0 && (intval < 9 || intval > 13)) {
 449                                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 450                                     "property '%s' number %d is invalid."),
 451                                     propname, intval);
 452                                 (void) zfs_error(hdl, EZFS_BADPROP, errbuf);
 453                                 goto error;
 454                         }
 455                         break;
 456
 457                 case ZPOOL_PROP_BOOTFS:
 458                         if (flags.create || flags.import) {
 459                                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 460                                     "property '%s' cannot be set at creation "
 461                                     "or import time"), propname);
 462                                 (void) zfs_error(hdl, EZFS_BADPROP, errbuf);
 463                                 goto error;
 464                         }
 465
 466                         if (version < SPA_VERSION_BOOTFS) {
 467                                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 468                                     "pool must be upgraded to support "
 469                                     "'%s' property"), propname);
 470                                 (void) zfs_error(hdl, EZFS_BADVERSION, errbuf);
 471                                 goto error;
 472                         }
 473
 474                         /*
 475                          * bootfs property value has to be a dataset name and
 476                          * the dataset has to be in the same pool as it sets to.
 477                          */
 478                         if (strval[0] != '\0' && !bootfs_name_valid(poolname,
 479                             strval)) {
 480                                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "'%s' "
 481                                     "is an invalid name"), strval);
 482                                 (void) zfs_error(hdl, EZFS_INVALIDNAME, errbuf);
 483                                 goto error;
 484                         }
 485
 486                         if ((zhp = zpool_open_canfail(hdl, poolname)) == NULL) {
 487                                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 488                                     "could not open pool '%s'"), poolname);
 489                                 (void) zfs_error(hdl, EZFS_OPENFAILED, errbuf);
 490                                 goto error;
 491                         }
 492                         verify(nvlist_lookup_nvlist(zpool_get_config(zhp, NULL),
 493                             ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0);
 494
 495 #if defined(__sun__) || defined(__sun)
 496                         /*
 497                          * bootfs property cannot be set on a disk which has
 498                          * been EFI labeled.
 499                          */
 500                         if (pool_uses_efi(nvroot)) {
 501                                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 502                                     "property '%s' not supported on "
 503                                     "EFI labeled devices"), propname);
 504                                 (void) zfs_error(hdl, EZFS_POOL_NOTSUP, errbuf);
 505                                 zpool_close(zhp);
 506                                 goto error;
 507                         }
 508 #endif
 509                         zpool_close(zhp);
 510                         break;
 511
 512                 case ZPOOL_PROP_ALTROOT:
 513                         if (!flags.create && !flags.import) {
 514                                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 515                                     "property '%s' can only be set during pool "
 516                                     "creation or import"), propname);
 517                                 (void) zfs_error(hdl, EZFS_BADPROP, errbuf);
 518                                 goto error;
 519                         }
 520
 521                         if (strval[0] != '/') {
 522                                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 523                                     "bad alternate root '%s'"), strval);
 524                                 (void) zfs_error(hdl, EZFS_BADPATH, errbuf);
 525                                 goto error;
 526                         }
 527                         break;
 528
 529                 case ZPOOL_PROP_CACHEFILE:
 530                         if (strval[0] == '\0')
 531                                 break;
 532
 533                         if (strcmp(strval, "none") == 0)
 534                                 break;
 535
 536                         if (strval[0] != '/') {
 537                                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 538                                     "property '%s' must be empty, an "
 539                                     "absolute path, or 'none'"), propname);
 540                                 (void) zfs_error(hdl, EZFS_BADPATH, errbuf);
 541                                 goto error;
 542                         }
 543
 544                         slash = strrchr(strval, '/');
 545
 546                         if (slash[1] == '\0' || strcmp(slash, "/.") == 0 ||
 547                             strcmp(slash, "/..") == 0) {
 548                                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 549                                     "'%s' is not a valid file"), strval);
 550                                 (void) zfs_error(hdl, EZFS_BADPATH, errbuf);
 551                                 goto error;
 552                         }
 553
 554                         *slash = '\0';
 555
 556                         if (strval[0] != '\0' &&
 557                             (stat64(strval, &statbuf) != 0 ||
 558                             !S_ISDIR(statbuf.st_mode))) {
 559                                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 560                                     "'%s' is not a valid directory"),
 561                                     strval);
 562                                 (void) zfs_error(hdl, EZFS_BADPATH, errbuf);
 563                                 goto error;
 564                         }
 565
 566                         *slash = '/';
 567                         break;
 568
 569                 case ZPOOL_PROP_READONLY:
 570                         if (!flags.import) {
 571                                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 572                                     "property '%s' can only be set at "
 573                                     "import time"), propname);
 574                                 (void) zfs_error(hdl, EZFS_BADPROP, errbuf);
 575                                 goto error;
 576                         }
 577                         break;
 578                 }
 579         }
 580
 581         return (retprops);
 582 error:
 583         nvlist_free(retprops);
 584         return (NULL);
 585 }
 586
 587 /*
 588  * Set zpool property : propname=propval.
 589  */
 590 int
 591 zpool_set_prop(zpool_handle_t *zhp, const char *propname, const char *propval)
 592 {
 593         zfs_cmd_t zc = { "\0", "\0", "\0", "\0", 0 };
 594         int ret = -1;
 595         char errbuf[1024];
 596         nvlist_t *nvl = NULL;
 597         nvlist_t *realprops;
 598         uint64_t version;
 599         prop_flags_t flags = { 0 };
 600
 601         (void) snprintf(errbuf, sizeof (errbuf),
 602             dgettext(TEXT_DOMAIN, "cannot set property for '%s'"),
 603             zhp->zpool_name);
 604
 605         if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0)
 606                 return (no_memory(zhp->zpool_hdl));
 607
 608         if (nvlist_add_string(nvl, propname, propval) != 0) {
 609                 nvlist_free(nvl);
 610                 return (no_memory(zhp->zpool_hdl));
 611         }
 612
 613         version = zpool_get_prop_int(zhp, ZPOOL_PROP_VERSION, NULL);
 614         if ((realprops = zpool_valid_proplist(zhp->zpool_hdl,
 615             zhp->zpool_name, nvl, version, flags, errbuf)) == NULL) {
 616                 nvlist_free(nvl);
 617                 return (-1);
 618         }
 619
 620         nvlist_free(nvl);
 621         nvl = realprops;
 622
 623         /*
 624          * Execute the corresponding ioctl() to set this property.
 625          */
 626         (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
 627
 628         if (zcmd_write_src_nvlist(zhp->zpool_hdl, &zc, nvl) != 0) {
 629                 nvlist_free(nvl);
 630                 return (-1);
 631         }
 632
 633         ret = zfs_ioctl(zhp->zpool_hdl, ZFS_IOC_POOL_SET_PROPS, &zc);
 634
 635         zcmd_free_nvlists(&zc);
 636         nvlist_free(nvl);
 637
 638         if (ret)
 639                 (void) zpool_standard_error(zhp->zpool_hdl, errno, errbuf);
 640         else
 641                 (void) zpool_props_refresh(zhp);
 642
 643         return (ret);
 644 }
 645
 646 int
 647 zpool_expand_proplist(zpool_handle_t *zhp, zprop_list_t **plp)
 648 {
 649         libzfs_handle_t *hdl = zhp->zpool_hdl;
 650         zprop_list_t *entry;
 651         char buf[ZFS_MAXPROPLEN];
 652
 653         if (zprop_expand_list(hdl, plp, ZFS_TYPE_POOL) != 0)
 654                 return (-1);
 655
 656         for (entry = *plp; entry != NULL; entry = entry->pl_next) {
 657
 658                 if (entry->pl_fixed)
 659                         continue;
 660
 661                 if (entry->pl_prop != ZPROP_INVAL &&
 662                     zpool_get_prop(zhp, entry->pl_prop, buf, sizeof (buf),
 663                     NULL) == 0) {
 664                         if (strlen(buf) > entry->pl_width)
 665                                 entry->pl_width = strlen(buf);
 666                 }
 667         }
 668
 669         return (0);
 670 }
 671
 672
 673 /*
 674  * Don't start the slice at the default block of 34; many storage
 675  * devices will use a stripe width of 128k, other vendors prefer a 1m
 676  * alignment.  It is best to play it safe and ensure a 1m alignment
 677  * given 512B blocks.  When the block size is larger by a power of 2
 678  * we will still be 1m aligned.  Some devices are sensitive to the
 679  * partition ending alignment as well.
 680  */
 681 #define NEW_START_BLOCK         2048
 682 #define PARTITION_END_ALIGNMENT 2048
 683
 684 /*
 685  * Validate the given pool name, optionally putting an extended error message in
 686  * 'buf'.
 687  */
 688 boolean_t
 689 zpool_name_valid(libzfs_handle_t *hdl, boolean_t isopen, const char *pool)
 690 {
 691         namecheck_err_t why;
 692         char what;
 693         int ret;
 694
 695         ret = pool_namecheck(pool, &why, &what);
 696
 697         /*
 698          * The rules for reserved pool names were extended at a later point.
 699          * But we need to support users with existing pools that may now be
 700          * invalid.  So we only check for this expanded set of names during a
 701          * create (or import), and only in userland.
 702          */
 703         if (ret == 0 && !isopen &&
 704             (strncmp(pool, "mirror", 6) == 0 ||
 705             strncmp(pool, "raidz", 5) == 0 ||
 706             strncmp(pool, "spare", 5) == 0 ||
 707             strcmp(pool, "log") == 0)) {
 708                 if (hdl != NULL)
 709                         zfs_error_aux(hdl,
 710                             dgettext(TEXT_DOMAIN, "name is reserved"));
 711                 return (B_FALSE);
 712         }
 713
 714
 715         if (ret != 0) {
 716                 if (hdl != NULL) {
 717                         switch (why) {
 718                         case NAME_ERR_TOOLONG:
 719                                 zfs_error_aux(hdl,
 720                                     dgettext(TEXT_DOMAIN, "name is too long"));
 721                                 break;
 722
 723                         case NAME_ERR_INVALCHAR:
 724                                 zfs_error_aux(hdl,
 725                                     dgettext(TEXT_DOMAIN, "invalid character "
 726                                     "'%c' in pool name"), what);
 727                                 break;
 728
 729                         case NAME_ERR_NOLETTER:
 730                                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 731                                     "name must begin with a letter"));
 732                                 break;
 733
 734                         case NAME_ERR_RESERVED:
 735                                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 736                                     "name is reserved"));
 737                                 break;
 738
 739                         case NAME_ERR_DISKLIKE:
 740                                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 741                                     "pool name is reserved"));
 742                                 break;
 743
 744                         case NAME_ERR_LEADING_SLASH:
 745                                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 746                                     "leading slash in name"));
 747                                 break;
 748
 749                         case NAME_ERR_EMPTY_COMPONENT:
 750                                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 751                                     "empty component in name"));
 752                                 break;
 753
 754                         case NAME_ERR_TRAILING_SLASH:
 755                                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 756                                     "trailing slash in name"));
 757                                 break;
 758
 759                         case NAME_ERR_MULTIPLE_AT:
 760                                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 761                                     "multiple '@' delimiters in name"));
 762                                 break;
 763                         case NAME_ERR_NO_AT:
 764                                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 765                                     "permission set is missing '@'"));
 766                                 break;
 767                         }
 768                 }
 769                 return (B_FALSE);
 770         }
 771
 772         return (B_TRUE);
 773 }
 774
 775 /*
 776  * Open a handle to the given pool, even if the pool is currently in the FAULTED
 777  * state.
 778  */
 779 zpool_handle_t *
 780 zpool_open_canfail(libzfs_handle_t *hdl, const char *pool)
 781 {
 782         zpool_handle_t *zhp;
 783         boolean_t missing;
 784
 785         /*
 786          * Make sure the pool name is valid.
 787          */
 788         if (!zpool_name_valid(hdl, B_TRUE, pool)) {
 789                 (void) zfs_error_fmt(hdl, EZFS_INVALIDNAME,
 790                     dgettext(TEXT_DOMAIN, "cannot open '%s'"),
 791                     pool);
 792                 return (NULL);
 793         }
 794
 795         if ((zhp = zfs_alloc(hdl, sizeof (zpool_handle_t))) == NULL)
 796                 return (NULL);
 797
 798         zhp->zpool_hdl = hdl;
 799         (void) strlcpy(zhp->zpool_name, pool, sizeof (zhp->zpool_name));
 800
 801         if (zpool_refresh_stats(zhp, &missing) != 0) {
 802                 zpool_close(zhp);
 803                 return (NULL);
 804         }
 805
 806         if (missing) {
 807                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "no such pool"));
 808                 (void) zfs_error_fmt(hdl, EZFS_NOENT,
 809                     dgettext(TEXT_DOMAIN, "cannot open '%s'"), pool);
 810                 zpool_close(zhp);
 811                 return (NULL);
 812         }
 813
 814         return (zhp);
 815 }
 816
 817 /*
 818  * Like the above, but silent on error.  Used when iterating over pools (because
 819  * the configuration cache may be out of date).
 820  */
 821 int
 822 zpool_open_silent(libzfs_handle_t *hdl, const char *pool, zpool_handle_t **ret)
 823 {
 824         zpool_handle_t *zhp;
 825         boolean_t missing;
 826
 827         if ((zhp = zfs_alloc(hdl, sizeof (zpool_handle_t))) == NULL)
 828                 return (-1);
 829
 830         zhp->zpool_hdl = hdl;
 831         (void) strlcpy(zhp->zpool_name, pool, sizeof (zhp->zpool_name));
 832
 833         if (zpool_refresh_stats(zhp, &missing) != 0) {
 834                 zpool_close(zhp);
 835                 return (-1);
 836         }
 837
 838         if (missing) {
 839                 zpool_close(zhp);
 840                 *ret = NULL;
 841                 return (0);
 842         }
 843
 844         *ret = zhp;
 845         return (0);
 846 }
 847
 848 /*
 849  * Similar to zpool_open_canfail(), but refuses to open pools in the faulted
 850  * state.
 851  */
 852 zpool_handle_t *
 853 zpool_open(libzfs_handle_t *hdl, const char *pool)
 854 {
 855         zpool_handle_t *zhp;
 856
 857         if ((zhp = zpool_open_canfail(hdl, pool)) == NULL)
 858                 return (NULL);
 859
 860         if (zhp->zpool_state == POOL_STATE_UNAVAIL) {
 861                 (void) zfs_error_fmt(hdl, EZFS_POOLUNAVAIL,
 862                     dgettext(TEXT_DOMAIN, "cannot open '%s'"), zhp->zpool_name);
 863                 zpool_close(zhp);
 864                 return (NULL);
 865         }
 866
 867         return (zhp);
 868 }
 869
 870 /*
 871  * Close the handle.  Simply frees the memory associated with the handle.
 872  */
 873 void
 874 zpool_close(zpool_handle_t *zhp)
 875 {
 876         if (zhp->zpool_config)
 877                 nvlist_free(zhp->zpool_config);
 878         if (zhp->zpool_old_config)
 879                 nvlist_free(zhp->zpool_old_config);
 880         if (zhp->zpool_props)
 881                 nvlist_free(zhp->zpool_props);
 882         free(zhp);
 883 }
 884
 885 /*
 886  * Return the name of the pool.
 887  */
 888 const char *
 889 zpool_get_name(zpool_handle_t *zhp)
 890 {
 891         return (zhp->zpool_name);
 892 }
 893
 894
 895 /*
 896  * Return the state of the pool (ACTIVE or UNAVAILABLE)
 897  */
 898 int
 899 zpool_get_state(zpool_handle_t *zhp)
 900 {
 901         return (zhp->zpool_state);
 902 }
 903
 904 /*
 905  * Create the named pool, using the provided vdev list.  It is assumed
 906  * that the consumer has already validated the contents of the nvlist, so we
 907  * don't have to worry about error semantics.
 908  */
 909 int
 910 zpool_create(libzfs_handle_t *hdl, const char *pool, nvlist_t *nvroot,
 911     nvlist_t *props, nvlist_t *fsprops)
 912 {
 913         zfs_cmd_t zc = { "\0", "\0", "\0", "\0", 0 };
 914         nvlist_t *zc_fsprops = NULL;
 915         nvlist_t *zc_props = NULL;
 916         char msg[1024];
 917         char *altroot;
 918         int ret = -1;
 919
 920         (void) snprintf(msg, sizeof (msg), dgettext(TEXT_DOMAIN,
 921             "cannot create '%s'"), pool);
 922
 923         if (!zpool_name_valid(hdl, B_FALSE, pool))
 924                 return (zfs_error(hdl, EZFS_INVALIDNAME, msg));
 925
 926         if (zcmd_write_conf_nvlist(hdl, &zc, nvroot) != 0)
 927                 return (-1);
 928
 929         if (props) {
 930                 prop_flags_t flags = { .create = B_TRUE, .import = B_FALSE };
 931
 932                 if ((zc_props = zpool_valid_proplist(hdl, pool, props,
 933                     SPA_VERSION_1, flags, msg)) == NULL) {
 934                         goto create_failed;
 935                 }
 936         }
 937
 938         if (fsprops) {
 939                 uint64_t zoned;
 940                 char *zonestr;
 941
 942                 zoned = ((nvlist_lookup_string(fsprops,
 943                     zfs_prop_to_name(ZFS_PROP_ZONED), &zonestr) == 0) &&
 944                     strcmp(zonestr, "on") == 0);
 945
 946                 if ((zc_fsprops = zfs_valid_proplist(hdl,
 947                     ZFS_TYPE_FILESYSTEM, fsprops, zoned, NULL, msg)) == NULL) {
 948                         goto create_failed;
 949                 }
 950                 if (!zc_props &&
 951                     (nvlist_alloc(&zc_props, NV_UNIQUE_NAME, 0) != 0)) {
 952                         goto create_failed;
 953                 }
 954                 if (nvlist_add_nvlist(zc_props,
 955                     ZPOOL_ROOTFS_PROPS, zc_fsprops) != 0) {
 956                         goto create_failed;
 957                 }
 958         }
 959
 960         if (zc_props && zcmd_write_src_nvlist(hdl, &zc, zc_props) != 0)
 961                 goto create_failed;
 962
 963         (void) strlcpy(zc.zc_name, pool, sizeof (zc.zc_name));
 964
 965         if ((ret = zfs_ioctl(hdl, ZFS_IOC_POOL_CREATE, &zc)) != 0) {
 966
 967                 zcmd_free_nvlists(&zc);
 968                 nvlist_free(zc_props);
 969                 nvlist_free(zc_fsprops);
 970
 971                 switch (errno) {
 972                 case EBUSY:
 973                         /*
 974                          * This can happen if the user has specified the same
 975                          * device multiple times.  We can't reliably detect this
 976                          * until we try to add it and see we already have a
 977                          * label.  This can also happen under if the device is
 978                          * part of an active md or lvm device.
 979                          */
 980                         zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 981                             "one or more vdevs refer to the same device, or one of\n"
 982                             "the devices is part of an active md or lvm device"));
 983                         return (zfs_error(hdl, EZFS_BADDEV, msg));
 984
 985                 case EOVERFLOW:
 986                         /*
 987                          * This occurs when one of the devices is below
 988                          * SPA_MINDEVSIZE.  Unfortunately, we can't detect which
 989                          * device was the problem device since there's no
 990                          * reliable way to determine device size from userland.
 991                          */
 992                         {
 993                                 char buf[64];
 994
 995                                 zfs_nicenum(SPA_MINDEVSIZE, buf, sizeof (buf));
 996
 997                                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
 998                                     "one or more devices is less than the "
 999                                     "minimum size (%s)"), buf);
1000                         }
1001                         return (zfs_error(hdl, EZFS_BADDEV, msg));
1002
1003                 case ENOSPC:
1004                         zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1005                             "one or more devices is out of space"));
1006                         return (zfs_error(hdl, EZFS_BADDEV, msg));
1007
1008                 case ENOTBLK:
1009                         zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1010                             "cache device must be a disk or disk slice"));
1011                         return (zfs_error(hdl, EZFS_BADDEV, msg));
1012
1013                 default:
1014                         return (zpool_standard_error(hdl, errno, msg));
1015                 }
1016         }
1017
1018         /*
1019          * If this is an alternate root pool, then we automatically set the
1020          * mountpoint of the root dataset to be '/'.
1021          */
1022         if (nvlist_lookup_string(props, zpool_prop_to_name(ZPOOL_PROP_ALTROOT),
1023             &altroot) == 0) {
1024                 zfs_handle_t *zhp;
1025
1026                 verify((zhp = zfs_open(hdl, pool, ZFS_TYPE_DATASET)) != NULL);
1027                 verify(zfs_prop_set(zhp, zfs_prop_to_name(ZFS_PROP_MOUNTPOINT),
1028                     "/") == 0);
1029
1030                 zfs_close(zhp);
1031         }
1032
1033 create_failed:
1034         zcmd_free_nvlists(&zc);
1035         nvlist_free(zc_props);
1036         nvlist_free(zc_fsprops);
1037         return (ret);
1038 }
1039
1040 /*
1041  * Destroy the given pool.  It is up to the caller to ensure that there are no
1042  * datasets left in the pool.
1043  */
1044 int
1045 zpool_destroy(zpool_handle_t *zhp)
1046 {
1047         zfs_cmd_t zc = { "\0", "\0", "\0", "\0", 0 };
1048         zfs_handle_t *zfp = NULL;
1049         libzfs_handle_t *hdl = zhp->zpool_hdl;
1050         char msg[1024];
1051
1052         if (zhp->zpool_state == POOL_STATE_ACTIVE &&
1053             (zfp = zfs_open(hdl, zhp->zpool_name, ZFS_TYPE_FILESYSTEM)) == NULL)
1054                 return (-1);
1055
1056         (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
1057
1058         if (zfs_ioctl(hdl, ZFS_IOC_POOL_DESTROY, &zc) != 0) {
1059                 (void) snprintf(msg, sizeof (msg), dgettext(TEXT_DOMAIN,
1060                     "cannot destroy '%s'"), zhp->zpool_name);
1061
1062                 if (errno == EROFS) {
1063                         zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1064                             "one or more devices is read only"));
1065                         (void) zfs_error(hdl, EZFS_BADDEV, msg);
1066                 } else {
1067                         (void) zpool_standard_error(hdl, errno, msg);
1068                 }
1069
1070                 if (zfp)
1071                         zfs_close(zfp);
1072                 return (-1);
1073         }
1074
1075         if (zfp) {
1076                 remove_mountpoint(zfp);
1077                 zfs_close(zfp);
1078         }
1079
1080         return (0);
1081 }
1082
1083 /*
1084  * Add the given vdevs to the pool.  The caller must have already performed the
1085  * necessary verification to ensure that the vdev specification is well-formed.
1086  */
1087 int
1088 zpool_add(zpool_handle_t *zhp, nvlist_t *nvroot)
1089 {
1090         zfs_cmd_t zc = { "\0", "\0", "\0", "\0", 0 };
1091         int ret;
1092         libzfs_handle_t *hdl = zhp->zpool_hdl;
1093         char msg[1024];
1094         nvlist_t **spares, **l2cache;
1095         uint_t nspares, nl2cache;
1096
1097         (void) snprintf(msg, sizeof (msg), dgettext(TEXT_DOMAIN,
1098             "cannot add to '%s'"), zhp->zpool_name);
1099
1100         if (zpool_get_prop_int(zhp, ZPOOL_PROP_VERSION, NULL) <
1101             SPA_VERSION_SPARES &&
1102             nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES,
1103             &spares, &nspares) == 0) {
1104                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "pool must be "
1105                     "upgraded to add hot spares"));
1106                 return (zfs_error(hdl, EZFS_BADVERSION, msg));
1107         }
1108
1109         if (pool_is_bootable(zhp) && nvlist_lookup_nvlist_array(nvroot,
1110             ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0) {
1111                 uint64_t s;
1112
1113                 for (s = 0; s < nspares; s++) {
1114                         char *path;
1115
1116                         if (nvlist_lookup_string(spares[s], ZPOOL_CONFIG_PATH,
1117                             &path) == 0 && pool_uses_efi(spares[s])) {
1118                                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1119                                     "device '%s' contains an EFI label and "
1120                                     "cannot be used on root pools."),
1121                                     zpool_vdev_name(hdl, NULL, spares[s],
1122                                     B_FALSE));
1123                                 return (zfs_error(hdl, EZFS_POOL_NOTSUP, msg));
1124                         }
1125                 }
1126         }
1127
1128         if (zpool_get_prop_int(zhp, ZPOOL_PROP_VERSION, NULL) <
1129             SPA_VERSION_L2CACHE &&
1130             nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE,
1131             &l2cache, &nl2cache) == 0) {
1132                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "pool must be "
1133                     "upgraded to add cache devices"));
1134                 return (zfs_error(hdl, EZFS_BADVERSION, msg));
1135         }
1136
1137         if (zcmd_write_conf_nvlist(hdl, &zc, nvroot) != 0)
1138                 return (-1);
1139         (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
1140
1141         if (zfs_ioctl(hdl, ZFS_IOC_VDEV_ADD, &zc) != 0) {
1142                 switch (errno) {
1143                 case EBUSY:
1144                         /*
1145                          * This can happen if the user has specified the same
1146                          * device multiple times.  We can't reliably detect this
1147                          * until we try to add it and see we already have a
1148                          * label.
1149                          */
1150                         zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1151                             "one or more vdevs refer to the same device"));
1152                         (void) zfs_error(hdl, EZFS_BADDEV, msg);
1153                         break;
1154
1155                 case EOVERFLOW:
1156                         /*
1157                          * This occurrs when one of the devices is below
1158                          * SPA_MINDEVSIZE.  Unfortunately, we can't detect which
1159                          * device was the problem device since there's no
1160                          * reliable way to determine device size from userland.
1161                          */
1162                         {
1163                                 char buf[64];
1164
1165                                 zfs_nicenum(SPA_MINDEVSIZE, buf, sizeof (buf));
1166
1167                                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1168                                     "device is less than the minimum "
1169                                     "size (%s)"), buf);
1170                         }
1171                         (void) zfs_error(hdl, EZFS_BADDEV, msg);
1172                         break;
1173
1174                 case ENOTSUP:
1175                         zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1176                             "pool must be upgraded to add these vdevs"));
1177                         (void) zfs_error(hdl, EZFS_BADVERSION, msg);
1178                         break;
1179
1180                 case EDOM:
1181                         zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1182                             "root pool can not have multiple vdevs"
1183                             " or separate logs"));
1184                         (void) zfs_error(hdl, EZFS_POOL_NOTSUP, msg);
1185                         break;
1186
1187                 case ENOTBLK:
1188                         zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1189                             "cache device must be a disk or disk slice"));
1190                         (void) zfs_error(hdl, EZFS_BADDEV, msg);
1191                         break;
1192
1193                 default:
1194                         (void) zpool_standard_error(hdl, errno, msg);
1195                 }
1196
1197                 ret = -1;
1198         } else {
1199                 ret = 0;
1200         }
1201
1202         zcmd_free_nvlists(&zc);
1203
1204         return (ret);
1205 }
1206
1207 /*
1208  * Exports the pool from the system.  The caller must ensure that there are no
1209  * mounted datasets in the pool.
1210  */
1211 int
1212 zpool_export_common(zpool_handle_t *zhp, boolean_t force, boolean_t hardforce)
1213 {
1214         zfs_cmd_t zc = { "\0", "\0", "\0", "\0", 0 };
1215         char msg[1024];
1216
1217         (void) snprintf(msg, sizeof (msg), dgettext(TEXT_DOMAIN,
1218             "cannot export '%s'"), zhp->zpool_name);
1219
1220         (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
1221         zc.zc_cookie = force;
1222         zc.zc_guid = hardforce;
1223
1224         if (zfs_ioctl(zhp->zpool_hdl, ZFS_IOC_POOL_EXPORT, &zc) != 0) {
1225                 switch (errno) {
1226                 case EXDEV:
1227                         zfs_error_aux(zhp->zpool_hdl, dgettext(TEXT_DOMAIN,
1228                             "use '-f' to override the following errors:\n"
1229                             "'%s' has an active shared spare which could be"
1230                             " used by other pools once '%s' is exported."),
1231                             zhp->zpool_name, zhp->zpool_name);
1232                         return (zfs_error(zhp->zpool_hdl, EZFS_ACTIVE_SPARE,
1233                             msg));
1234                 default:
1235                         return (zpool_standard_error_fmt(zhp->zpool_hdl, errno,
1236                             msg));
1237                 }
1238         }
1239
1240         return (0);
1241 }
1242
1243 int
1244 zpool_export(zpool_handle_t *zhp, boolean_t force)
1245 {
1246         return (zpool_export_common(zhp, force, B_FALSE));
1247 }
1248
1249 int
1250 zpool_export_force(zpool_handle_t *zhp)
1251 {
1252         return (zpool_export_common(zhp, B_TRUE, B_TRUE));
1253 }
1254
1255 static void
1256 zpool_rewind_exclaim(libzfs_handle_t *hdl, const char *name, boolean_t dryrun,
1257     nvlist_t *config)
1258 {
1259         nvlist_t *nv = NULL;
1260         uint64_t rewindto;
1261         int64_t loss = -1;
1262         struct tm t;
1263         char timestr[128];
1264
1265         if (!hdl->libzfs_printerr || config == NULL)
1266                 return;
1267
1268         if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_LOAD_INFO, &nv) != 0)
1269                 return;
1270
1271         if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_LOAD_TIME, &rewindto) != 0)
1272                 return;
1273         (void) nvlist_lookup_int64(nv, ZPOOL_CONFIG_REWIND_TIME, &loss);
1274
1275         if (localtime_r((time_t *)&rewindto, &t) != NULL &&
1276             strftime(timestr, 128, "%c", &t) != 0) {
1277                 if (dryrun) {
1278                         (void) printf(dgettext(TEXT_DOMAIN,
1279                             "Would be able to return %s "
1280                             "to its state as of %s.\n"),
1281                             name, timestr);
1282                 } else {
1283                         (void) printf(dgettext(TEXT_DOMAIN,
1284                             "Pool %s returned to its state as of %s.\n"),
1285                             name, timestr);
1286                 }
1287                 if (loss > 120) {
1288                         (void) printf(dgettext(TEXT_DOMAIN,
1289                             "%s approximately %lld "),
1290                             dryrun ? "Would discard" : "Discarded",
1291                             ((longlong_t)loss + 30) / 60);
1292                         (void) printf(dgettext(TEXT_DOMAIN,
1293                             "minutes of transactions.\n"));
1294                 } else if (loss > 0) {
1295                         (void) printf(dgettext(TEXT_DOMAIN,
1296                             "%s approximately %lld "),
1297                             dryrun ? "Would discard" : "Discarded",
1298                             (longlong_t)loss);
1299                         (void) printf(dgettext(TEXT_DOMAIN,
1300                             "seconds of transactions.\n"));
1301                 }
1302         }
1303 }
1304
1305 void
1306 zpool_explain_recover(libzfs_handle_t *hdl, const char *name, int reason,
1307     nvlist_t *config)
1308 {
1309         nvlist_t *nv = NULL;
1310         int64_t loss = -1;
1311         uint64_t edata = UINT64_MAX;
1312         uint64_t rewindto;
1313         struct tm t;
1314         char timestr[128];
1315
1316         if (!hdl->libzfs_printerr)
1317                 return;
1318
1319         if (reason >= 0)
1320                 (void) printf(dgettext(TEXT_DOMAIN, "action: "));
1321         else
1322                 (void) printf(dgettext(TEXT_DOMAIN, "\t"));
1323
1324         /* All attempted rewinds failed if ZPOOL_CONFIG_LOAD_TIME missing */
1325         if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_LOAD_INFO, &nv) != 0 ||
1326             nvlist_lookup_uint64(nv, ZPOOL_CONFIG_LOAD_TIME, &rewindto) != 0)
1327                 goto no_info;
1328
1329         (void) nvlist_lookup_int64(nv, ZPOOL_CONFIG_REWIND_TIME, &loss);
1330         (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_LOAD_DATA_ERRORS,
1331             &edata);
1332
1333         (void) printf(dgettext(TEXT_DOMAIN,
1334             "Recovery is possible, but will result in some data loss.\n"));
1335
1336         if (localtime_r((time_t *)&rewindto, &t) != NULL &&
1337             strftime(timestr, 128, "%c", &t) != 0) {
1338                 (void) printf(dgettext(TEXT_DOMAIN,
1339                     "\tReturning the pool to its state as of %s\n"
1340                     "\tshould correct the problem.  "),
1341                     timestr);
1342         } else {
1343                 (void) printf(dgettext(TEXT_DOMAIN,
1344                     "\tReverting the pool to an earlier state "
1345                     "should correct the problem.\n\t"));
1346         }
1347
1348         if (loss > 120) {
1349                 (void) printf(dgettext(TEXT_DOMAIN,
1350                     "Approximately %lld minutes of data\n"
1351                     "\tmust be discarded, irreversibly.  "),
1352                     ((longlong_t)loss + 30) / 60);
1353         } else if (loss > 0) {
1354                 (void) printf(dgettext(TEXT_DOMAIN,
1355                     "Approximately %lld seconds of data\n"
1356                     "\tmust be discarded, irreversibly.  "),
1357                     (longlong_t)loss);
1358         }
1359         if (edata != 0 && edata != UINT64_MAX) {
1360                 if (edata == 1) {
1361                         (void) printf(dgettext(TEXT_DOMAIN,
1362                             "After rewind, at least\n"
1363                             "\tone persistent user-data error will remain.  "));
1364                 } else {
1365                         (void) printf(dgettext(TEXT_DOMAIN,
1366                             "After rewind, several\n"
1367                             "\tpersistent user-data errors will remain.  "));
1368                 }
1369         }
1370         (void) printf(dgettext(TEXT_DOMAIN,
1371             "Recovery can be attempted\n\tby executing 'zpool %s -F %s'.  "),
1372             reason >= 0 ? "clear" : "import", name);
1373
1374         (void) printf(dgettext(TEXT_DOMAIN,
1375             "A scrub of the pool\n"
1376             "\tis strongly recommended after recovery.\n"));
1377         return;
1378
1379 no_info:
1380         (void) printf(dgettext(TEXT_DOMAIN,
1381             "Destroy and re-create the pool from\n\ta backup source.\n"));
1382 }
1383
1384 /*
1385  * zpool_import() is a contracted interface. Should be kept the same
1386  * if possible.
1387  *
1388  * Applications should use zpool_import_props() to import a pool with
1389  * new properties value to be set.
1390  */
1391 int
1392 zpool_import(libzfs_handle_t *hdl, nvlist_t *config, const char *newname,
1393     char *altroot)
1394 {
1395         nvlist_t *props = NULL;
1396         int ret;
1397
1398         if (altroot != NULL) {
1399                 if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0) {
1400                         return (zfs_error_fmt(hdl, EZFS_NOMEM,
1401                             dgettext(TEXT_DOMAIN, "cannot import '%s'"),
1402                             newname));
1403                 }
1404
1405                 if (nvlist_add_string(props,
1406                     zpool_prop_to_name(ZPOOL_PROP_ALTROOT), altroot) != 0 ||
1407                     nvlist_add_string(props,
1408                     zpool_prop_to_name(ZPOOL_PROP_CACHEFILE), "none") != 0) {
1409                         nvlist_free(props);
1410                         return (zfs_error_fmt(hdl, EZFS_NOMEM,
1411                             dgettext(TEXT_DOMAIN, "cannot import '%s'"),
1412                             newname));
1413                 }
1414         }
1415
1416         ret = zpool_import_props(hdl, config, newname, props,
1417             ZFS_IMPORT_NORMAL);
1418         if (props)
1419                 nvlist_free(props);
1420         return (ret);
1421 }
1422
1423 static void
1424 print_vdev_tree(libzfs_handle_t *hdl, const char *name, nvlist_t *nv,
1425     int indent)
1426 {
1427         nvlist_t **child;
1428         uint_t c, children;
1429         char *vname;
1430         uint64_t is_log = 0;
1431
1432         (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_IS_LOG,
1433             &is_log);
1434
1435         if (name != NULL)
1436                 (void) printf("\t%*s%s%s\n", indent, "", name,
1437                     is_log ? " [log]" : "");
1438
1439         if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
1440             &child, &children) != 0)
1441                 return;
1442
1443         for (c = 0; c < children; c++) {
1444                 vname = zpool_vdev_name(hdl, NULL, child[c], B_TRUE);
1445                 print_vdev_tree(hdl, vname, child[c], indent + 2);
1446                 free(vname);
1447         }
1448 }
1449
1450 /*
1451  * Import the given pool using the known configuration and a list of
1452  * properties to be set. The configuration should have come from
1453  * zpool_find_import(). The 'newname' parameters control whether the pool
1454  * is imported with a different name.
1455  */
1456 int
1457 zpool_import_props(libzfs_handle_t *hdl, nvlist_t *config, const char *newname,
1458     nvlist_t *props, int flags)
1459 {
1460         zfs_cmd_t zc = { "\0", "\0", "\0", "\0", 0 };
1461         zpool_rewind_policy_t policy;
1462         nvlist_t *nv = NULL;
1463         nvlist_t *nvinfo = NULL;
1464         nvlist_t *missing = NULL;
1465         char *thename;
1466         char *origname;
1467         int ret;
1468         int error = 0;
1469         char errbuf[1024];
1470
1471         verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME,
1472             &origname) == 0);
1473
1474         (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
1475             "cannot import pool '%s'"), origname);
1476
1477         if (newname != NULL) {
1478                 if (!zpool_name_valid(hdl, B_FALSE, newname))
1479                         return (zfs_error_fmt(hdl, EZFS_INVALIDNAME,
1480                             dgettext(TEXT_DOMAIN, "cannot import '%s'"),
1481                             newname));
1482                 thename = (char *)newname;
1483         } else {
1484                 thename = origname;
1485         }
1486
1487         if (props) {
1488                 uint64_t version;
1489                 prop_flags_t flags = { .create = B_FALSE, .import = B_TRUE };
1490
1491                 verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION,
1492                     &version) == 0);
1493
1494                 if ((props = zpool_valid_proplist(hdl, origname,
1495                     props, version, flags, errbuf)) == NULL) {
1496                         return (-1);
1497                 } else if (zcmd_write_src_nvlist(hdl, &zc, props) != 0) {
1498                         nvlist_free(props);
1499                         return (-1);
1500                 }
1501         }
1502
1503         (void) strlcpy(zc.zc_name, thename, sizeof (zc.zc_name));
1504
1505         verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID,
1506             &zc.zc_guid) == 0);
1507
1508         if (zcmd_write_conf_nvlist(hdl, &zc, config) != 0) {
1509                 nvlist_free(props);
1510                 return (-1);
1511         }
1512         if (zcmd_alloc_dst_nvlist(hdl, &zc, zc.zc_nvlist_conf_size * 2) != 0) {
1513                 nvlist_free(props);
1514                 return (-1);
1515         }
1516
1517         zc.zc_cookie = flags;
1518         while ((ret = zfs_ioctl(hdl, ZFS_IOC_POOL_IMPORT, &zc)) != 0 &&
1519             errno == ENOMEM) {
1520                 if (zcmd_expand_dst_nvlist(hdl, &zc) != 0) {
1521                         zcmd_free_nvlists(&zc);
1522                         return (-1);
1523                 }
1524         }
1525         if (ret != 0)
1526                 error = errno;
1527
1528         (void) zcmd_read_dst_nvlist(hdl, &zc, &nv);
1529         zpool_get_rewind_policy(config, &policy);
1530
1531         if (error) {
1532                 char desc[1024];
1533
1534                 /*
1535                  * Dry-run failed, but we print out what success
1536                  * looks like if we found a best txg
1537                  */
1538                 if (policy.zrp_request & ZPOOL_TRY_REWIND) {
1539                         zpool_rewind_exclaim(hdl, newname ? origname : thename,
1540                             B_TRUE, nv);
1541                         nvlist_free(nv);
1542                         return (-1);
1543                 }
1544
1545                 if (newname == NULL)
1546                         (void) snprintf(desc, sizeof (desc),
1547                             dgettext(TEXT_DOMAIN, "cannot import '%s'"),
1548                             thename);
1549                 else
1550                         (void) snprintf(desc, sizeof (desc),
1551                             dgettext(TEXT_DOMAIN, "cannot import '%s' as '%s'"),
1552                             origname, thename);
1553
1554                 switch (error) {
1555                 case ENOTSUP:
1556                         /*
1557                          * Unsupported version.
1558                          */
1559                         (void) zfs_error(hdl, EZFS_BADVERSION, desc);
1560                         break;
1561
1562                 case EINVAL:
1563                         (void) zfs_error(hdl, EZFS_INVALCONFIG, desc);
1564                         break;
1565
1566                 case EROFS:
1567                         zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1568                             "one or more devices is read only"));
1569                         (void) zfs_error(hdl, EZFS_BADDEV, desc);
1570                         break;
1571
1572                 case ENXIO:
1573                         if (nv && nvlist_lookup_nvlist(nv,
1574                             ZPOOL_CONFIG_LOAD_INFO, &nvinfo) == 0 &&
1575                             nvlist_lookup_nvlist(nvinfo,
1576                             ZPOOL_CONFIG_MISSING_DEVICES, &missing) == 0) {
1577                                 (void) printf(dgettext(TEXT_DOMAIN,
1578                                     "The devices below are missing, use "
1579                                     "'-m' to import the pool anyway:\n"));
1580                                 print_vdev_tree(hdl, NULL, missing, 2);
1581                                 (void) printf("\n");
1582                         }
1583                         (void) zpool_standard_error(hdl, error, desc);
1584                         break;
1585
1586                 case EEXIST:
1587                         (void) zpool_standard_error(hdl, error, desc);
1588                         break;
1589
1590                 case EBUSY:
1591                         zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1592                             "one or more devices are already in use\n"));
1593                         (void) zfs_error(hdl, EZFS_BADDEV, desc);
1594                         break;
1595
1596                 default:
1597                         (void) zpool_standard_error(hdl, error, desc);
1598                         zpool_explain_recover(hdl,
1599                             newname ? origname : thename, -error, nv);
1600                         break;
1601                 }
1602
1603                 nvlist_free(nv);
1604                 ret = -1;
1605         } else {
1606                 zpool_handle_t *zhp;
1607
1608                 /*
1609                  * This should never fail, but play it safe anyway.
1610                  */
1611                 if (zpool_open_silent(hdl, thename, &zhp) != 0)
1612                         ret = -1;
1613                 else if (zhp != NULL)
1614                         zpool_close(zhp);
1615                 if (policy.zrp_request &
1616                     (ZPOOL_DO_REWIND | ZPOOL_TRY_REWIND)) {
1617                         zpool_rewind_exclaim(hdl, newname ? origname : thename,
1618                             ((policy.zrp_request & ZPOOL_TRY_REWIND) != 0), nv);
1619                 }
1620                 nvlist_free(nv);
1621                 return (0);
1622         }
1623
1624         zcmd_free_nvlists(&zc);
1625         nvlist_free(props);
1626
1627         return (ret);
1628 }
1629
1630 /*
1631  * Scan the pool.
1632  */
1633 int
1634 zpool_scan(zpool_handle_t *zhp, pool_scan_func_t func)
1635 {
1636         zfs_cmd_t zc = { "\0", "\0", "\0", "\0", 0 };
1637         char msg[1024];
1638         libzfs_handle_t *hdl = zhp->zpool_hdl;
1639
1640         (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
1641         zc.zc_cookie = func;
1642
1643         if (zfs_ioctl(hdl, ZFS_IOC_POOL_SCAN, &zc) == 0 ||
1644             (errno == ENOENT && func != POOL_SCAN_NONE))
1645                 return (0);
1646
1647         if (func == POOL_SCAN_SCRUB) {
1648                 (void) snprintf(msg, sizeof (msg),
1649                     dgettext(TEXT_DOMAIN, "cannot scrub %s"), zc.zc_name);
1650         } else if (func == POOL_SCAN_NONE) {
1651                 (void) snprintf(msg, sizeof (msg),
1652                     dgettext(TEXT_DOMAIN, "cannot cancel scrubbing %s"),
1653                     zc.zc_name);
1654         } else {
1655                 assert(!"unexpected result");
1656         }
1657
1658         if (errno == EBUSY) {
1659                 nvlist_t *nvroot;
1660                 pool_scan_stat_t *ps = NULL;
1661                 uint_t psc;
1662
1663                 verify(nvlist_lookup_nvlist(zhp->zpool_config,
1664                     ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0);
1665                 (void) nvlist_lookup_uint64_array(nvroot,
1666                     ZPOOL_CONFIG_SCAN_STATS, (uint64_t **)&ps, &psc);
1667                 if (ps && ps->pss_func == POOL_SCAN_SCRUB)
1668                         return (zfs_error(hdl, EZFS_SCRUBBING, msg));
1669                 else
1670                         return (zfs_error(hdl, EZFS_RESILVERING, msg));
1671         } else if (errno == ENOENT) {
1672                 return (zfs_error(hdl, EZFS_NO_SCRUB, msg));
1673         } else {
1674                 return (zpool_standard_error(hdl, errno, msg));
1675         }
1676 }
1677
1678 /*
1679  * Find a vdev that matches the search criteria specified. We use the
1680  * the nvpair name to determine how we should look for the device.
1681  * 'avail_spare' is set to TRUE if the provided guid refers to an AVAIL
1682  * spare; but FALSE if its an INUSE spare.
1683  */
1684 static nvlist_t *
1685 vdev_to_nvlist_iter(nvlist_t *nv, nvlist_t *search, boolean_t *avail_spare,
1686     boolean_t *l2cache, boolean_t *log)
1687 {
1688         uint_t c, children;
1689         nvlist_t **child;
1690         nvlist_t *ret;
1691         uint64_t is_log;
1692         char *srchkey;
1693         nvpair_t *pair = nvlist_next_nvpair(search, NULL);
1694
1695         /* Nothing to look for */
1696         if (search == NULL || pair == NULL)
1697                 return (NULL);
1698
1699         /* Obtain the key we will use to search */
1700         srchkey = nvpair_name(pair);
1701
1702         switch (nvpair_type(pair)) {
1703         case DATA_TYPE_UINT64:
1704                 if (strcmp(srchkey, ZPOOL_CONFIG_GUID) == 0) {
1705                         uint64_t srchval, theguid;
1706
1707                         verify(nvpair_value_uint64(pair, &srchval) == 0);
1708                         verify(nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID,
1709                             &theguid) == 0);
1710                         if (theguid == srchval)
1711                                 return (nv);
1712                 }
1713                 break;
1714
1715         case DATA_TYPE_STRING: {
1716                 char *srchval, *val;
1717
1718                 verify(nvpair_value_string(pair, &srchval) == 0);
1719                 if (nvlist_lookup_string(nv, srchkey, &val) != 0)
1720                         break;
1721
1722                 /*
1723                  * Search for the requested value. Special cases:
1724                  *
1725                  * - ZPOOL_CONFIG_PATH for whole disk entries.  These end in with a
1726                  *   partition suffix "1", "-part1", or "p1".  The suffix is  hidden
1727                  *   from the user, but included in the string, so this matches around
1728                  *   it.
1729                  * - looking for a top-level vdev name (i.e. ZPOOL_CONFIG_TYPE).
1730                  *
1731                  * Otherwise, all other searches are simple string compares.
1732                  */
1733                 if (strcmp(srchkey, ZPOOL_CONFIG_PATH) == 0) {
1734                         uint64_t wholedisk = 0;
1735
1736                         (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_WHOLE_DISK,
1737                             &wholedisk);
1738                         if (wholedisk) {
1739                                 char buf[MAXPATHLEN];
1740
1741                                 zfs_append_partition(srchval, buf, sizeof (buf));
1742                                 if (strcmp(val, buf) == 0)
1743                                         return (nv);
1744
1745                                 break;
1746                         }
1747                 } else if (strcmp(srchkey, ZPOOL_CONFIG_TYPE) == 0 && val) {
1748                         char *type, *idx, *end, *p;
1749                         uint64_t id, vdev_id;
1750
1751                         /*
1752                          * Determine our vdev type, keeping in mind
1753                          * that the srchval is composed of a type and
1754                          * vdev id pair (i.e. mirror-4).
1755                          */
1756                         if ((type = strdup(srchval)) == NULL)
1757                                 return (NULL);
1758
1759                         if ((p = strrchr(type, '-')) == NULL) {
1760                                 free(type);
1761                                 break;
1762                         }
1763                         idx = p + 1;
1764                         *p = '\0';
1765
1766                         /*
1767                          * If the types don't match then keep looking.
1768                          */
1769                         if (strncmp(val, type, strlen(val)) != 0) {
1770                                 free(type);
1771                                 break;
1772                         }
1773
1774                         verify(strncmp(type, VDEV_TYPE_RAIDZ,
1775                             strlen(VDEV_TYPE_RAIDZ)) == 0 ||
1776                             strncmp(type, VDEV_TYPE_MIRROR,
1777                             strlen(VDEV_TYPE_MIRROR)) == 0);
1778                         verify(nvlist_lookup_uint64(nv, ZPOOL_CONFIG_ID,
1779                             &id) == 0);
1780
1781                         errno = 0;
1782                         vdev_id = strtoull(idx, &end, 10);
1783
1784                         free(type);
1785                         if (errno != 0)
1786                                 return (NULL);
1787
1788                         /*
1789                          * Now verify that we have the correct vdev id.
1790                          */
1791                         if (vdev_id == id)
1792                                 return (nv);
1793                 }
1794
1795                 /*
1796                  * Common case
1797                  */
1798                 if (strcmp(srchval, val) == 0)
1799                         return (nv);
1800                 break;
1801         }
1802
1803         default:
1804                 break;
1805         }
1806
1807         if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
1808             &child, &children) != 0)
1809                 return (NULL);
1810
1811         for (c = 0; c < children; c++) {
1812                 if ((ret = vdev_to_nvlist_iter(child[c], search,
1813                     avail_spare, l2cache, NULL)) != NULL) {
1814                         /*
1815                          * The 'is_log' value is only set for the toplevel
1816                          * vdev, not the leaf vdevs.  So we always lookup the
1817                          * log device from the root of the vdev tree (where
1818                          * 'log' is non-NULL).
1819                          */
1820                         if (log != NULL &&
1821                             nvlist_lookup_uint64(child[c],
1822                             ZPOOL_CONFIG_IS_LOG, &is_log) == 0 &&
1823                             is_log) {
1824                                 *log = B_TRUE;
1825                         }
1826                         return (ret);
1827                 }
1828         }
1829
1830         if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES,
1831             &child, &children) == 0) {
1832                 for (c = 0; c < children; c++) {
1833                         if ((ret = vdev_to_nvlist_iter(child[c], search,
1834                             avail_spare, l2cache, NULL)) != NULL) {
1835                                 *avail_spare = B_TRUE;
1836                                 return (ret);
1837                         }
1838                 }
1839         }
1840
1841         if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE,
1842             &child, &children) == 0) {
1843                 for (c = 0; c < children; c++) {
1844                         if ((ret = vdev_to_nvlist_iter(child[c], search,
1845                             avail_spare, l2cache, NULL)) != NULL) {
1846                                 *l2cache = B_TRUE;
1847                                 return (ret);
1848                         }
1849                 }
1850         }
1851
1852         return (NULL);
1853 }
1854
1855 /*
1856  * Given a physical path (minus the "/devices" prefix), find the
1857  * associated vdev.
1858  */
1859 nvlist_t *
1860 zpool_find_vdev_by_physpath(zpool_handle_t *zhp, const char *ppath,
1861     boolean_t *avail_spare, boolean_t *l2cache, boolean_t *log)
1862 {
1863         nvlist_t *search, *nvroot, *ret;
1864
1865         verify(nvlist_alloc(&search, NV_UNIQUE_NAME, KM_SLEEP) == 0);
1866         verify(nvlist_add_string(search, ZPOOL_CONFIG_PHYS_PATH, ppath) == 0);
1867
1868         verify(nvlist_lookup_nvlist(zhp->zpool_config, ZPOOL_CONFIG_VDEV_TREE,
1869             &nvroot) == 0);
1870
1871         *avail_spare = B_FALSE;
1872         *l2cache = B_FALSE;
1873         if (log != NULL)
1874                 *log = B_FALSE;
1875         ret = vdev_to_nvlist_iter(nvroot, search, avail_spare, l2cache, log);
1876         nvlist_free(search);
1877
1878         return (ret);
1879 }
1880
1881 /*
1882  * Determine if we have an "interior" top-level vdev (i.e mirror/raidz).
1883  */
1884 boolean_t
1885 zpool_vdev_is_interior(const char *name)
1886 {
1887         if (strncmp(name, VDEV_TYPE_RAIDZ, strlen(VDEV_TYPE_RAIDZ)) == 0 ||
1888             strncmp(name, VDEV_TYPE_MIRROR, strlen(VDEV_TYPE_MIRROR)) == 0)
1889                 return (B_TRUE);
1890         return (B_FALSE);
1891 }
1892
1893 nvlist_t *
1894 zpool_find_vdev(zpool_handle_t *zhp, const char *path, boolean_t *avail_spare,
1895     boolean_t *l2cache, boolean_t *log)
1896 {
1897         char buf[MAXPATHLEN];
1898         char *end;
1899         nvlist_t *nvroot, *search, *ret;
1900         uint64_t guid;
1901
1902         verify(nvlist_alloc(&search, NV_UNIQUE_NAME, KM_SLEEP) == 0);
1903
1904         guid = strtoull(path, &end, 10);
1905         if (guid != 0 && *end == '\0') {
1906                 verify(nvlist_add_uint64(search, ZPOOL_CONFIG_GUID, guid) == 0);
1907         } else if (zpool_vdev_is_interior(path)) {
1908                 verify(nvlist_add_string(search, ZPOOL_CONFIG_TYPE, path) == 0);
1909         } else if (path[0] != '/') {
1910                 if (zfs_resolve_shortname(path, buf, sizeof (buf)) < 0) {
1911                         nvlist_free(search);
1912                         return (NULL);
1913                 }
1914                 verify(nvlist_add_string(search, ZPOOL_CONFIG_PATH, buf) == 0);
1915         } else {
1916                 verify(nvlist_add_string(search, ZPOOL_CONFIG_PATH, path) == 0);
1917         }
1918
1919         verify(nvlist_lookup_nvlist(zhp->zpool_config, ZPOOL_CONFIG_VDEV_TREE,
1920             &nvroot) == 0);
1921
1922         *avail_spare = B_FALSE;
1923         *l2cache = B_FALSE;
1924         if (log != NULL)
1925                 *log = B_FALSE;
1926         ret = vdev_to_nvlist_iter(nvroot, search, avail_spare, l2cache, log);
1927         nvlist_free(search);
1928
1929         return (ret);
1930 }
1931
1932 static int
1933 vdev_online(nvlist_t *nv)
1934 {
1935         uint64_t ival;
1936
1937         if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_OFFLINE, &ival) == 0 ||
1938             nvlist_lookup_uint64(nv, ZPOOL_CONFIG_FAULTED, &ival) == 0 ||
1939             nvlist_lookup_uint64(nv, ZPOOL_CONFIG_REMOVED, &ival) == 0)
1940                 return (0);
1941
1942         return (1);
1943 }
1944
1945 /*
1946  * Helper function for zpool_get_physpaths().
1947  */
1948 static int
1949 vdev_get_one_physpath(nvlist_t *config, char *physpath, size_t physpath_size,
1950     size_t *bytes_written)
1951 {
1952         size_t bytes_left, pos, rsz;
1953         char *tmppath;
1954         const char *format;
1955
1956         if (nvlist_lookup_string(config, ZPOOL_CONFIG_PHYS_PATH,
1957             &tmppath) != 0)
1958                 return (EZFS_NODEVICE);
1959
1960         pos = *bytes_written;
1961         bytes_left = physpath_size - pos;
1962         format = (pos == 0) ? "%s" : " %s";
1963
1964         rsz = snprintf(physpath + pos, bytes_left, format, tmppath);
1965         *bytes_written += rsz;
1966
1967         if (rsz >= bytes_left) {
1968                 /* if physpath was not copied properly, clear it */
1969                 if (bytes_left != 0) {
1970                         physpath[pos] = 0;
1971                 }
1972                 return (EZFS_NOSPC);
1973         }
1974         return (0);
1975 }
1976
1977 static int
1978 vdev_get_physpaths(nvlist_t *nv, char *physpath, size_t phypath_size,
1979     size_t *rsz, boolean_t is_spare)
1980 {
1981         char *type;
1982         int ret;
1983
1984         if (nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) != 0)
1985                 return (EZFS_INVALCONFIG);
1986
1987         if (strcmp(type, VDEV_TYPE_DISK) == 0) {
1988                 /*
1989                  * An active spare device has ZPOOL_CONFIG_IS_SPARE set.
1990                  * For a spare vdev, we only want to boot from the active
1991                  * spare device.
1992                  */
1993                 if (is_spare) {
1994                         uint64_t spare = 0;
1995                         (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_IS_SPARE,
1996                             &spare);
1997                         if (!spare)
1998                                 return (EZFS_INVALCONFIG);
1999                 }
2000
2001                 if (vdev_online(nv)) {
2002                         if ((ret = vdev_get_one_physpath(nv, physpath,
2003                             phypath_size, rsz)) != 0)
2004                                 return (ret);
2005                 }
2006         } else if (strcmp(type, VDEV_TYPE_MIRROR) == 0 ||
2007             strcmp(type, VDEV_TYPE_REPLACING) == 0 ||
2008             (is_spare = (strcmp(type, VDEV_TYPE_SPARE) == 0))) {
2009                 nvlist_t **child;
2010                 uint_t count;
2011                 int i, ret;
2012
2013                 if (nvlist_lookup_nvlist_array(nv,
2014                     ZPOOL_CONFIG_CHILDREN, &child, &count) != 0)
2015                         return (EZFS_INVALCONFIG);
2016
2017                 for (i = 0; i < count; i++) {
2018                         ret = vdev_get_physpaths(child[i], physpath,
2019                             phypath_size, rsz, is_spare);
2020                         if (ret == EZFS_NOSPC)
2021                                 return (ret);
2022                 }
2023         }
2024
2025         return (EZFS_POOL_INVALARG);
2026 }
2027
2028 /*
2029  * Get phys_path for a root pool config.
2030  * Return 0 on success; non-zero on failure.
2031  */
2032 static int
2033 zpool_get_config_physpath(nvlist_t *config, char *physpath, size_t phypath_size)
2034 {
2035         size_t rsz;
2036         nvlist_t *vdev_root;
2037         nvlist_t **child;
2038         uint_t count;
2039         char *type;
2040
2041         rsz = 0;
2042
2043         if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
2044             &vdev_root) != 0)
2045                 return (EZFS_INVALCONFIG);
2046
2047         if (nvlist_lookup_string(vdev_root, ZPOOL_CONFIG_TYPE, &type) != 0 ||
2048             nvlist_lookup_nvlist_array(vdev_root, ZPOOL_CONFIG_CHILDREN,
2049             &child, &count) != 0)
2050                 return (EZFS_INVALCONFIG);
2051
2052         /*
2053          * root pool can not have EFI labeled disks and can only have
2054          * a single top-level vdev.
2055          */
2056         if (strcmp(type, VDEV_TYPE_ROOT) != 0 || count != 1 ||
2057             pool_uses_efi(vdev_root))
2058                 return (EZFS_POOL_INVALARG);
2059
2060         (void) vdev_get_physpaths(child[0], physpath, phypath_size, &rsz,
2061             B_FALSE);
2062
2063         /* No online devices */
2064         if (rsz == 0)
2065                 return (EZFS_NODEVICE);
2066
2067         return (0);
2068 }
2069
2070 /*
2071  * Get phys_path for a root pool
2072  * Return 0 on success; non-zero on failure.
2073  */
2074 int
2075 zpool_get_physpath(zpool_handle_t *zhp, char *physpath, size_t phypath_size)
2076 {
2077         return (zpool_get_config_physpath(zhp->zpool_config, physpath,
2078             phypath_size));
2079 }
2080
2081 /*
2082  * If the device has being dynamically expanded then we need to relabel
2083  * the disk to use the new unallocated space.
2084  */
2085 static int
2086 zpool_relabel_disk(libzfs_handle_t *hdl, const char *path, const char *msg)
2087 {
2088         int fd, error;
2089
2090         if ((fd = open(path, O_RDWR|O_DIRECT)) < 0) {
2091                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "cannot "
2092                     "relabel '%s': unable to open device: %d"), path, errno);
2093                 return (zfs_error(hdl, EZFS_OPENFAILED, msg));
2094         }
2095
2096         /*
2097          * It's possible that we might encounter an error if the device
2098          * does not have any unallocated space left. If so, we simply
2099          * ignore that error and continue on.
2100          *
2101          * Also, we don't call efi_rescan() - that would just return EBUSY.
2102          * The module will do it for us in vdev_disk_open().
2103          */
2104         error = efi_use_whole_disk(fd);
2105         (void) close(fd);
2106         if (error && error != VT_ENOSPC) {
2107                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "cannot "
2108                     "relabel '%s': unable to read disk capacity"), path);
2109                 return (zfs_error(hdl, EZFS_NOCAP, msg));
2110         }
2111         return (0);
2112 }
2113
2114 /*
2115  * Bring the specified vdev online.   The 'flags' parameter is a set of the
2116  * ZFS_ONLINE_* flags.
2117  */
2118 int
2119 zpool_vdev_online(zpool_handle_t *zhp, const char *path, int flags,
2120     vdev_state_t *newstate)
2121 {
2122         zfs_cmd_t zc = { "\0", "\0", "\0", "\0", 0 };
2123         char msg[1024];
2124         nvlist_t *tgt;
2125         boolean_t avail_spare, l2cache, islog;
2126         libzfs_handle_t *hdl = zhp->zpool_hdl;
2127         int error;
2128
2129         if (flags & ZFS_ONLINE_EXPAND) {
2130                 (void) snprintf(msg, sizeof (msg),
2131                     dgettext(TEXT_DOMAIN, "cannot expand %s"), path);
2132         } else {
2133                 (void) snprintf(msg, sizeof (msg),
2134                     dgettext(TEXT_DOMAIN, "cannot online %s"), path);
2135         }
2136
2137         (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
2138         if ((tgt = zpool_find_vdev(zhp, path, &avail_spare, &l2cache,
2139             &islog)) == NULL)
2140                 return (zfs_error(hdl, EZFS_NODEVICE, msg));
2141
2142         verify(nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID, &zc.zc_guid) == 0);
2143
2144         if (avail_spare)
2145                 return (zfs_error(hdl, EZFS_ISSPARE, msg));
2146
2147         if (flags & ZFS_ONLINE_EXPAND ||
2148             zpool_get_prop_int(zhp, ZPOOL_PROP_AUTOEXPAND, NULL)) {
2149                 uint64_t wholedisk = 0;
2150
2151                 (void) nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_WHOLE_DISK,
2152                     &wholedisk);
2153
2154                 /*
2155                  * XXX - L2ARC 1.0 devices can't support expansion.
2156                  */
2157                 if (l2cache) {
2158                         zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2159                             "cannot expand cache devices"));
2160                         return (zfs_error(hdl, EZFS_VDEVNOTSUP, msg));
2161                 }
2162
2163                 if (wholedisk) {
2164                         const char *fullpath = path;
2165                         char buf[MAXPATHLEN];
2166
2167                         if (path[0] != '/') {
2168                                 error = zfs_resolve_shortname(path, buf,
2169                                     sizeof(buf));
2170                                 if (error != 0)
2171                                         return (zfs_error(hdl, EZFS_NODEVICE,
2172                                             msg));
2173
2174                                 fullpath = buf;
2175                         }
2176
2177                         error = zpool_relabel_disk(hdl, fullpath, msg);
2178                         if (error != 0)
2179                                 return (error);
2180                 }
2181         }
2182
2183         zc.zc_cookie = VDEV_STATE_ONLINE;
2184         zc.zc_obj = flags;
2185
2186         if (zfs_ioctl(hdl, ZFS_IOC_VDEV_SET_STATE, &zc) != 0) {
2187                 if (errno == EINVAL) {
2188                         zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "was split "
2189                             "from this pool into a new one.  Use '%s' "
2190                             "instead"), "zpool detach");
2191                         return (zfs_error(hdl, EZFS_POSTSPLIT_ONLINE, msg));
2192                 }
2193                 return (zpool_standard_error(hdl, errno, msg));
2194         }
2195
2196         *newstate = zc.zc_cookie;
2197         return (0);
2198 }
2199
2200 /*
2201  * Take the specified vdev offline
2202  */
2203 int
2204 zpool_vdev_offline(zpool_handle_t *zhp, const char *path, boolean_t istmp)
2205 {
2206         zfs_cmd_t zc = { "\0", "\0", "\0", "\0", 0 };
2207         char msg[1024];
2208         nvlist_t *tgt;
2209         boolean_t avail_spare, l2cache;
2210         libzfs_handle_t *hdl = zhp->zpool_hdl;
2211
2212         (void) snprintf(msg, sizeof (msg),
2213             dgettext(TEXT_DOMAIN, "cannot offline %s"), path);
2214
2215         (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
2216         if ((tgt = zpool_find_vdev(zhp, path, &avail_spare, &l2cache,
2217             NULL)) == NULL)
2218                 return (zfs_error(hdl, EZFS_NODEVICE, msg));
2219
2220         verify(nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID, &zc.zc_guid) == 0);
2221
2222         if (avail_spare)
2223                 return (zfs_error(hdl, EZFS_ISSPARE, msg));
2224
2225         zc.zc_cookie = VDEV_STATE_OFFLINE;
2226         zc.zc_obj = istmp ? ZFS_OFFLINE_TEMPORARY : 0;
2227
2228         if (zfs_ioctl(hdl, ZFS_IOC_VDEV_SET_STATE, &zc) == 0)
2229                 return (0);
2230
2231         switch (errno) {
2232         case EBUSY:
2233
2234                 /*
2235                  * There are no other replicas of this device.
2236                  */
2237                 return (zfs_error(hdl, EZFS_NOREPLICAS, msg));
2238
2239         case EEXIST:
2240                 /*
2241                  * The log device has unplayed logs
2242                  */
2243                 return (zfs_error(hdl, EZFS_UNPLAYED_LOGS, msg));
2244
2245         default:
2246                 return (zpool_standard_error(hdl, errno, msg));
2247         }
2248 }
2249
2250 /*
2251  * Mark the given vdev faulted.
2252  */
2253 int
2254 zpool_vdev_fault(zpool_handle_t *zhp, uint64_t guid, vdev_aux_t aux)
2255 {
2256         zfs_cmd_t zc = { "\0", "\0", "\0", "\0", 0 };
2257         char msg[1024];
2258         libzfs_handle_t *hdl = zhp->zpool_hdl;
2259
2260         (void) snprintf(msg, sizeof (msg),
2261            dgettext(TEXT_DOMAIN, "cannot fault %llu"), (u_longlong_t)guid);
2262
2263         (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
2264         zc.zc_guid = guid;
2265         zc.zc_cookie = VDEV_STATE_FAULTED;
2266         zc.zc_obj = aux;
2267
2268         if (ioctl(hdl->libzfs_fd, ZFS_IOC_VDEV_SET_STATE, &zc) == 0)
2269                 return (0);
2270
2271         switch (errno) {
2272         case EBUSY:
2273
2274                 /*
2275                  * There are no other replicas of this device.
2276                  */
2277                 return (zfs_error(hdl, EZFS_NOREPLICAS, msg));
2278
2279         default:
2280                 return (zpool_standard_error(hdl, errno, msg));
2281         }
2282
2283 }
2284
2285 /*
2286  * Mark the given vdev degraded.
2287  */
2288 int
2289 zpool_vdev_degrade(zpool_handle_t *zhp, uint64_t guid, vdev_aux_t aux)
2290 {
2291         zfs_cmd_t zc = { "\0", "\0", "\0", "\0", 0 };
2292         char msg[1024];
2293         libzfs_handle_t *hdl = zhp->zpool_hdl;
2294
2295         (void) snprintf(msg, sizeof (msg),
2296            dgettext(TEXT_DOMAIN, "cannot degrade %llu"), (u_longlong_t)guid);
2297
2298         (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
2299         zc.zc_guid = guid;
2300         zc.zc_cookie = VDEV_STATE_DEGRADED;
2301         zc.zc_obj = aux;
2302
2303         if (ioctl(hdl->libzfs_fd, ZFS_IOC_VDEV_SET_STATE, &zc) == 0)
2304                 return (0);
2305
2306         return (zpool_standard_error(hdl, errno, msg));
2307 }
2308
2309 /*
2310  * Returns TRUE if the given nvlist is a vdev that was originally swapped in as
2311  * a hot spare.
2312  */
2313 static boolean_t
2314 is_replacing_spare(nvlist_t *search, nvlist_t *tgt, int which)
2315 {
2316         nvlist_t **child;
2317         uint_t c, children;
2318         char *type;
2319
2320         if (nvlist_lookup_nvlist_array(search, ZPOOL_CONFIG_CHILDREN, &child,
2321             &children) == 0) {
2322                 verify(nvlist_lookup_string(search, ZPOOL_CONFIG_TYPE,
2323                     &type) == 0);
2324
2325                 if (strcmp(type, VDEV_TYPE_SPARE) == 0 &&
2326                     children == 2 && child[which] == tgt)
2327                         return (B_TRUE);
2328
2329                 for (c = 0; c < children; c++)
2330                         if (is_replacing_spare(child[c], tgt, which))
2331                                 return (B_TRUE);
2332         }
2333
2334         return (B_FALSE);
2335 }
2336
2337 /*
2338  * Attach new_disk (fully described by nvroot) to old_disk.
2339  * If 'replacing' is specified, the new disk will replace the old one.
2340  */
2341 int
2342 zpool_vdev_attach(zpool_handle_t *zhp,
2343     const char *old_disk, const char *new_disk, nvlist_t *nvroot, int replacing)
2344 {
2345         zfs_cmd_t zc = { "\0", "\0", "\0", "\0", 0 };
2346         char msg[1024];
2347         int ret;
2348         nvlist_t *tgt;
2349         boolean_t avail_spare, l2cache, islog;
2350         uint64_t val;
2351         char *newname;
2352         nvlist_t **child;
2353         uint_t children;
2354         nvlist_t *config_root;
2355         libzfs_handle_t *hdl = zhp->zpool_hdl;
2356         boolean_t rootpool = pool_is_bootable(zhp);
2357
2358         if (replacing)
2359                 (void) snprintf(msg, sizeof (msg), dgettext(TEXT_DOMAIN,
2360                     "cannot replace %s with %s"), old_disk, new_disk);
2361         else
2362                 (void) snprintf(msg, sizeof (msg), dgettext(TEXT_DOMAIN,
2363                     "cannot attach %s to %s"), new_disk, old_disk);
2364
2365         /*
2366          * If this is a root pool, make sure that we're not attaching an
2367          * EFI labeled device.
2368          */
2369         if (rootpool && pool_uses_efi(nvroot)) {
2370                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2371                     "EFI labeled devices are not supported on root pools."));
2372                 return (zfs_error(hdl, EZFS_POOL_NOTSUP, msg));
2373         }
2374
2375         (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
2376         if ((tgt = zpool_find_vdev(zhp, old_disk, &avail_spare, &l2cache,
2377             &islog)) == 0)
2378                 return (zfs_error(hdl, EZFS_NODEVICE, msg));
2379
2380         if (avail_spare)
2381                 return (zfs_error(hdl, EZFS_ISSPARE, msg));
2382
2383         if (l2cache)
2384                 return (zfs_error(hdl, EZFS_ISL2CACHE, msg));
2385
2386         verify(nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID, &zc.zc_guid) == 0);
2387         zc.zc_cookie = replacing;
2388
2389         if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN,
2390             &child, &children) != 0 || children != 1) {
2391                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2392                     "new device must be a single disk"));
2393                 return (zfs_error(hdl, EZFS_INVALCONFIG, msg));
2394         }
2395
2396         verify(nvlist_lookup_nvlist(zpool_get_config(zhp, NULL),
2397             ZPOOL_CONFIG_VDEV_TREE, &config_root) == 0);
2398
2399         if ((newname = zpool_vdev_name(NULL, NULL, child[0], B_FALSE)) == NULL)
2400                 return (-1);
2401
2402         /*
2403          * If the target is a hot spare that has been swapped in, we can only
2404          * replace it with another hot spare.
2405          */
2406         if (replacing &&
2407             nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_IS_SPARE, &val) == 0 &&
2408             (zpool_find_vdev(zhp, newname, &avail_spare, &l2cache,
2409             NULL) == NULL || !avail_spare) &&
2410             is_replacing_spare(config_root, tgt, 1)) {
2411                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2412                     "can only be replaced by another hot spare"));
2413                 free(newname);
2414                 return (zfs_error(hdl, EZFS_BADTARGET, msg));
2415         }
2416
2417         free(newname);
2418
2419         if (zcmd_write_conf_nvlist(hdl, &zc, nvroot) != 0)
2420                 return (-1);
2421
2422         ret = zfs_ioctl(hdl, ZFS_IOC_VDEV_ATTACH, &zc);
2423
2424         zcmd_free_nvlists(&zc);
2425
2426         if (ret == 0) {
2427                 if (rootpool) {
2428                         /*
2429                          * XXX need a better way to prevent user from
2430                          * booting up a half-baked vdev.
2431                          */
2432                         (void) fprintf(stderr, dgettext(TEXT_DOMAIN, "Make "
2433                             "sure to wait until resilver is done "
2434                             "before rebooting.\n"));
2435                 }
2436                 return (0);
2437         }
2438
2439         switch (errno) {
2440         case ENOTSUP:
2441                 /*
2442                  * Can't attach to or replace this type of vdev.
2443                  */
2444                 if (replacing) {
2445                         uint64_t version = zpool_get_prop_int(zhp,
2446                             ZPOOL_PROP_VERSION, NULL);
2447
2448                         if (islog)
2449                                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2450                                     "cannot replace a log with a spare"));
2451                         else if (version >= SPA_VERSION_MULTI_REPLACE)
2452                                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2453                                     "already in replacing/spare config; wait "
2454                                     "for completion or use 'zpool detach'"));
2455                         else
2456                                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2457                                     "cannot replace a replacing device"));
2458                 } else {
2459                         zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2460                             "can only attach to mirrors and top-level "
2461                             "disks"));
2462                 }
2463                 (void) zfs_error(hdl, EZFS_BADTARGET, msg);
2464                 break;
2465
2466         case EINVAL:
2467                 /*
2468                  * The new device must be a single disk.
2469                  */
2470                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2471                     "new device must be a single disk"));
2472                 (void) zfs_error(hdl, EZFS_INVALCONFIG, msg);
2473                 break;
2474
2475         case EBUSY:
2476                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "%s is busy"),
2477                     new_disk);
2478                 (void) zfs_error(hdl, EZFS_BADDEV, msg);
2479                 break;
2480
2481         case EOVERFLOW:
2482                 /*
2483                  * The new device is too small.
2484                  */
2485                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2486                     "device is too small"));
2487                 (void) zfs_error(hdl, EZFS_BADDEV, msg);
2488                 break;
2489
2490         case EDOM:
2491                 /*
2492                  * The new device has a different alignment requirement.
2493                  */
2494                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2495                     "devices have different sector alignment"));
2496                 (void) zfs_error(hdl, EZFS_BADDEV, msg);
2497                 break;
2498
2499         case ENAMETOOLONG:
2500                 /*
2501                  * The resulting top-level vdev spec won't fit in the label.
2502                  */
2503                 (void) zfs_error(hdl, EZFS_DEVOVERFLOW, msg);
2504                 break;
2505
2506         default:
2507                 (void) zpool_standard_error(hdl, errno, msg);
2508         }
2509
2510         return (-1);
2511 }
2512
2513 /*
2514  * Detach the specified device.
2515  */
2516 int
2517 zpool_vdev_detach(zpool_handle_t *zhp, const char *path)
2518 {
2519         zfs_cmd_t zc = { "\0", "\0", "\0", "\0", 0 };
2520         char msg[1024];
2521         nvlist_t *tgt;
2522         boolean_t avail_spare, l2cache;
2523         libzfs_handle_t *hdl = zhp->zpool_hdl;
2524
2525         (void) snprintf(msg, sizeof (msg),
2526             dgettext(TEXT_DOMAIN, "cannot detach %s"), path);
2527
2528         (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
2529         if ((tgt = zpool_find_vdev(zhp, path, &avail_spare, &l2cache,
2530             NULL)) == 0)
2531                 return (zfs_error(hdl, EZFS_NODEVICE, msg));
2532
2533         if (avail_spare)
2534                 return (zfs_error(hdl, EZFS_ISSPARE, msg));
2535
2536         if (l2cache)
2537                 return (zfs_error(hdl, EZFS_ISL2CACHE, msg));
2538
2539         verify(nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID, &zc.zc_guid) == 0);
2540
2541         if (zfs_ioctl(hdl, ZFS_IOC_VDEV_DETACH, &zc) == 0)
2542                 return (0);
2543
2544         switch (errno) {
2545
2546         case ENOTSUP:
2547                 /*
2548                  * Can't detach from this type of vdev.
2549                  */
2550                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "only "
2551                     "applicable to mirror and replacing vdevs"));
2552                 (void) zfs_error(hdl, EZFS_BADTARGET, msg);
2553                 break;
2554
2555         case EBUSY:
2556                 /*
2557                  * There are no other replicas of this device.
2558                  */
2559                 (void) zfs_error(hdl, EZFS_NOREPLICAS, msg);
2560                 break;
2561
2562         default:
2563                 (void) zpool_standard_error(hdl, errno, msg);
2564         }
2565
2566         return (-1);
2567 }
2568
2569 /*
2570  * Find a mirror vdev in the source nvlist.
2571  *
2572  * The mchild array contains a list of disks in one of the top-level mirrors
2573  * of the source pool.  The schild array contains a list of disks that the
2574  * user specified on the command line.  We loop over the mchild array to
2575  * see if any entry in the schild array matches.
2576  *
2577  * If a disk in the mchild array is found in the schild array, we return
2578  * the index of that entry.  Otherwise we return -1.
2579  */
2580 static int
2581 find_vdev_entry(zpool_handle_t *zhp, nvlist_t **mchild, uint_t mchildren,
2582     nvlist_t **schild, uint_t schildren)
2583 {
2584         uint_t mc;
2585
2586         for (mc = 0; mc < mchildren; mc++) {
2587                 uint_t sc;
2588                 char *mpath = zpool_vdev_name(zhp->zpool_hdl, zhp,
2589                     mchild[mc], B_FALSE);
2590
2591                 for (sc = 0; sc < schildren; sc++) {
2592                         char *spath = zpool_vdev_name(zhp->zpool_hdl, zhp,
2593                             schild[sc], B_FALSE);
2594                         boolean_t result = (strcmp(mpath, spath) == 0);
2595
2596                         free(spath);
2597                         if (result) {
2598                                 free(mpath);
2599                                 return (mc);
2600                         }
2601                 }
2602
2603                 free(mpath);
2604         }
2605
2606         return (-1);
2607 }
2608
2609 /*
2610  * Split a mirror pool.  If newroot points to null, then a new nvlist
2611  * is generated and it is the responsibility of the caller to free it.
2612  */
2613 int
2614 zpool_vdev_split(zpool_handle_t *zhp, char *newname, nvlist_t **newroot,
2615     nvlist_t *props, splitflags_t flags)
2616 {
2617         zfs_cmd_t zc = { "\0", "\0", "\0", "\0", 0 };
2618         char msg[1024];
2619         nvlist_t *tree, *config, **child, **newchild, *newconfig = NULL;
2620         nvlist_t **varray = NULL, *zc_props = NULL;
2621         uint_t c, children, newchildren, lastlog = 0, vcount, found = 0;
2622         libzfs_handle_t *hdl = zhp->zpool_hdl;
2623         uint64_t vers;
2624         boolean_t freelist = B_FALSE, memory_err = B_TRUE;
2625         int retval = 0;
2626
2627         (void) snprintf(msg, sizeof (msg),
2628             dgettext(TEXT_DOMAIN, "Unable to split %s"), zhp->zpool_name);
2629
2630         if (!zpool_name_valid(hdl, B_FALSE, newname))
2631                 return (zfs_error(hdl, EZFS_INVALIDNAME, msg));
2632
2633         if ((config = zpool_get_config(zhp, NULL)) == NULL) {
2634                 (void) fprintf(stderr, gettext("Internal error: unable to "
2635                     "retrieve pool configuration\n"));
2636                 return (-1);
2637         }
2638
2639         verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &tree)
2640             == 0);
2641         verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION, &vers) == 0);
2642
2643         if (props) {
2644                 prop_flags_t flags = { .create = B_FALSE, .import = B_TRUE };
2645                 if ((zc_props = zpool_valid_proplist(hdl, zhp->zpool_name,
2646                     props, vers, flags, msg)) == NULL)
2647                         return (-1);
2648         }
2649
2650         if (nvlist_lookup_nvlist_array(tree, ZPOOL_CONFIG_CHILDREN, &child,
2651             &children) != 0) {
2652                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2653                     "Source pool is missing vdev tree"));
2654                 if (zc_props)
2655                         nvlist_free(zc_props);
2656                 return (-1);
2657         }
2658
2659         varray = zfs_alloc(hdl, children * sizeof (nvlist_t *));
2660         vcount = 0;
2661
2662         if (*newroot == NULL ||
2663             nvlist_lookup_nvlist_array(*newroot, ZPOOL_CONFIG_CHILDREN,
2664             &newchild, &newchildren) != 0)
2665                 newchildren = 0;
2666
2667         for (c = 0; c < children; c++) {
2668                 uint64_t is_log = B_FALSE, is_hole = B_FALSE;
2669                 char *type;
2670                 nvlist_t **mchild, *vdev;
2671                 uint_t mchildren;
2672                 int entry;
2673
2674                 /*
2675                  * Unlike cache & spares, slogs are stored in the
2676                  * ZPOOL_CONFIG_CHILDREN array.  We filter them out here.
2677                  */
2678                 (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG,
2679                     &is_log);
2680                 (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_HOLE,
2681                     &is_hole);
2682                 if (is_log || is_hole) {
2683                         /*
2684                          * Create a hole vdev and put it in the config.
2685                          */
2686                         if (nvlist_alloc(&vdev, NV_UNIQUE_NAME, 0) != 0)
2687                                 goto out;
2688                         if (nvlist_add_string(vdev, ZPOOL_CONFIG_TYPE,
2689                             VDEV_TYPE_HOLE) != 0)
2690                                 goto out;
2691                         if (nvlist_add_uint64(vdev, ZPOOL_CONFIG_IS_HOLE,
2692                             1) != 0)
2693                                 goto out;
2694                         if (lastlog == 0)
2695                                 lastlog = vcount;
2696                         varray[vcount++] = vdev;
2697                         continue;
2698                 }
2699                 lastlog = 0;
2700                 verify(nvlist_lookup_string(child[c], ZPOOL_CONFIG_TYPE, &type)
2701                     == 0);
2702                 if (strcmp(type, VDEV_TYPE_MIRROR) != 0) {
2703                         zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2704                             "Source pool must be composed only of mirrors\n"));
2705                         retval = zfs_error(hdl, EZFS_INVALCONFIG, msg);
2706                         goto out;
2707                 }
2708
2709                 verify(nvlist_lookup_nvlist_array(child[c],
2710                     ZPOOL_CONFIG_CHILDREN, &mchild, &mchildren) == 0);
2711
2712                 /* find or add an entry for this top-level vdev */
2713                 if (newchildren > 0 &&
2714                     (entry = find_vdev_entry(zhp, mchild, mchildren,
2715                     newchild, newchildren)) >= 0) {
2716                         /* We found a disk that the user specified. */
2717                         vdev = mchild[entry];
2718                         ++found;
2719                 } else {
2720                         /* User didn't specify a disk for this vdev. */
2721                         vdev = mchild[mchildren - 1];
2722                 }
2723
2724                 if (nvlist_dup(vdev, &varray[vcount++], 0) != 0)
2725                         goto out;
2726         }
2727
2728         /* did we find every disk the user specified? */
2729         if (found != newchildren) {
2730                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "Device list must "
2731                     "include at most one disk from each mirror"));
2732                 retval = zfs_error(hdl, EZFS_INVALCONFIG, msg);
2733                 goto out;
2734         }
2735
2736         /* Prepare the nvlist for populating. */
2737         if (*newroot == NULL) {
2738                 if (nvlist_alloc(newroot, NV_UNIQUE_NAME, 0) != 0)
2739                         goto out;
2740                 freelist = B_TRUE;
2741                 if (nvlist_add_string(*newroot, ZPOOL_CONFIG_TYPE,
2742                     VDEV_TYPE_ROOT) != 0)
2743                         goto out;
2744         } else {
2745                 verify(nvlist_remove_all(*newroot, ZPOOL_CONFIG_CHILDREN) == 0);
2746         }
2747
2748         /* Add all the children we found */
2749         if (nvlist_add_nvlist_array(*newroot, ZPOOL_CONFIG_CHILDREN, varray,
2750             lastlog == 0 ? vcount : lastlog) != 0)
2751                 goto out;
2752
2753         /*
2754          * If we're just doing a dry run, exit now with success.
2755          */
2756         if (flags.dryrun) {
2757                 memory_err = B_FALSE;
2758                 freelist = B_FALSE;
2759                 goto out;
2760         }
2761
2762         /* now build up the config list & call the ioctl */
2763         if (nvlist_alloc(&newconfig, NV_UNIQUE_NAME, 0) != 0)
2764                 goto out;
2765
2766         if (nvlist_add_nvlist(newconfig,
2767             ZPOOL_CONFIG_VDEV_TREE, *newroot) != 0 ||
2768             nvlist_add_string(newconfig,
2769             ZPOOL_CONFIG_POOL_NAME, newname) != 0 ||
2770             nvlist_add_uint64(newconfig, ZPOOL_CONFIG_VERSION, vers) != 0)
2771                 goto out;
2772
2773         /*
2774          * The new pool is automatically part of the namespace unless we
2775          * explicitly export it.
2776          */
2777         if (!flags.import)
2778                 zc.zc_cookie = ZPOOL_EXPORT_AFTER_SPLIT;
2779         (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
2780         (void) strlcpy(zc.zc_string, newname, sizeof (zc.zc_string));
2781         if (zcmd_write_conf_nvlist(hdl, &zc, newconfig) != 0)
2782                 goto out;
2783         if (zc_props != NULL && zcmd_write_src_nvlist(hdl, &zc, zc_props) != 0)
2784                 goto out;
2785
2786         if (zfs_ioctl(hdl, ZFS_IOC_VDEV_SPLIT, &zc) != 0) {
2787                 retval = zpool_standard_error(hdl, errno, msg);
2788                 goto out;
2789         }
2790
2791         freelist = B_FALSE;
2792         memory_err = B_FALSE;
2793
2794 out:
2795         if (varray != NULL) {
2796                 int v;
2797
2798                 for (v = 0; v < vcount; v++)
2799                         nvlist_free(varray[v]);
2800                 free(varray);
2801         }
2802         zcmd_free_nvlists(&zc);
2803         if (zc_props)
2804                 nvlist_free(zc_props);
2805         if (newconfig)
2806                 nvlist_free(newconfig);
2807         if (freelist) {
2808                 nvlist_free(*newroot);
2809                 *newroot = NULL;
2810         }
2811
2812         if (retval != 0)
2813                 return (retval);
2814
2815         if (memory_err)
2816                 return (no_memory(hdl));
2817
2818         return (0);
2819 }
2820
2821 /*
2822  * Remove the given device.  Currently, this is supported only for hot spares
2823  * and level 2 cache devices.
2824  */
2825 int
2826 zpool_vdev_remove(zpool_handle_t *zhp, const char *path)
2827 {
2828         zfs_cmd_t zc = { "\0", "\0", "\0", "\0", 0 };
2829         char msg[1024];
2830         nvlist_t *tgt;
2831         boolean_t avail_spare, l2cache, islog;
2832         libzfs_handle_t *hdl = zhp->zpool_hdl;
2833         uint64_t version;
2834
2835         (void) snprintf(msg, sizeof (msg),
2836             dgettext(TEXT_DOMAIN, "cannot remove %s"), path);
2837
2838         (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
2839         if ((tgt = zpool_find_vdev(zhp, path, &avail_spare, &l2cache,
2840             &islog)) == 0)
2841                 return (zfs_error(hdl, EZFS_NODEVICE, msg));
2842         /*
2843          * XXX - this should just go away.
2844          */
2845         if (!avail_spare && !l2cache && !islog) {
2846                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2847                     "only inactive hot spares, cache, top-level, "
2848                     "or log devices can be removed"));
2849                 return (zfs_error(hdl, EZFS_NODEVICE, msg));
2850         }
2851
2852         version = zpool_get_prop_int(zhp, ZPOOL_PROP_VERSION, NULL);
2853         if (islog && version < SPA_VERSION_HOLES) {
2854                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2855                     "pool must be upgrade to support log removal"));
2856                 return (zfs_error(hdl, EZFS_BADVERSION, msg));
2857         }
2858
2859         verify(nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID, &zc.zc_guid) == 0);
2860
2861         if (zfs_ioctl(hdl, ZFS_IOC_VDEV_REMOVE, &zc) == 0)
2862                 return (0);
2863
2864         return (zpool_standard_error(hdl, errno, msg));
2865 }
2866
2867 /*
2868  * Clear the errors for the pool, or the particular device if specified.
2869  */
2870 int
2871 zpool_clear(zpool_handle_t *zhp, const char *path, nvlist_t *rewindnvl)
2872 {
2873         zfs_cmd_t zc = { "\0", "\0", "\0", "\0", 0 };
2874         char msg[1024];
2875         nvlist_t *tgt;
2876         zpool_rewind_policy_t policy;
2877         boolean_t avail_spare, l2cache;
2878         libzfs_handle_t *hdl = zhp->zpool_hdl;
2879         nvlist_t *nvi = NULL;
2880         int error;
2881
2882         if (path)
2883                 (void) snprintf(msg, sizeof (msg),
2884                     dgettext(TEXT_DOMAIN, "cannot clear errors for %s"),
2885                     path);
2886         else
2887                 (void) snprintf(msg, sizeof (msg),
2888                     dgettext(TEXT_DOMAIN, "cannot clear errors for %s"),
2889                     zhp->zpool_name);
2890
2891         (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
2892         if (path) {
2893                 if ((tgt = zpool_find_vdev(zhp, path, &avail_spare,
2894                     &l2cache, NULL)) == 0)
2895                         return (zfs_error(hdl, EZFS_NODEVICE, msg));
2896
2897                 /*
2898                  * Don't allow error clearing for hot spares.  Do allow
2899                  * error clearing for l2cache devices.
2900                  */
2901                 if (avail_spare)
2902                         return (zfs_error(hdl, EZFS_ISSPARE, msg));
2903
2904                 verify(nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID,
2905                     &zc.zc_guid) == 0);
2906         }
2907
2908         zpool_get_rewind_policy(rewindnvl, &policy);
2909         zc.zc_cookie = policy.zrp_request;
2910
2911         if (zcmd_alloc_dst_nvlist(hdl, &zc, zhp->zpool_config_size * 2) != 0)
2912                 return (-1);
2913
2914         if (zcmd_write_src_nvlist(hdl, &zc, rewindnvl) != 0)
2915                 return (-1);
2916
2917         while ((error = zfs_ioctl(hdl, ZFS_IOC_CLEAR, &zc)) != 0 &&
2918             errno == ENOMEM) {
2919                 if (zcmd_expand_dst_nvlist(hdl, &zc) != 0) {
2920                         zcmd_free_nvlists(&zc);
2921                         return (-1);
2922                 }
2923         }
2924
2925         if (!error || ((policy.zrp_request & ZPOOL_TRY_REWIND) &&
2926             errno != EPERM && errno != EACCES)) {
2927                 if (policy.zrp_request &
2928                     (ZPOOL_DO_REWIND | ZPOOL_TRY_REWIND)) {
2929                         (void) zcmd_read_dst_nvlist(hdl, &zc, &nvi);
2930                         zpool_rewind_exclaim(hdl, zc.zc_name,
2931                             ((policy.zrp_request & ZPOOL_TRY_REWIND) != 0),
2932                             nvi);
2933                         nvlist_free(nvi);
2934                 }
2935                 zcmd_free_nvlists(&zc);
2936                 return (0);
2937         }
2938
2939         zcmd_free_nvlists(&zc);
2940         return (zpool_standard_error(hdl, errno, msg));
2941 }
2942
2943 /*
2944  * Similar to zpool_clear(), but takes a GUID (used by fmd).
2945  */
2946 int
2947 zpool_vdev_clear(zpool_handle_t *zhp, uint64_t guid)
2948 {
2949         zfs_cmd_t zc = { "\0", "\0", "\0", "\0", 0 };
2950         char msg[1024];
2951         libzfs_handle_t *hdl = zhp->zpool_hdl;
2952
2953         (void) snprintf(msg, sizeof (msg),
2954             dgettext(TEXT_DOMAIN, "cannot clear errors for %llx"),
2955            (u_longlong_t)guid);
2956
2957         (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
2958         zc.zc_guid = guid;
2959         zc.zc_cookie = ZPOOL_NO_REWIND;
2960
2961         if (ioctl(hdl->libzfs_fd, ZFS_IOC_CLEAR, &zc) == 0)
2962                 return (0);
2963
2964         return (zpool_standard_error(hdl, errno, msg));
2965 }
2966
2967 /*
2968  * Change the GUID for a pool.
2969  */
2970 int
2971 zpool_reguid(zpool_handle_t *zhp)
2972 {
2973         char msg[1024];
2974         libzfs_handle_t *hdl = zhp->zpool_hdl;
2975         zfs_cmd_t zc = { "\0", "\0", "\0", "\0", 0 };
2976
2977         (void) snprintf(msg, sizeof (msg),
2978             dgettext(TEXT_DOMAIN, "cannot reguid '%s'"), zhp->zpool_name);
2979
2980         (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
2981         if (zfs_ioctl(hdl, ZFS_IOC_POOL_REGUID, &zc) == 0)
2982                 return (0);
2983
2984         return (zpool_standard_error(hdl, errno, msg));
2985 }
2986
2987 /*
2988  * Convert from a devid string to a path.
2989  */
2990 static char *
2991 devid_to_path(char *devid_str)
2992 {
2993         ddi_devid_t devid;
2994         char *minor;
2995         char *path;
2996         devid_nmlist_t *list = NULL;
2997         int ret;
2998
2999         if (devid_str_decode(devid_str, &devid, &minor) != 0)
3000                 return (NULL);
3001
3002         ret = devid_deviceid_to_nmlist("/dev", devid, minor, &list);
3003
3004         devid_str_free(minor);
3005         devid_free(devid);
3006
3007         if (ret != 0)
3008                 return (NULL);
3009
3010         if ((path = strdup(list[0].devname)) == NULL)
3011                 return (NULL);
3012
3013         devid_free_nmlist(list);
3014
3015         return (path);
3016 }
3017
3018 /*
3019  * Convert from a path to a devid string.
3020  */
3021 static char *
3022 path_to_devid(const char *path)
3023 {
3024         int fd;
3025         ddi_devid_t devid;
3026         char *minor, *ret;
3027
3028         if ((fd = open(path, O_RDONLY)) < 0)
3029                 return (NULL);
3030
3031         minor = NULL;
3032         ret = NULL;
3033         if (devid_get(fd, &devid) == 0) {
3034                 if (devid_get_minor_name(fd, &minor) == 0)
3035                         ret = devid_str_encode(devid, minor);
3036                 if (minor != NULL)
3037                         devid_str_free(minor);
3038                 devid_free(devid);
3039         }
3040         (void) close(fd);
3041
3042         return (ret);
3043 }
3044
3045 /*
3046  * Issue the necessary ioctl() to update the stored path value for the vdev.  We
3047  * ignore any failure here, since a common case is for an unprivileged user to
3048  * type 'zpool status', and we'll display the correct information anyway.
3049  */
3050 static void
3051 set_path(zpool_handle_t *zhp, nvlist_t *nv, const char *path)
3052 {
3053         zfs_cmd_t zc = { "\0", "\0", "\0", "\0", 0 };
3054
3055         (void) strncpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
3056         (void) strncpy(zc.zc_value, path, sizeof (zc.zc_value));
3057         verify(nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID,
3058             &zc.zc_guid) == 0);
3059
3060         (void) ioctl(zhp->zpool_hdl->libzfs_fd, ZFS_IOC_VDEV_SETPATH, &zc);
3061 }
3062
3063 /*
3064  * Remove partition suffix from a vdev path.  Partition suffixes may take three
3065  * forms: "-partX", "pX", or "X", where X is a string of digits.  The second
3066  * case only occurs when the suffix is preceded by a digit, i.e. "md0p0" The
3067  * third case only occurs when preceded by a string matching the regular
3068  * expression "^[hs]d[a-z]+", i.e. a scsi or ide disk.
3069  */
3070 static char *
3071 strip_partition(libzfs_handle_t *hdl, char *path)
3072 {
3073         char *tmp = zfs_strdup(hdl, path);
3074         char *part = NULL, *d = NULL;
3075
3076         if ((part = strstr(tmp, "-part")) && part != tmp) {
3077                 d = part + 5;
3078         } else if ((part = strrchr(tmp, 'p')) &&
3079             part > tmp + 1 && isdigit(*(part-1))) {
3080                 d = part + 1;
3081         } else if ((tmp[0] == 'h' || tmp[0] == 's') && tmp[1] == 'd') {
3082                 for (d = &tmp[2]; isalpha(*d); part = ++d);
3083         }
3084         if (part && d && *d != '\0') {
3085                 for (; isdigit(*d); d++);
3086                 if (*d == '\0')
3087                         *part = '\0';
3088         }
3089         return (tmp);
3090 }
3091
3092 #define PATH_BUF_LEN    64
3093
3094 /*
3095  * Given a vdev, return the name to display in iostat.  If the vdev has a path,
3096  * we use that, stripping off any leading "/dev/dsk/"; if not, we use the type.
3097  * We also check if this is a whole disk, in which case we strip off the
3098  * trailing 's0' slice name.
3099  *
3100  * This routine is also responsible for identifying when disks have been
3101  * reconfigured in a new location.  The kernel will have opened the device by
3102  * devid, but the path will still refer to the old location.  To catch this, we
3103  * first do a path -> devid translation (which is fast for the common case).  If
3104  * the devid matches, we're done.  If not, we do a reverse devid -> path
3105  * translation and issue the appropriate ioctl() to update the path of the vdev.
3106  * If 'zhp' is NULL, then this is an exported pool, and we don't need to do any
3107  * of these checks.
3108  */
3109 char *
3110 zpool_vdev_name(libzfs_handle_t *hdl, zpool_handle_t *zhp, nvlist_t *nv,
3111     boolean_t verbose)
3112 {
3113         char *path, *devid, *type;
3114         uint64_t value;
3115         char buf[PATH_BUF_LEN];
3116         vdev_stat_t *vs;
3117         uint_t vsc;
3118
3119         if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NOT_PRESENT,
3120             &value) == 0) {
3121                 verify(nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID,
3122                     &value) == 0);
3123                 (void) snprintf(buf, sizeof (buf), "%llu",
3124                     (u_longlong_t)value);
3125                 path = buf;
3126         } else if (nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) == 0) {
3127                 /*
3128                  * If the device is dead (faulted, offline, etc) then don't
3129                  * bother opening it.  Otherwise we may be forcing the user to
3130                  * open a misbehaving device, which can have undesirable
3131                  * effects.
3132                  */
3133                 if ((nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_VDEV_STATS,
3134                     (uint64_t **)&vs, &vsc) != 0 ||
3135                     vs->vs_state >= VDEV_STATE_DEGRADED) &&
3136                     zhp != NULL &&
3137                     nvlist_lookup_string(nv, ZPOOL_CONFIG_DEVID, &devid) == 0) {
3138                         /*
3139                          * Determine if the current path is correct.
3140                          */
3141                         char *newdevid = path_to_devid(path);
3142
3143                         if (newdevid == NULL ||
3144                             strcmp(devid, newdevid) != 0) {
3145                                 char *newpath;
3146
3147                                 if ((newpath = devid_to_path(devid)) != NULL) {
3148                                         /*
3149                                          * Update the path appropriately.
3150                                          */
3151                                         set_path(zhp, nv, newpath);
3152                                         if (nvlist_add_string(nv,
3153                                             ZPOOL_CONFIG_PATH, newpath) == 0)
3154                                                 verify(nvlist_lookup_string(nv,
3155                                                     ZPOOL_CONFIG_PATH,
3156                                                     &path) == 0);
3157                                         free(newpath);
3158                                 }
3159                         }
3160
3161                         if (newdevid)
3162                                 devid_str_free(newdevid);
3163                 }
3164
3165                 /*
3166                  * For a block device only use the name.
3167                  */
3168                 verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) == 0);
3169                 if (strcmp(type, VDEV_TYPE_DISK) == 0) {
3170                         path = strrchr(path, '/');
3171                         path++;
3172                 }
3173
3174                 /*
3175                  * Remove the partition from the path it this is a whole disk.
3176                  */
3177                 if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_WHOLE_DISK,
3178                     &value) == 0 && value) {
3179                         return strip_partition(hdl, path);
3180                 }
3181         } else {
3182                 verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &path) == 0);
3183
3184                 /*
3185                  * If it's a raidz device, we need to stick in the parity level.
3186                  */
3187                 if (strcmp(path, VDEV_TYPE_RAIDZ) == 0) {
3188                         char tmpbuf[PATH_BUF_LEN];
3189
3190                         verify(nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NPARITY,
3191                             &value) == 0);
3192                         (void) snprintf(tmpbuf, sizeof (tmpbuf), "%s%llu", path,
3193                             (u_longlong_t)value);
3194                         path = tmpbuf;
3195                 }
3196
3197                 /*
3198                  * We identify each top-level vdev by using a <type-id>
3199                  * naming convention.
3200                  */
3201                 if (verbose) {
3202                         uint64_t id;
3203
3204                         verify(nvlist_lookup_uint64(nv, ZPOOL_CONFIG_ID,
3205                             &id) == 0);
3206                         (void) snprintf(buf, sizeof (buf), "%s-%llu", path,
3207                             (u_longlong_t)id);
3208                         path = buf;
3209                 }
3210         }
3211
3212         return (zfs_strdup(hdl, path));
3213 }
3214
3215 static int
3216 zbookmark_compare(const void *a, const void *b)
3217 {
3218         return (memcmp(a, b, sizeof (zbookmark_t)));
3219 }
3220
3221 /*
3222  * Retrieve the persistent error log, uniquify the members, and return to the
3223  * caller.
3224  */
3225 int
3226 zpool_get_errlog(zpool_handle_t *zhp, nvlist_t **nverrlistp)
3227 {
3228         zfs_cmd_t zc = { "\0", "\0", "\0", "\0", 0 };
3229         uint64_t count;
3230         zbookmark_t *zb = NULL;
3231         int i;
3232
3233         /*
3234          * Retrieve the raw error list from the kernel.  If the number of errors
3235          * has increased, allocate more space and continue until we get the
3236          * entire list.
3237          */
3238         verify(nvlist_lookup_uint64(zhp->zpool_config, ZPOOL_CONFIG_ERRCOUNT,
3239             &count) == 0);
3240         if (count == 0)
3241                 return (0);
3242         if ((zc.zc_nvlist_dst = (uintptr_t)zfs_alloc(zhp->zpool_hdl,
3243             count * sizeof (zbookmark_t))) == (uintptr_t)NULL)
3244                 return (-1);
3245         zc.zc_nvlist_dst_size = count;
3246         (void) strcpy(zc.zc_name, zhp->zpool_name);
3247         for (;;) {
3248                 if (ioctl(zhp->zpool_hdl->libzfs_fd, ZFS_IOC_ERROR_LOG,
3249                     &zc) != 0) {
3250                         free((void *)(uintptr_t)zc.zc_nvlist_dst);
3251                         if (errno == ENOMEM) {
3252                                 count = zc.zc_nvlist_dst_size;
3253                                 if ((zc.zc_nvlist_dst = (uintptr_t)
3254                                     zfs_alloc(zhp->zpool_hdl, count *
3255                                     sizeof (zbookmark_t))) == (uintptr_t)NULL)
3256                                         return (-1);
3257                         } else {
3258                                 return (-1);
3259                         }
3260                 } else {
3261                         break;
3262                 }
3263         }
3264
3265         /*
3266          * Sort the resulting bookmarks.  This is a little confusing due to the
3267          * implementation of ZFS_IOC_ERROR_LOG.  The bookmarks are copied last
3268          * to first, and 'zc_nvlist_dst_size' indicates the number of boomarks
3269          * _not_ copied as part of the process.  So we point the start of our
3270          * array appropriate and decrement the total number of elements.
3271          */
3272         zb = ((zbookmark_t *)(uintptr_t)zc.zc_nvlist_dst) +
3273             zc.zc_nvlist_dst_size;
3274         count -= zc.zc_nvlist_dst_size;
3275
3276         qsort(zb, count, sizeof (zbookmark_t), zbookmark_compare);
3277
3278         verify(nvlist_alloc(nverrlistp, 0, KM_SLEEP) == 0);
3279
3280         /*
3281          * Fill in the nverrlistp with nvlist's of dataset and object numbers.
3282          */
3283         for (i = 0; i < count; i++) {
3284                 nvlist_t *nv;
3285
3286                 /* ignoring zb_blkid and zb_level for now */
3287                 if (i > 0 && zb[i-1].zb_objset == zb[i].zb_objset &&
3288                     zb[i-1].zb_object == zb[i].zb_object)
3289                         continue;
3290
3291                 if (nvlist_alloc(&nv, NV_UNIQUE_NAME, KM_SLEEP) != 0)
3292                         goto nomem;
3293                 if (nvlist_add_uint64(nv, ZPOOL_ERR_DATASET,
3294                     zb[i].zb_objset) != 0) {
3295                         nvlist_free(nv);
3296                         goto nomem;
3297                 }
3298                 if (nvlist_add_uint64(nv, ZPOOL_ERR_OBJECT,
3299                     zb[i].zb_object) != 0) {
3300                         nvlist_free(nv);
3301                         goto nomem;
3302                 }
3303                 if (nvlist_add_nvlist(*nverrlistp, "ejk", nv) != 0) {
3304                         nvlist_free(nv);
3305                         goto nomem;
3306                 }
3307                 nvlist_free(nv);
3308         }
3309
3310         free((void *)(uintptr_t)zc.zc_nvlist_dst);
3311         return (0);
3312
3313 nomem:
3314         free((void *)(uintptr_t)zc.zc_nvlist_dst);
3315         return (no_memory(zhp->zpool_hdl));
3316 }
3317
3318 /*
3319  * Upgrade a ZFS pool to the latest on-disk version.
3320  */
3321 int
3322 zpool_upgrade(zpool_handle_t *zhp, uint64_t new_version)
3323 {
3324         zfs_cmd_t zc = { "\0", "\0", "\0", "\0", 0 };
3325         libzfs_handle_t *hdl = zhp->zpool_hdl;
3326
3327         (void) strcpy(zc.zc_name, zhp->zpool_name);
3328         zc.zc_cookie = new_version;
3329
3330         if (zfs_ioctl(hdl, ZFS_IOC_POOL_UPGRADE, &zc) != 0)
3331                 return (zpool_standard_error_fmt(hdl, errno,
3332                     dgettext(TEXT_DOMAIN, "cannot upgrade '%s'"),
3333                     zhp->zpool_name));
3334         return (0);
3335 }
3336
3337 void
3338 zpool_set_history_str(const char *subcommand, int argc, char **argv,
3339     char *history_str)
3340 {
3341         int i;
3342
3343         (void) strlcpy(history_str, subcommand, HIS_MAX_RECORD_LEN);
3344         for (i = 1; i < argc; i++) {
3345                 if (strlen(history_str) + 1 + strlen(argv[i]) >
3346                     HIS_MAX_RECORD_LEN)
3347                         break;
3348                 (void) strlcat(history_str, " ", HIS_MAX_RECORD_LEN);
3349                 (void) strlcat(history_str, argv[i], HIS_MAX_RECORD_LEN);
3350         }
3351 }
3352
3353 /*
3354  * Stage command history for logging.
3355  */
3356 int
3357 zpool_stage_history(libzfs_handle_t *hdl, const char *history_str)
3358 {
3359         if (history_str == NULL)
3360                 return (EINVAL);
3361
3362         if (strlen(history_str) > HIS_MAX_RECORD_LEN)
3363                 return (EINVAL);
3364
3365         if (hdl->libzfs_log_str != NULL)
3366                 free(hdl->libzfs_log_str);
3367
3368         if ((hdl->libzfs_log_str = strdup(history_str)) == NULL)
3369                 return (no_memory(hdl));
3370
3371         return (0);
3372 }
3373
3374 /*
3375  * Perform ioctl to get some command history of a pool.
3376  *
3377  * 'buf' is the buffer to fill up to 'len' bytes.  'off' is the
3378  * logical offset of the history buffer to start reading from.
3379  *
3380  * Upon return, 'off' is the next logical offset to read from and
3381  * 'len' is the actual amount of bytes read into 'buf'.
3382  */
3383 static int
3384 get_history(zpool_handle_t *zhp, char *buf, uint64_t *off, uint64_t *len)
3385 {
3386         zfs_cmd_t zc = { "\0", "\0", "\0", "\0", 0 };
3387         libzfs_handle_t *hdl = zhp->zpool_hdl;
3388
3389         (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
3390
3391         zc.zc_history = (uint64_t)(uintptr_t)buf;
3392         zc.zc_history_len = *len;
3393         zc.zc_history_offset = *off;
3394
3395         if (ioctl(hdl->libzfs_fd, ZFS_IOC_POOL_GET_HISTORY, &zc) != 0) {
3396                 switch (errno) {
3397                 case EPERM:
3398                         return (zfs_error_fmt(hdl, EZFS_PERM,
3399                             dgettext(TEXT_DOMAIN,
3400                             "cannot show history for pool '%s'"),
3401                             zhp->zpool_name));
3402                 case ENOENT:
3403                         return (zfs_error_fmt(hdl, EZFS_NOHISTORY,
3404                             dgettext(TEXT_DOMAIN, "cannot get history for pool "
3405                             "'%s'"), zhp->zpool_name));
3406                 case ENOTSUP:
3407                         return (zfs_error_fmt(hdl, EZFS_BADVERSION,
3408                             dgettext(TEXT_DOMAIN, "cannot get history for pool "
3409                             "'%s', pool must be upgraded"), zhp->zpool_name));
3410                 default:
3411                         return (zpool_standard_error_fmt(hdl, errno,
3412                             dgettext(TEXT_DOMAIN,
3413                             "cannot get history for '%s'"), zhp->zpool_name));
3414                 }
3415         }
3416
3417         *len = zc.zc_history_len;
3418         *off = zc.zc_history_offset;
3419
3420         return (0);
3421 }
3422
3423 /*
3424  * Process the buffer of nvlists, unpacking and storing each nvlist record
3425  * into 'records'.  'leftover' is set to the number of bytes that weren't
3426  * processed as there wasn't a complete record.
3427  */
3428 int
3429 zpool_history_unpack(char *buf, uint64_t bytes_read, uint64_t *leftover,
3430     nvlist_t ***records, uint_t *numrecords)
3431 {
3432         uint64_t reclen;
3433         nvlist_t *nv;
3434         int i;
3435
3436         while (bytes_read > sizeof (reclen)) {
3437
3438                 /* get length of packed record (stored as little endian) */
3439                 for (i = 0, reclen = 0; i < sizeof (reclen); i++)
3440                         reclen += (uint64_t)(((uchar_t *)buf)[i]) << (8*i);
3441
3442                 if (bytes_read < sizeof (reclen) + reclen)
3443                         break;
3444
3445                 /* unpack record */
3446                 if (nvlist_unpack(buf + sizeof (reclen), reclen, &nv, 0) != 0)
3447                         return (ENOMEM);
3448                 bytes_read -= sizeof (reclen) + reclen;
3449                 buf += sizeof (reclen) + reclen;
3450
3451                 /* add record to nvlist array */
3452                 (*numrecords)++;
3453                 if (ISP2(*numrecords + 1)) {
3454                         *records = realloc(*records,
3455                             *numrecords * 2 * sizeof (nvlist_t *));
3456                 }
3457                 (*records)[*numrecords - 1] = nv;
3458         }
3459
3460         *leftover = bytes_read;
3461         return (0);
3462 }
3463
3464 #define HIS_BUF_LEN     (128*1024)
3465
3466 /*
3467  * Retrieve the command history of a pool.
3468  */
3469 int
3470 zpool_get_history(zpool_handle_t *zhp, nvlist_t **nvhisp)
3471 {
3472         char buf[HIS_BUF_LEN];
3473         uint64_t off = 0;
3474         nvlist_t **records = NULL;
3475         uint_t numrecords = 0;
3476         int err, i;
3477
3478         do {
3479                 uint64_t bytes_read = sizeof (buf);
3480                 uint64_t leftover;
3481
3482                 if ((err = get_history(zhp, buf, &off, &bytes_read)) != 0)
3483                         break;
3484
3485                 /* if nothing else was read in, we're at EOF, just return */
3486                 if (!bytes_read)
3487                         break;
3488
3489                 if ((err = zpool_history_unpack(buf, bytes_read,
3490                     &leftover, &records, &numrecords)) != 0)
3491                         break;
3492                 off -= leftover;
3493
3494                 /* CONSTCOND */
3495         } while (1);
3496
3497         if (!err) {
3498                 verify(nvlist_alloc(nvhisp, NV_UNIQUE_NAME, 0) == 0);
3499                 verify(nvlist_add_nvlist_array(*nvhisp, ZPOOL_HIST_RECORD,
3500                     records, numrecords) == 0);
3501         }
3502         for (i = 0; i < numrecords; i++)
3503                 nvlist_free(records[i]);
3504         free(records);
3505
3506         return (err);
3507 }
3508
3509 /*
3510  * Retrieve the next event.  If there is a new event available 'nvp' will
3511  * contain a newly allocated nvlist and 'dropped' will be set to the number
3512  * of missed events since the last call to this function.  When 'nvp' is
3513  * set to NULL it indicates no new events are available.  In either case
3514  * the function returns 0 and it is up to the caller to free 'nvp'.  In
3515  * the case of a fatal error the function will return a non-zero value.
3516  * When the function is called in blocking mode it will not return until
3517  * a new event is available.
3518  */
3519 int
3520 zpool_events_next(libzfs_handle_t *hdl, nvlist_t **nvp,
3521     int *dropped, int block, int cleanup_fd)
3522 {
3523         zfs_cmd_t zc = { "\0", "\0", "\0", "\0", 0 };
3524         int error = 0;
3525
3526         *nvp = NULL;
3527         *dropped = 0;
3528         zc.zc_cleanup_fd = cleanup_fd;
3529
3530         if (!block)
3531                 zc.zc_guid = ZEVENT_NONBLOCK;
3532
3533         if (zcmd_alloc_dst_nvlist(hdl, &zc, ZEVENT_SIZE) != 0)
3534                 return (-1);
3535
3536 retry:
3537         if (zfs_ioctl(hdl, ZFS_IOC_EVENTS_NEXT, &zc) != 0) {
3538                 switch (errno) {
3539                 case ESHUTDOWN:
3540                         error = zfs_error_fmt(hdl, EZFS_POOLUNAVAIL,
3541                             dgettext(TEXT_DOMAIN, "zfs shutdown"));
3542                         goto out;
3543                 case ENOENT:
3544                         /* Blocking error case should not occur */
3545                         if (block)
3546                                 error = zpool_standard_error_fmt(hdl, errno,
3547                                     dgettext(TEXT_DOMAIN, "cannot get event"));
3548
3549                         goto out;
3550                 case ENOMEM:
3551                         if (zcmd_expand_dst_nvlist(hdl, &zc) != 0) {
3552                                 error = zfs_error_fmt(hdl, EZFS_NOMEM,
3553                                     dgettext(TEXT_DOMAIN, "cannot get event"));
3554                                 goto out;
3555                         } else {
3556                                 goto retry;
3557                         }
3558                 default:
3559                         error = zpool_standard_error_fmt(hdl, errno,
3560                             dgettext(TEXT_DOMAIN, "cannot get event"));
3561                         goto out;
3562                 }
3563         }
3564
3565         error = zcmd_read_dst_nvlist(hdl, &zc, nvp);
3566         if (error != 0)
3567                 goto out;
3568
3569         *dropped = (int)zc.zc_cookie;
3570 out:
3571         zcmd_free_nvlists(&zc);
3572
3573         return (error);
3574 }
3575
3576 /*
3577  * Clear all events.
3578  */
3579 int
3580 zpool_events_clear(libzfs_handle_t *hdl, int *count)
3581 {
3582         zfs_cmd_t zc = { "\0", "\0", "\0", "\0", 0 };
3583         char msg[1024];
3584
3585         (void) snprintf(msg, sizeof (msg), dgettext(TEXT_DOMAIN,
3586             "cannot clear events"));
3587
3588         if (zfs_ioctl(hdl, ZFS_IOC_EVENTS_CLEAR, &zc) != 0)
3589                 return (zpool_standard_error_fmt(hdl, errno, msg));
3590
3591         if (count != NULL)
3592                 *count = (int)zc.zc_cookie; /* # of events cleared */
3593
3594         return (0);
3595 }
3596
3597 void
3598 zpool_obj_to_path(zpool_handle_t *zhp, uint64_t dsobj, uint64_t obj,
3599     char *pathname, size_t len)
3600 {
3601         zfs_cmd_t zc = { "\0", "\0", "\0", "\0", 0 };
3602         boolean_t mounted = B_FALSE;
3603         char *mntpnt = NULL;
3604         char dsname[MAXNAMELEN];
3605
3606         if (dsobj == 0) {
3607                 /* special case for the MOS */
3608                 (void) snprintf(pathname, len, "<metadata>:<0x%llx>", (longlong_t)obj);
3609                 return;
3610         }
3611
3612         /* get the dataset's name */
3613         (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
3614         zc.zc_obj = dsobj;
3615         if (ioctl(zhp->zpool_hdl->libzfs_fd,
3616             ZFS_IOC_DSOBJ_TO_DSNAME, &zc) != 0) {
3617                 /* just write out a path of two object numbers */
3618                 (void) snprintf(pathname, len, "<0x%llx>:<0x%llx>",
3619                     (longlong_t)dsobj, (longlong_t)obj);
3620                 return;
3621         }
3622         (void) strlcpy(dsname, zc.zc_value, sizeof (dsname));
3623
3624         /* find out if the dataset is mounted */
3625         mounted = is_mounted(zhp->zpool_hdl, dsname, &mntpnt);
3626
3627         /* get the corrupted object's path */
3628         (void) strlcpy(zc.zc_name, dsname, sizeof (zc.zc_name));
3629         zc.zc_obj = obj;
3630         if (ioctl(zhp->zpool_hdl->libzfs_fd, ZFS_IOC_OBJ_TO_PATH,
3631             &zc) == 0) {
3632                 if (mounted) {
3633                         (void) snprintf(pathname, len, "%s%s", mntpnt,
3634                             zc.zc_value);
3635                 } else {
3636                         (void) snprintf(pathname, len, "%s:%s",
3637                             dsname, zc.zc_value);
3638                 }
3639         } else {
3640                 (void) snprintf(pathname, len, "%s:<0x%llx>", dsname, (longlong_t)obj);
3641         }
3642         free(mntpnt);
3643 }
3644
3645 /*
3646  * Read the EFI label from the config, if a label does not exist then
3647  * pass back the error to the caller. If the caller has passed a non-NULL
3648  * diskaddr argument then we set it to the starting address of the EFI
3649  * partition.
3650  */
3651 static int
3652 read_efi_label(nvlist_t *config, diskaddr_t *sb)
3653 {
3654         char *path;
3655         int fd;
3656         char diskname[MAXPATHLEN];
3657         int err = -1;
3658
3659         if (nvlist_lookup_string(config, ZPOOL_CONFIG_PATH, &path) != 0)
3660                 return (err);
3661
3662         (void) snprintf(diskname, sizeof (diskname), "%s%s", RDISK_ROOT,
3663             strrchr(path, '/'));
3664         if ((fd = open(diskname, O_RDWR|O_DIRECT)) >= 0) {
3665                 struct dk_gpt *vtoc;
3666
3667                 if ((err = efi_alloc_and_read(fd, &vtoc)) >= 0) {
3668                         if (sb != NULL)
3669                                 *sb = vtoc->efi_parts[0].p_start;
3670                         efi_free(vtoc);
3671                 }
3672                 (void) close(fd);
3673         }
3674         return (err);
3675 }
3676
3677 /*
3678  * determine where a partition starts on a disk in the current
3679  * configuration
3680  */
3681 static diskaddr_t
3682 find_start_block(nvlist_t *config)
3683 {
3684         nvlist_t **child;
3685         uint_t c, children;
3686         diskaddr_t sb = MAXOFFSET_T;
3687         uint64_t wholedisk;
3688
3689         if (nvlist_lookup_nvlist_array(config,
3690             ZPOOL_CONFIG_CHILDREN, &child, &children) != 0) {
3691                 if (nvlist_lookup_uint64(config,
3692                     ZPOOL_CONFIG_WHOLE_DISK,
3693                     &wholedisk) != 0 || !wholedisk) {
3694                         return (MAXOFFSET_T);
3695                 }
3696                 if (read_efi_label(config, &sb) < 0)
3697                         sb = MAXOFFSET_T;
3698                 return (sb);
3699         }
3700
3701         for (c = 0; c < children; c++) {
3702                 sb = find_start_block(child[c]);
3703                 if (sb != MAXOFFSET_T) {
3704                         return (sb);
3705                 }
3706         }
3707         return (MAXOFFSET_T);
3708 }
3709
3710 int
3711 zpool_label_disk_wait(char *path, int timeout)
3712 {
3713         struct stat64 statbuf;
3714         int i;
3715
3716         /*
3717          * Wait timeout miliseconds for a newly created device to be available
3718          * from the given path.  There is a small window when a /dev/ device
3719          * will exist and the udev link will not, so we must wait for the
3720          * symlink.  Depending on the udev rules this may take a few seconds.
3721          */
3722         for (i = 0; i < timeout; i++) {
3723                 usleep(1000);
3724
3725                 errno = 0;
3726                 if ((stat64(path, &statbuf) == 0) && (errno == 0))
3727                         return (0);
3728         }
3729
3730         return (ENOENT);
3731 }
3732
3733 int
3734 zpool_label_disk_check(char *path)
3735 {
3736         struct dk_gpt *vtoc;
3737         int fd, err;
3738
3739         if ((fd = open(path, O_RDWR|O_DIRECT)) < 0)
3740                 return errno;
3741
3742         if ((err = efi_alloc_and_read(fd, &vtoc)) != 0) {
3743                 (void) close(fd);
3744                 return err;
3745         }
3746
3747         if (vtoc->efi_flags & EFI_GPT_PRIMARY_CORRUPT) {
3748                 efi_free(vtoc);
3749                 (void) close(fd);
3750                 return EIDRM;
3751         }
3752
3753         efi_free(vtoc);
3754         (void) close(fd);
3755         return 0;
3756 }
3757
3758 /*
3759  * Label an individual disk.  The name provided is the short name,
3760  * stripped of any leading /dev path.
3761  */
3762 int
3763 zpool_label_disk(libzfs_handle_t *hdl, zpool_handle_t *zhp, char *name)
3764 {
3765         char path[MAXPATHLEN];
3766         struct dk_gpt *vtoc;
3767         int rval, fd;
3768         size_t resv = EFI_MIN_RESV_SIZE;
3769         uint64_t slice_size;
3770         diskaddr_t start_block;
3771         char errbuf[1024];
3772
3773         /* prepare an error message just in case */
3774         (void) snprintf(errbuf, sizeof (errbuf),
3775             dgettext(TEXT_DOMAIN, "cannot label '%s'"), name);
3776
3777         if (zhp) {
3778                 nvlist_t *nvroot;
3779
3780                 if (pool_is_bootable(zhp)) {
3781                         zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3782                             "EFI labeled devices are not supported on root "
3783                             "pools."));
3784                         return (zfs_error(hdl, EZFS_POOL_NOTSUP, errbuf));
3785                 }
3786
3787                 verify(nvlist_lookup_nvlist(zhp->zpool_config,
3788                     ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0);
3789
3790                 if (zhp->zpool_start_block == 0)
3791                         start_block = find_start_block(nvroot);
3792                 else
3793                         start_block = zhp->zpool_start_block;
3794                 zhp->zpool_start_block = start_block;
3795         } else {
3796                 /* new pool */
3797                 start_block = NEW_START_BLOCK;
3798         }
3799
3800         (void) snprintf(path, sizeof (path), "%s/%s%s", RDISK_ROOT, name,
3801             BACKUP_SLICE);
3802
3803         if ((fd = open(path, O_RDWR|O_DIRECT)) < 0) {
3804                 /*
3805                  * This shouldn't happen.  We've long since verified that this
3806                  * is a valid device.
3807                  */
3808                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "cannot "
3809                     "label '%s': unable to open device: %d"), path, errno);
3810                 return (zfs_error(hdl, EZFS_OPENFAILED, errbuf));
3811         }
3812
3813         if (efi_alloc_and_init(fd, EFI_NUMPAR, &vtoc) != 0) {
3814                 /*
3815                  * The only way this can fail is if we run out of memory, or we
3816                  * were unable to read the disk's capacity
3817                  */
3818                 if (errno == ENOMEM)
3819                         (void) no_memory(hdl);
3820
3821                 (void) close(fd);
3822                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "cannot "
3823                     "label '%s': unable to read disk capacity"), path);
3824
3825                 return (zfs_error(hdl, EZFS_NOCAP, errbuf));
3826         }
3827
3828         slice_size = vtoc->efi_last_u_lba + 1;
3829         slice_size -= EFI_MIN_RESV_SIZE;
3830         if (start_block == MAXOFFSET_T)
3831                 start_block = NEW_START_BLOCK;
3832         slice_size -= start_block;
3833         slice_size = P2ALIGN(slice_size, PARTITION_END_ALIGNMENT);
3834
3835         vtoc->efi_parts[0].p_start = start_block;
3836         vtoc->efi_parts[0].p_size = slice_size;
3837
3838         /*
3839          * Why we use V_USR: V_BACKUP confuses users, and is considered
3840          * disposable by some EFI utilities (since EFI doesn't have a backup
3841          * slice).  V_UNASSIGNED is supposed to be used only for zero size
3842          * partitions, and efi_write() will fail if we use it.  V_ROOT, V_BOOT,
3843          * etc. were all pretty specific.  V_USR is as close to reality as we
3844          * can get, in the absence of V_OTHER.
3845          */
3846         vtoc->efi_parts[0].p_tag = V_USR;
3847         (void) strcpy(vtoc->efi_parts[0].p_name, "zfs");
3848
3849         vtoc->efi_parts[8].p_start = slice_size + start_block;
3850         vtoc->efi_parts[8].p_size = resv;
3851         vtoc->efi_parts[8].p_tag = V_RESERVED;
3852
3853         if ((rval = efi_write(fd, vtoc)) != 0 || (rval = efi_rescan(fd)) != 0) {
3854                 /*
3855                  * Some block drivers (like pcata) may not support EFI
3856                  * GPT labels.  Print out a helpful error message dir-
3857                  * ecting the user to manually label the disk and give
3858                  * a specific slice.
3859                  */
3860                 (void) close(fd);
3861                 efi_free(vtoc);
3862
3863                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "try using "
3864                     "parted(8) and then provide a specific slice: %d"), rval);
3865                 return (zfs_error(hdl, EZFS_LABELFAILED, errbuf));
3866         }
3867
3868         (void) close(fd);
3869         efi_free(vtoc);
3870
3871         /* Wait for the first expected slice to appear. */
3872         (void) snprintf(path, sizeof (path), "%s/%s%s%s", DISK_ROOT, name,
3873             isdigit(name[strlen(name)-1]) ? "p" : "", FIRST_SLICE);
3874         rval = zpool_label_disk_wait(path, 3000);
3875         if (rval) {
3876                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "failed to "
3877                     "detect device partitions on '%s': %d"), path, rval);
3878                 return (zfs_error(hdl, EZFS_LABELFAILED, errbuf));
3879         }
3880
3881         /* We can't be to paranoid.  Read the label back and verify it. */
3882         (void) snprintf(path, sizeof (path), "%s/%s", DISK_ROOT, name);
3883         rval = zpool_label_disk_check(path);
3884         if (rval) {
3885                 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "freshly written "
3886                     "EFI label on '%s' is damaged.  Ensure\nthis device "
3887                     "is not in in use, and is functioning properly: %d"),
3888                     path, rval);
3889                 return (zfs_error(hdl, EZFS_LABELFAILED, errbuf));
3890         }
3891
3892         return 0;
3893 }