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