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