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