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 https://opensource.org/licenses/CDDL-1.0. 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 2015 Nexenta Systems, Inc. All rights reserved. 24 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. 25 * Copyright (c) 2011, 2020 by Delphix. All rights reserved. 26 * Copyright 2016 Igor Kozhukhov <ikozhukhov@gmail.com> 27 * Copyright (c) 2018 Datto Inc. 28 * Copyright (c) 2017 Open-E, Inc. All Rights Reserved. 29 * Copyright (c) 2017, Intel Corporation. 30 * Copyright (c) 2018, loli10K <ezomori.nozomu@gmail.com> 31 * Copyright (c) 2021, Colm Buckley <colm@tuatha.org> 32 * Copyright (c) 2021, Klara Inc. 33 */ 34 35 #include <errno.h> 36 #include <libintl.h> 37 #include <stdio.h> 38 #include <stdlib.h> 39 #include <strings.h> 40 #include <unistd.h> 41 #include <libgen.h> 42 #include <zone.h> 43 #include <sys/stat.h> 44 #include <sys/efi_partition.h> 45 #include <sys/systeminfo.h> 46 #include <sys/zfs_ioctl.h> 47 #include <sys/zfs_sysfs.h> 48 #include <sys/vdev_disk.h> 49 #include <sys/types.h> 50 #include <dlfcn.h> 51 #include <libzutil.h> 52 #include <fcntl.h> 53 54 #include "zfs_namecheck.h" 55 #include "zfs_prop.h" 56 #include "libzfs_impl.h" 57 #include "zfs_comutil.h" 58 #include "zfeature_common.h" 59 60 static boolean_t zpool_vdev_is_interior(const char *name); 61 62 typedef struct prop_flags { 63 unsigned int create:1; /* Validate property on creation */ 64 unsigned int import:1; /* Validate property on import */ 65 unsigned int vdevprop:1; /* Validate property as a VDEV property */ 66 } prop_flags_t; 67 68 /* 69 * ==================================================================== 70 * zpool property functions 71 * ==================================================================== 72 */ 73 74 static int 75 zpool_get_all_props(zpool_handle_t *zhp) 76 { 77 zfs_cmd_t zc = {"\0"}; 78 libzfs_handle_t *hdl = zhp->zpool_hdl; 79 80 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name)); 81 82 zcmd_alloc_dst_nvlist(hdl, &zc, 0); 83 84 while (zfs_ioctl(hdl, ZFS_IOC_POOL_GET_PROPS, &zc) != 0) { 85 if (errno == ENOMEM) 86 zcmd_expand_dst_nvlist(hdl, &zc); 87 else { 88 zcmd_free_nvlists(&zc); 89 return (-1); 90 } 91 } 92 93 if (zcmd_read_dst_nvlist(hdl, &zc, &zhp->zpool_props) != 0) { 94 zcmd_free_nvlists(&zc); 95 return (-1); 96 } 97 98 zcmd_free_nvlists(&zc); 99 100 return (0); 101 } 102 103 int 104 zpool_props_refresh(zpool_handle_t *zhp) 105 { 106 nvlist_t *old_props; 107 108 old_props = zhp->zpool_props; 109 110 if (zpool_get_all_props(zhp) != 0) 111 return (-1); 112 113 nvlist_free(old_props); 114 return (0); 115 } 116 117 static const char * 118 zpool_get_prop_string(zpool_handle_t *zhp, zpool_prop_t prop, 119 zprop_source_t *src) 120 { 121 nvlist_t *nv, *nvl; 122 const char *value; 123 zprop_source_t source; 124 125 nvl = zhp->zpool_props; 126 if (nvlist_lookup_nvlist(nvl, zpool_prop_to_name(prop), &nv) == 0) { 127 source = fnvlist_lookup_uint64(nv, ZPROP_SOURCE); 128 value = fnvlist_lookup_string(nv, ZPROP_VALUE); 129 } else { 130 source = ZPROP_SRC_DEFAULT; 131 if ((value = zpool_prop_default_string(prop)) == NULL) 132 value = "-"; 133 } 134 135 if (src) 136 *src = source; 137 138 return (value); 139 } 140 141 uint64_t 142 zpool_get_prop_int(zpool_handle_t *zhp, zpool_prop_t prop, zprop_source_t *src) 143 { 144 nvlist_t *nv, *nvl; 145 uint64_t value; 146 zprop_source_t source; 147 148 if (zhp->zpool_props == NULL && zpool_get_all_props(zhp)) { 149 /* 150 * zpool_get_all_props() has most likely failed because 151 * the pool is faulted, but if all we need is the top level 152 * vdev's guid then get it from the zhp config nvlist. 153 */ 154 if ((prop == ZPOOL_PROP_GUID) && 155 (nvlist_lookup_nvlist(zhp->zpool_config, 156 ZPOOL_CONFIG_VDEV_TREE, &nv) == 0) && 157 (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &value) 158 == 0)) { 159 return (value); 160 } 161 return (zpool_prop_default_numeric(prop)); 162 } 163 164 nvl = zhp->zpool_props; 165 if (nvlist_lookup_nvlist(nvl, zpool_prop_to_name(prop), &nv) == 0) { 166 source = fnvlist_lookup_uint64(nv, ZPROP_SOURCE); 167 value = fnvlist_lookup_uint64(nv, ZPROP_VALUE); 168 } else { 169 source = ZPROP_SRC_DEFAULT; 170 value = zpool_prop_default_numeric(prop); 171 } 172 173 if (src) 174 *src = source; 175 176 return (value); 177 } 178 179 /* 180 * Map VDEV STATE to printed strings. 181 */ 182 const char * 183 zpool_state_to_name(vdev_state_t state, vdev_aux_t aux) 184 { 185 switch (state) { 186 case VDEV_STATE_CLOSED: 187 case VDEV_STATE_OFFLINE: 188 return (gettext("OFFLINE")); 189 case VDEV_STATE_REMOVED: 190 return (gettext("REMOVED")); 191 case VDEV_STATE_CANT_OPEN: 192 if (aux == VDEV_AUX_CORRUPT_DATA || aux == VDEV_AUX_BAD_LOG) 193 return (gettext("FAULTED")); 194 else if (aux == VDEV_AUX_SPLIT_POOL) 195 return (gettext("SPLIT")); 196 else 197 return (gettext("UNAVAIL")); 198 case VDEV_STATE_FAULTED: 199 return (gettext("FAULTED")); 200 case VDEV_STATE_DEGRADED: 201 return (gettext("DEGRADED")); 202 case VDEV_STATE_HEALTHY: 203 return (gettext("ONLINE")); 204 205 default: 206 break; 207 } 208 209 return (gettext("UNKNOWN")); 210 } 211 212 /* 213 * Map POOL STATE to printed strings. 214 */ 215 const char * 216 zpool_pool_state_to_name(pool_state_t state) 217 { 218 switch (state) { 219 default: 220 break; 221 case POOL_STATE_ACTIVE: 222 return (gettext("ACTIVE")); 223 case POOL_STATE_EXPORTED: 224 return (gettext("EXPORTED")); 225 case POOL_STATE_DESTROYED: 226 return (gettext("DESTROYED")); 227 case POOL_STATE_SPARE: 228 return (gettext("SPARE")); 229 case POOL_STATE_L2CACHE: 230 return (gettext("L2CACHE")); 231 case POOL_STATE_UNINITIALIZED: 232 return (gettext("UNINITIALIZED")); 233 case POOL_STATE_UNAVAIL: 234 return (gettext("UNAVAIL")); 235 case POOL_STATE_POTENTIALLY_ACTIVE: 236 return (gettext("POTENTIALLY_ACTIVE")); 237 } 238 239 return (gettext("UNKNOWN")); 240 } 241 242 /* 243 * Given a pool handle, return the pool health string ("ONLINE", "DEGRADED", 244 * "SUSPENDED", etc). 245 */ 246 const char * 247 zpool_get_state_str(zpool_handle_t *zhp) 248 { 249 zpool_errata_t errata; 250 zpool_status_t status; 251 const char *str; 252 253 status = zpool_get_status(zhp, NULL, &errata); 254 255 if (zpool_get_state(zhp) == POOL_STATE_UNAVAIL) { 256 str = gettext("FAULTED"); 257 } else if (status == ZPOOL_STATUS_IO_FAILURE_WAIT || 258 status == ZPOOL_STATUS_IO_FAILURE_MMP) { 259 str = gettext("SUSPENDED"); 260 } else { 261 nvlist_t *nvroot = fnvlist_lookup_nvlist( 262 zpool_get_config(zhp, NULL), ZPOOL_CONFIG_VDEV_TREE); 263 uint_t vsc; 264 vdev_stat_t *vs = (vdev_stat_t *)fnvlist_lookup_uint64_array( 265 nvroot, ZPOOL_CONFIG_VDEV_STATS, &vsc); 266 str = zpool_state_to_name(vs->vs_state, vs->vs_aux); 267 } 268 return (str); 269 } 270 271 /* 272 * Get a zpool property value for 'prop' and return the value in 273 * a pre-allocated buffer. 274 */ 275 int 276 zpool_get_prop(zpool_handle_t *zhp, zpool_prop_t prop, char *buf, 277 size_t len, zprop_source_t *srctype, boolean_t literal) 278 { 279 uint64_t intval; 280 const char *strval; 281 zprop_source_t src = ZPROP_SRC_NONE; 282 283 if (zpool_get_state(zhp) == POOL_STATE_UNAVAIL) { 284 switch (prop) { 285 case ZPOOL_PROP_NAME: 286 (void) strlcpy(buf, zpool_get_name(zhp), len); 287 break; 288 289 case ZPOOL_PROP_HEALTH: 290 (void) strlcpy(buf, zpool_get_state_str(zhp), len); 291 break; 292 293 case ZPOOL_PROP_GUID: 294 intval = zpool_get_prop_int(zhp, prop, &src); 295 (void) snprintf(buf, len, "%llu", (u_longlong_t)intval); 296 break; 297 298 case ZPOOL_PROP_ALTROOT: 299 case ZPOOL_PROP_CACHEFILE: 300 case ZPOOL_PROP_COMMENT: 301 case ZPOOL_PROP_COMPATIBILITY: 302 if (zhp->zpool_props != NULL || 303 zpool_get_all_props(zhp) == 0) { 304 (void) strlcpy(buf, 305 zpool_get_prop_string(zhp, prop, &src), 306 len); 307 break; 308 } 309 zfs_fallthrough; 310 default: 311 (void) strlcpy(buf, "-", len); 312 break; 313 } 314 315 if (srctype != NULL) 316 *srctype = src; 317 return (0); 318 } 319 320 if (zhp->zpool_props == NULL && zpool_get_all_props(zhp) && 321 prop != ZPOOL_PROP_NAME) 322 return (-1); 323 324 switch (zpool_prop_get_type(prop)) { 325 case PROP_TYPE_STRING: 326 (void) strlcpy(buf, zpool_get_prop_string(zhp, prop, &src), 327 len); 328 break; 329 330 case PROP_TYPE_NUMBER: 331 intval = zpool_get_prop_int(zhp, prop, &src); 332 333 switch (prop) { 334 case ZPOOL_PROP_SIZE: 335 case ZPOOL_PROP_ALLOCATED: 336 case ZPOOL_PROP_FREE: 337 case ZPOOL_PROP_FREEING: 338 case ZPOOL_PROP_LEAKED: 339 case ZPOOL_PROP_ASHIFT: 340 case ZPOOL_PROP_MAXBLOCKSIZE: 341 case ZPOOL_PROP_MAXDNODESIZE: 342 case ZPOOL_PROP_BCLONESAVED: 343 case ZPOOL_PROP_BCLONEUSED: 344 if (literal) 345 (void) snprintf(buf, len, "%llu", 346 (u_longlong_t)intval); 347 else 348 (void) zfs_nicenum(intval, buf, len); 349 break; 350 351 case ZPOOL_PROP_EXPANDSZ: 352 case ZPOOL_PROP_CHECKPOINT: 353 if (intval == 0) { 354 (void) strlcpy(buf, "-", len); 355 } else if (literal) { 356 (void) snprintf(buf, len, "%llu", 357 (u_longlong_t)intval); 358 } else { 359 (void) zfs_nicebytes(intval, buf, len); 360 } 361 break; 362 363 case ZPOOL_PROP_CAPACITY: 364 if (literal) { 365 (void) snprintf(buf, len, "%llu", 366 (u_longlong_t)intval); 367 } else { 368 (void) snprintf(buf, len, "%llu%%", 369 (u_longlong_t)intval); 370 } 371 break; 372 373 case ZPOOL_PROP_FRAGMENTATION: 374 if (intval == UINT64_MAX) { 375 (void) strlcpy(buf, "-", len); 376 } else if (literal) { 377 (void) snprintf(buf, len, "%llu", 378 (u_longlong_t)intval); 379 } else { 380 (void) snprintf(buf, len, "%llu%%", 381 (u_longlong_t)intval); 382 } 383 break; 384 385 case ZPOOL_PROP_BCLONERATIO: 386 case ZPOOL_PROP_DEDUPRATIO: 387 if (literal) 388 (void) snprintf(buf, len, "%llu.%02llu", 389 (u_longlong_t)(intval / 100), 390 (u_longlong_t)(intval % 100)); 391 else 392 (void) snprintf(buf, len, "%llu.%02llux", 393 (u_longlong_t)(intval / 100), 394 (u_longlong_t)(intval % 100)); 395 break; 396 397 case ZPOOL_PROP_HEALTH: 398 (void) strlcpy(buf, zpool_get_state_str(zhp), len); 399 break; 400 case ZPOOL_PROP_VERSION: 401 if (intval >= SPA_VERSION_FEATURES) { 402 (void) snprintf(buf, len, "-"); 403 break; 404 } 405 zfs_fallthrough; 406 default: 407 (void) snprintf(buf, len, "%llu", (u_longlong_t)intval); 408 } 409 break; 410 411 case PROP_TYPE_INDEX: 412 intval = zpool_get_prop_int(zhp, prop, &src); 413 if (zpool_prop_index_to_string(prop, intval, &strval) 414 != 0) 415 return (-1); 416 (void) strlcpy(buf, strval, len); 417 break; 418 419 default: 420 abort(); 421 } 422 423 if (srctype) 424 *srctype = src; 425 426 return (0); 427 } 428 429 /* 430 * Check if the bootfs name has the same pool name as it is set to. 431 * Assuming bootfs is a valid dataset name. 432 */ 433 static boolean_t 434 bootfs_name_valid(const char *pool, const char *bootfs) 435 { 436 int len = strlen(pool); 437 if (bootfs[0] == '\0') 438 return (B_TRUE); 439 440 if (!zfs_name_valid(bootfs, ZFS_TYPE_FILESYSTEM|ZFS_TYPE_SNAPSHOT)) 441 return (B_FALSE); 442 443 if (strncmp(pool, bootfs, len) == 0 && 444 (bootfs[len] == '/' || bootfs[len] == '\0')) 445 return (B_TRUE); 446 447 return (B_FALSE); 448 } 449 450 /* 451 * Given an nvlist of zpool properties to be set, validate that they are 452 * correct, and parse any numeric properties (index, boolean, etc) if they are 453 * specified as strings. 454 */ 455 static nvlist_t * 456 zpool_valid_proplist(libzfs_handle_t *hdl, const char *poolname, 457 nvlist_t *props, uint64_t version, prop_flags_t flags, char *errbuf) 458 { 459 nvpair_t *elem; 460 nvlist_t *retprops; 461 zpool_prop_t prop; 462 const char *strval; 463 uint64_t intval; 464 const char *slash, *check; 465 struct stat64 statbuf; 466 zpool_handle_t *zhp; 467 char report[1024]; 468 469 if (nvlist_alloc(&retprops, NV_UNIQUE_NAME, 0) != 0) { 470 (void) no_memory(hdl); 471 return (NULL); 472 } 473 474 elem = NULL; 475 while ((elem = nvlist_next_nvpair(props, elem)) != NULL) { 476 const char *propname = nvpair_name(elem); 477 478 if (flags.vdevprop && zpool_prop_vdev(propname)) { 479 vdev_prop_t vprop = vdev_name_to_prop(propname); 480 481 if (vdev_prop_readonly(vprop)) { 482 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "'%s' " 483 "is readonly"), propname); 484 (void) zfs_error(hdl, EZFS_PROPREADONLY, 485 errbuf); 486 goto error; 487 } 488 489 if (zprop_parse_value(hdl, elem, vprop, ZFS_TYPE_VDEV, 490 retprops, &strval, &intval, errbuf) != 0) 491 goto error; 492 493 continue; 494 } else if (flags.vdevprop && vdev_prop_user(propname)) { 495 if (nvlist_add_nvpair(retprops, elem) != 0) { 496 (void) no_memory(hdl); 497 goto error; 498 } 499 continue; 500 } else if (flags.vdevprop) { 501 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 502 "invalid property: '%s'"), propname); 503 (void) zfs_error(hdl, EZFS_BADPROP, errbuf); 504 goto error; 505 } 506 507 prop = zpool_name_to_prop(propname); 508 if (prop == ZPOOL_PROP_INVAL && zpool_prop_feature(propname)) { 509 int err; 510 char *fname = strchr(propname, '@') + 1; 511 512 err = zfeature_lookup_name(fname, NULL); 513 if (err != 0) { 514 ASSERT3U(err, ==, ENOENT); 515 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 516 "feature '%s' unsupported by kernel"), 517 fname); 518 (void) zfs_error(hdl, EZFS_BADPROP, errbuf); 519 goto error; 520 } 521 522 if (nvpair_type(elem) != DATA_TYPE_STRING) { 523 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 524 "'%s' must be a string"), propname); 525 (void) zfs_error(hdl, EZFS_BADPROP, errbuf); 526 goto error; 527 } 528 529 (void) nvpair_value_string(elem, &strval); 530 if (strcmp(strval, ZFS_FEATURE_ENABLED) != 0 && 531 strcmp(strval, ZFS_FEATURE_DISABLED) != 0) { 532 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 533 "property '%s' can only be set to " 534 "'enabled' or 'disabled'"), propname); 535 (void) zfs_error(hdl, EZFS_BADPROP, errbuf); 536 goto error; 537 } 538 539 if (!flags.create && 540 strcmp(strval, ZFS_FEATURE_DISABLED) == 0) { 541 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 542 "property '%s' can only be set to " 543 "'disabled' at creation time"), propname); 544 (void) zfs_error(hdl, EZFS_BADPROP, errbuf); 545 goto error; 546 } 547 548 if (nvlist_add_uint64(retprops, propname, 0) != 0) { 549 (void) no_memory(hdl); 550 goto error; 551 } 552 continue; 553 } 554 555 /* 556 * Make sure this property is valid and applies to this type. 557 */ 558 if (prop == ZPOOL_PROP_INVAL) { 559 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 560 "invalid property '%s'"), propname); 561 (void) zfs_error(hdl, EZFS_BADPROP, errbuf); 562 goto error; 563 } 564 565 if (zpool_prop_readonly(prop)) { 566 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "'%s' " 567 "is readonly"), propname); 568 (void) zfs_error(hdl, EZFS_PROPREADONLY, errbuf); 569 goto error; 570 } 571 572 if (!flags.create && zpool_prop_setonce(prop)) { 573 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 574 "property '%s' can only be set at " 575 "creation time"), propname); 576 (void) zfs_error(hdl, EZFS_BADPROP, errbuf); 577 goto error; 578 } 579 580 if (zprop_parse_value(hdl, elem, prop, ZFS_TYPE_POOL, retprops, 581 &strval, &intval, errbuf) != 0) 582 goto error; 583 584 /* 585 * Perform additional checking for specific properties. 586 */ 587 switch (prop) { 588 case ZPOOL_PROP_VERSION: 589 if (intval < version || 590 !SPA_VERSION_IS_SUPPORTED(intval)) { 591 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 592 "property '%s' number %llu is invalid."), 593 propname, (unsigned long long)intval); 594 (void) zfs_error(hdl, EZFS_BADVERSION, errbuf); 595 goto error; 596 } 597 break; 598 599 case ZPOOL_PROP_ASHIFT: 600 if (intval != 0 && 601 (intval < ASHIFT_MIN || intval > ASHIFT_MAX)) { 602 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 603 "property '%s' number %llu is invalid, " 604 "only values between %" PRId32 " and %" 605 PRId32 " are allowed."), 606 propname, (unsigned long long)intval, 607 ASHIFT_MIN, ASHIFT_MAX); 608 (void) zfs_error(hdl, EZFS_BADPROP, errbuf); 609 goto error; 610 } 611 break; 612 613 case ZPOOL_PROP_BOOTFS: 614 if (flags.create || flags.import) { 615 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 616 "property '%s' cannot be set at creation " 617 "or import time"), propname); 618 (void) zfs_error(hdl, EZFS_BADPROP, errbuf); 619 goto error; 620 } 621 622 if (version < SPA_VERSION_BOOTFS) { 623 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 624 "pool must be upgraded to support " 625 "'%s' property"), propname); 626 (void) zfs_error(hdl, EZFS_BADVERSION, errbuf); 627 goto error; 628 } 629 630 /* 631 * bootfs property value has to be a dataset name and 632 * the dataset has to be in the same pool as it sets to. 633 */ 634 if (!bootfs_name_valid(poolname, strval)) { 635 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "'%s' " 636 "is an invalid name"), strval); 637 (void) zfs_error(hdl, EZFS_INVALIDNAME, errbuf); 638 goto error; 639 } 640 641 if ((zhp = zpool_open_canfail(hdl, poolname)) == NULL) { 642 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 643 "could not open pool '%s'"), poolname); 644 (void) zfs_error(hdl, EZFS_OPENFAILED, errbuf); 645 goto error; 646 } 647 zpool_close(zhp); 648 break; 649 650 case ZPOOL_PROP_ALTROOT: 651 if (!flags.create && !flags.import) { 652 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 653 "property '%s' can only be set during pool " 654 "creation or import"), propname); 655 (void) zfs_error(hdl, EZFS_BADPROP, errbuf); 656 goto error; 657 } 658 659 if (strval[0] != '/') { 660 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 661 "bad alternate root '%s'"), strval); 662 (void) zfs_error(hdl, EZFS_BADPATH, errbuf); 663 goto error; 664 } 665 break; 666 667 case ZPOOL_PROP_CACHEFILE: 668 if (strval[0] == '\0') 669 break; 670 671 if (strcmp(strval, "none") == 0) 672 break; 673 674 if (strval[0] != '/') { 675 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 676 "property '%s' must be empty, an " 677 "absolute path, or 'none'"), propname); 678 (void) zfs_error(hdl, EZFS_BADPATH, errbuf); 679 goto error; 680 } 681 682 slash = strrchr(strval, '/'); 683 684 if (slash[1] == '\0' || strcmp(slash, "/.") == 0 || 685 strcmp(slash, "/..") == 0) { 686 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 687 "'%s' is not a valid file"), strval); 688 (void) zfs_error(hdl, EZFS_BADPATH, errbuf); 689 goto error; 690 } 691 692 *(char *)slash = '\0'; 693 694 if (strval[0] != '\0' && 695 (stat64(strval, &statbuf) != 0 || 696 !S_ISDIR(statbuf.st_mode))) { 697 *(char *)slash = '/'; 698 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 699 "'%s' is not a valid directory"), 700 strval); 701 (void) zfs_error(hdl, EZFS_BADPATH, errbuf); 702 goto error; 703 } 704 705 *(char *)slash = '/'; 706 break; 707 708 case ZPOOL_PROP_COMPATIBILITY: 709 switch (zpool_load_compat(strval, NULL, report, 1024)) { 710 case ZPOOL_COMPATIBILITY_OK: 711 case ZPOOL_COMPATIBILITY_WARNTOKEN: 712 break; 713 case ZPOOL_COMPATIBILITY_BADFILE: 714 case ZPOOL_COMPATIBILITY_BADTOKEN: 715 case ZPOOL_COMPATIBILITY_NOFILES: 716 zfs_error_aux(hdl, "%s", report); 717 (void) zfs_error(hdl, EZFS_BADPROP, errbuf); 718 goto error; 719 } 720 break; 721 722 case ZPOOL_PROP_COMMENT: 723 for (check = strval; *check != '\0'; check++) { 724 if (!isprint(*check)) { 725 zfs_error_aux(hdl, 726 dgettext(TEXT_DOMAIN, 727 "comment may only have printable " 728 "characters")); 729 (void) zfs_error(hdl, EZFS_BADPROP, 730 errbuf); 731 goto error; 732 } 733 } 734 if (strlen(strval) > ZPROP_MAX_COMMENT) { 735 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 736 "comment must not exceed %d characters"), 737 ZPROP_MAX_COMMENT); 738 (void) zfs_error(hdl, EZFS_BADPROP, errbuf); 739 goto error; 740 } 741 break; 742 case ZPOOL_PROP_READONLY: 743 if (!flags.import) { 744 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 745 "property '%s' can only be set at " 746 "import time"), propname); 747 (void) zfs_error(hdl, EZFS_BADPROP, errbuf); 748 goto error; 749 } 750 break; 751 case ZPOOL_PROP_MULTIHOST: 752 if (get_system_hostid() == 0) { 753 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 754 "requires a non-zero system hostid")); 755 (void) zfs_error(hdl, EZFS_BADPROP, errbuf); 756 goto error; 757 } 758 break; 759 case ZPOOL_PROP_DEDUPDITTO: 760 printf("Note: property '%s' no longer has " 761 "any effect\n", propname); 762 break; 763 764 default: 765 break; 766 } 767 } 768 769 return (retprops); 770 error: 771 nvlist_free(retprops); 772 return (NULL); 773 } 774 775 /* 776 * Set zpool property : propname=propval. 777 */ 778 int 779 zpool_set_prop(zpool_handle_t *zhp, const char *propname, const char *propval) 780 { 781 zfs_cmd_t zc = {"\0"}; 782 int ret = -1; 783 char errbuf[ERRBUFLEN]; 784 nvlist_t *nvl = NULL; 785 nvlist_t *realprops; 786 uint64_t version; 787 prop_flags_t flags = { 0 }; 788 789 (void) snprintf(errbuf, sizeof (errbuf), 790 dgettext(TEXT_DOMAIN, "cannot set property for '%s'"), 791 zhp->zpool_name); 792 793 if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) 794 return (no_memory(zhp->zpool_hdl)); 795 796 if (nvlist_add_string(nvl, propname, propval) != 0) { 797 nvlist_free(nvl); 798 return (no_memory(zhp->zpool_hdl)); 799 } 800 801 version = zpool_get_prop_int(zhp, ZPOOL_PROP_VERSION, NULL); 802 if ((realprops = zpool_valid_proplist(zhp->zpool_hdl, 803 zhp->zpool_name, nvl, version, flags, errbuf)) == NULL) { 804 nvlist_free(nvl); 805 return (-1); 806 } 807 808 nvlist_free(nvl); 809 nvl = realprops; 810 811 /* 812 * Execute the corresponding ioctl() to set this property. 813 */ 814 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name)); 815 816 zcmd_write_src_nvlist(zhp->zpool_hdl, &zc, nvl); 817 818 ret = zfs_ioctl(zhp->zpool_hdl, ZFS_IOC_POOL_SET_PROPS, &zc); 819 820 zcmd_free_nvlists(&zc); 821 nvlist_free(nvl); 822 823 if (ret) 824 (void) zpool_standard_error(zhp->zpool_hdl, errno, errbuf); 825 else 826 (void) zpool_props_refresh(zhp); 827 828 return (ret); 829 } 830 831 int 832 zpool_expand_proplist(zpool_handle_t *zhp, zprop_list_t **plp, 833 zfs_type_t type, boolean_t literal) 834 { 835 libzfs_handle_t *hdl = zhp->zpool_hdl; 836 zprop_list_t *entry; 837 char buf[ZFS_MAXPROPLEN]; 838 nvlist_t *features = NULL; 839 nvpair_t *nvp; 840 zprop_list_t **last; 841 boolean_t firstexpand = (NULL == *plp); 842 int i; 843 844 if (zprop_expand_list(hdl, plp, type) != 0) 845 return (-1); 846 847 if (type == ZFS_TYPE_VDEV) 848 return (0); 849 850 last = plp; 851 while (*last != NULL) 852 last = &(*last)->pl_next; 853 854 if ((*plp)->pl_all) 855 features = zpool_get_features(zhp); 856 857 if ((*plp)->pl_all && firstexpand) { 858 for (i = 0; i < SPA_FEATURES; i++) { 859 zprop_list_t *entry = zfs_alloc(hdl, 860 sizeof (zprop_list_t)); 861 entry->pl_prop = ZPROP_USERPROP; 862 entry->pl_user_prop = zfs_asprintf(hdl, "feature@%s", 863 spa_feature_table[i].fi_uname); 864 entry->pl_width = strlen(entry->pl_user_prop); 865 entry->pl_all = B_TRUE; 866 867 *last = entry; 868 last = &entry->pl_next; 869 } 870 } 871 872 /* add any unsupported features */ 873 for (nvp = nvlist_next_nvpair(features, NULL); 874 nvp != NULL; nvp = nvlist_next_nvpair(features, nvp)) { 875 char *propname; 876 boolean_t found; 877 zprop_list_t *entry; 878 879 if (zfeature_is_supported(nvpair_name(nvp))) 880 continue; 881 882 propname = zfs_asprintf(hdl, "unsupported@%s", 883 nvpair_name(nvp)); 884 885 /* 886 * Before adding the property to the list make sure that no 887 * other pool already added the same property. 888 */ 889 found = B_FALSE; 890 entry = *plp; 891 while (entry != NULL) { 892 if (entry->pl_user_prop != NULL && 893 strcmp(propname, entry->pl_user_prop) == 0) { 894 found = B_TRUE; 895 break; 896 } 897 entry = entry->pl_next; 898 } 899 if (found) { 900 free(propname); 901 continue; 902 } 903 904 entry = zfs_alloc(hdl, sizeof (zprop_list_t)); 905 entry->pl_prop = ZPROP_USERPROP; 906 entry->pl_user_prop = propname; 907 entry->pl_width = strlen(entry->pl_user_prop); 908 entry->pl_all = B_TRUE; 909 910 *last = entry; 911 last = &entry->pl_next; 912 } 913 914 for (entry = *plp; entry != NULL; entry = entry->pl_next) { 915 if (entry->pl_fixed && !literal) 916 continue; 917 918 if (entry->pl_prop != ZPROP_USERPROP && 919 zpool_get_prop(zhp, entry->pl_prop, buf, sizeof (buf), 920 NULL, literal) == 0) { 921 if (strlen(buf) > entry->pl_width) 922 entry->pl_width = strlen(buf); 923 } 924 } 925 926 return (0); 927 } 928 929 int 930 vdev_expand_proplist(zpool_handle_t *zhp, const char *vdevname, 931 zprop_list_t **plp) 932 { 933 zprop_list_t *entry; 934 char buf[ZFS_MAXPROPLEN]; 935 const char *strval = NULL; 936 int err = 0; 937 nvpair_t *elem = NULL; 938 nvlist_t *vprops = NULL; 939 nvlist_t *propval = NULL; 940 const char *propname; 941 vdev_prop_t prop; 942 zprop_list_t **last; 943 944 for (entry = *plp; entry != NULL; entry = entry->pl_next) { 945 if (entry->pl_fixed) 946 continue; 947 948 if (zpool_get_vdev_prop(zhp, vdevname, entry->pl_prop, 949 entry->pl_user_prop, buf, sizeof (buf), NULL, 950 B_FALSE) == 0) { 951 if (strlen(buf) > entry->pl_width) 952 entry->pl_width = strlen(buf); 953 } 954 if (entry->pl_prop == VDEV_PROP_NAME && 955 strlen(vdevname) > entry->pl_width) 956 entry->pl_width = strlen(vdevname); 957 } 958 959 /* Handle the all properties case */ 960 last = plp; 961 if (*last != NULL && (*last)->pl_all == B_TRUE) { 962 while (*last != NULL) 963 last = &(*last)->pl_next; 964 965 err = zpool_get_all_vdev_props(zhp, vdevname, &vprops); 966 if (err != 0) 967 return (err); 968 969 while ((elem = nvlist_next_nvpair(vprops, elem)) != NULL) { 970 propname = nvpair_name(elem); 971 972 /* Skip properties that are not user defined */ 973 if ((prop = vdev_name_to_prop(propname)) != 974 VDEV_PROP_USERPROP) 975 continue; 976 977 if (nvpair_value_nvlist(elem, &propval) != 0) 978 continue; 979 980 strval = fnvlist_lookup_string(propval, ZPROP_VALUE); 981 982 entry = zfs_alloc(zhp->zpool_hdl, 983 sizeof (zprop_list_t)); 984 entry->pl_prop = prop; 985 entry->pl_user_prop = zfs_strdup(zhp->zpool_hdl, 986 propname); 987 entry->pl_width = strlen(strval); 988 entry->pl_all = B_TRUE; 989 *last = entry; 990 last = &entry->pl_next; 991 } 992 } 993 994 return (0); 995 } 996 997 /* 998 * Get the state for the given feature on the given ZFS pool. 999 */ 1000 int 1001 zpool_prop_get_feature(zpool_handle_t *zhp, const char *propname, char *buf, 1002 size_t len) 1003 { 1004 uint64_t refcount; 1005 boolean_t found = B_FALSE; 1006 nvlist_t *features = zpool_get_features(zhp); 1007 boolean_t supported; 1008 const char *feature = strchr(propname, '@') + 1; 1009 1010 supported = zpool_prop_feature(propname); 1011 ASSERT(supported || zpool_prop_unsupported(propname)); 1012 1013 /* 1014 * Convert from feature name to feature guid. This conversion is 1015 * unnecessary for unsupported@... properties because they already 1016 * use guids. 1017 */ 1018 if (supported) { 1019 int ret; 1020 spa_feature_t fid; 1021 1022 ret = zfeature_lookup_name(feature, &fid); 1023 if (ret != 0) { 1024 (void) strlcpy(buf, "-", len); 1025 return (ENOTSUP); 1026 } 1027 feature = spa_feature_table[fid].fi_guid; 1028 } 1029 1030 if (nvlist_lookup_uint64(features, feature, &refcount) == 0) 1031 found = B_TRUE; 1032 1033 if (supported) { 1034 if (!found) { 1035 (void) strlcpy(buf, ZFS_FEATURE_DISABLED, len); 1036 } else { 1037 if (refcount == 0) 1038 (void) strlcpy(buf, ZFS_FEATURE_ENABLED, len); 1039 else 1040 (void) strlcpy(buf, ZFS_FEATURE_ACTIVE, len); 1041 } 1042 } else { 1043 if (found) { 1044 if (refcount == 0) { 1045 (void) strcpy(buf, ZFS_UNSUPPORTED_INACTIVE); 1046 } else { 1047 (void) strcpy(buf, ZFS_UNSUPPORTED_READONLY); 1048 } 1049 } else { 1050 (void) strlcpy(buf, "-", len); 1051 return (ENOTSUP); 1052 } 1053 } 1054 1055 return (0); 1056 } 1057 1058 /* 1059 * Validate the given pool name, optionally putting an extended error message in 1060 * 'buf'. 1061 */ 1062 boolean_t 1063 zpool_name_valid(libzfs_handle_t *hdl, boolean_t isopen, const char *pool) 1064 { 1065 namecheck_err_t why; 1066 char what; 1067 int ret; 1068 1069 ret = pool_namecheck(pool, &why, &what); 1070 1071 /* 1072 * The rules for reserved pool names were extended at a later point. 1073 * But we need to support users with existing pools that may now be 1074 * invalid. So we only check for this expanded set of names during a 1075 * create (or import), and only in userland. 1076 */ 1077 if (ret == 0 && !isopen && 1078 (strncmp(pool, "mirror", 6) == 0 || 1079 strncmp(pool, "raidz", 5) == 0 || 1080 strncmp(pool, "draid", 5) == 0 || 1081 strncmp(pool, "spare", 5) == 0 || 1082 strcmp(pool, "log") == 0)) { 1083 if (hdl != NULL) 1084 zfs_error_aux(hdl, 1085 dgettext(TEXT_DOMAIN, "name is reserved")); 1086 return (B_FALSE); 1087 } 1088 1089 1090 if (ret != 0) { 1091 if (hdl != NULL) { 1092 switch (why) { 1093 case NAME_ERR_TOOLONG: 1094 zfs_error_aux(hdl, 1095 dgettext(TEXT_DOMAIN, "name is too long")); 1096 break; 1097 1098 case NAME_ERR_INVALCHAR: 1099 zfs_error_aux(hdl, 1100 dgettext(TEXT_DOMAIN, "invalid character " 1101 "'%c' in pool name"), what); 1102 break; 1103 1104 case NAME_ERR_NOLETTER: 1105 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1106 "name must begin with a letter")); 1107 break; 1108 1109 case NAME_ERR_RESERVED: 1110 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1111 "name is reserved")); 1112 break; 1113 1114 case NAME_ERR_DISKLIKE: 1115 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1116 "pool name is reserved")); 1117 break; 1118 1119 case NAME_ERR_LEADING_SLASH: 1120 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1121 "leading slash in name")); 1122 break; 1123 1124 case NAME_ERR_EMPTY_COMPONENT: 1125 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1126 "empty component in name")); 1127 break; 1128 1129 case NAME_ERR_TRAILING_SLASH: 1130 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1131 "trailing slash in name")); 1132 break; 1133 1134 case NAME_ERR_MULTIPLE_DELIMITERS: 1135 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1136 "multiple '@' and/or '#' delimiters in " 1137 "name")); 1138 break; 1139 1140 case NAME_ERR_NO_AT: 1141 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1142 "permission set is missing '@'")); 1143 break; 1144 1145 default: 1146 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1147 "(%d) not defined"), why); 1148 break; 1149 } 1150 } 1151 return (B_FALSE); 1152 } 1153 1154 return (B_TRUE); 1155 } 1156 1157 /* 1158 * Open a handle to the given pool, even if the pool is currently in the FAULTED 1159 * state. 1160 */ 1161 zpool_handle_t * 1162 zpool_open_canfail(libzfs_handle_t *hdl, const char *pool) 1163 { 1164 zpool_handle_t *zhp; 1165 boolean_t missing; 1166 1167 /* 1168 * Make sure the pool name is valid. 1169 */ 1170 if (!zpool_name_valid(hdl, B_TRUE, pool)) { 1171 (void) zfs_error_fmt(hdl, EZFS_INVALIDNAME, 1172 dgettext(TEXT_DOMAIN, "cannot open '%s'"), 1173 pool); 1174 return (NULL); 1175 } 1176 1177 zhp = zfs_alloc(hdl, sizeof (zpool_handle_t)); 1178 1179 zhp->zpool_hdl = hdl; 1180 (void) strlcpy(zhp->zpool_name, pool, sizeof (zhp->zpool_name)); 1181 1182 if (zpool_refresh_stats(zhp, &missing) != 0) { 1183 zpool_close(zhp); 1184 return (NULL); 1185 } 1186 1187 if (missing) { 1188 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "no such pool")); 1189 (void) zfs_error_fmt(hdl, EZFS_NOENT, 1190 dgettext(TEXT_DOMAIN, "cannot open '%s'"), pool); 1191 zpool_close(zhp); 1192 return (NULL); 1193 } 1194 1195 return (zhp); 1196 } 1197 1198 /* 1199 * Like the above, but silent on error. Used when iterating over pools (because 1200 * the configuration cache may be out of date). 1201 */ 1202 int 1203 zpool_open_silent(libzfs_handle_t *hdl, const char *pool, zpool_handle_t **ret) 1204 { 1205 zpool_handle_t *zhp; 1206 boolean_t missing; 1207 1208 zhp = zfs_alloc(hdl, sizeof (zpool_handle_t)); 1209 1210 zhp->zpool_hdl = hdl; 1211 (void) strlcpy(zhp->zpool_name, pool, sizeof (zhp->zpool_name)); 1212 1213 if (zpool_refresh_stats(zhp, &missing) != 0) { 1214 zpool_close(zhp); 1215 return (-1); 1216 } 1217 1218 if (missing) { 1219 zpool_close(zhp); 1220 *ret = NULL; 1221 return (0); 1222 } 1223 1224 *ret = zhp; 1225 return (0); 1226 } 1227 1228 /* 1229 * Similar to zpool_open_canfail(), but refuses to open pools in the faulted 1230 * state. 1231 */ 1232 zpool_handle_t * 1233 zpool_open(libzfs_handle_t *hdl, const char *pool) 1234 { 1235 zpool_handle_t *zhp; 1236 1237 if ((zhp = zpool_open_canfail(hdl, pool)) == NULL) 1238 return (NULL); 1239 1240 if (zhp->zpool_state == POOL_STATE_UNAVAIL) { 1241 (void) zfs_error_fmt(hdl, EZFS_POOLUNAVAIL, 1242 dgettext(TEXT_DOMAIN, "cannot open '%s'"), zhp->zpool_name); 1243 zpool_close(zhp); 1244 return (NULL); 1245 } 1246 1247 return (zhp); 1248 } 1249 1250 /* 1251 * Close the handle. Simply frees the memory associated with the handle. 1252 */ 1253 void 1254 zpool_close(zpool_handle_t *zhp) 1255 { 1256 nvlist_free(zhp->zpool_config); 1257 nvlist_free(zhp->zpool_old_config); 1258 nvlist_free(zhp->zpool_props); 1259 free(zhp); 1260 } 1261 1262 /* 1263 * Return the name of the pool. 1264 */ 1265 const char * 1266 zpool_get_name(zpool_handle_t *zhp) 1267 { 1268 return (zhp->zpool_name); 1269 } 1270 1271 1272 /* 1273 * Return the state of the pool (ACTIVE or UNAVAILABLE) 1274 */ 1275 int 1276 zpool_get_state(zpool_handle_t *zhp) 1277 { 1278 return (zhp->zpool_state); 1279 } 1280 1281 /* 1282 * Check if vdev list contains a special vdev 1283 */ 1284 static boolean_t 1285 zpool_has_special_vdev(nvlist_t *nvroot) 1286 { 1287 nvlist_t **child; 1288 uint_t children; 1289 1290 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN, &child, 1291 &children) == 0) { 1292 for (uint_t c = 0; c < children; c++) { 1293 const char *bias; 1294 1295 if (nvlist_lookup_string(child[c], 1296 ZPOOL_CONFIG_ALLOCATION_BIAS, &bias) == 0 && 1297 strcmp(bias, VDEV_ALLOC_BIAS_SPECIAL) == 0) { 1298 return (B_TRUE); 1299 } 1300 } 1301 } 1302 return (B_FALSE); 1303 } 1304 1305 /* 1306 * Check if vdev list contains a dRAID vdev 1307 */ 1308 static boolean_t 1309 zpool_has_draid_vdev(nvlist_t *nvroot) 1310 { 1311 nvlist_t **child; 1312 uint_t children; 1313 1314 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN, 1315 &child, &children) == 0) { 1316 for (uint_t c = 0; c < children; c++) { 1317 const char *type; 1318 1319 if (nvlist_lookup_string(child[c], 1320 ZPOOL_CONFIG_TYPE, &type) == 0 && 1321 strcmp(type, VDEV_TYPE_DRAID) == 0) { 1322 return (B_TRUE); 1323 } 1324 } 1325 } 1326 return (B_FALSE); 1327 } 1328 1329 /* 1330 * Output a dRAID top-level vdev name in to the provided buffer. 1331 */ 1332 static char * 1333 zpool_draid_name(char *name, int len, uint64_t data, uint64_t parity, 1334 uint64_t spares, uint64_t children) 1335 { 1336 snprintf(name, len, "%s%llu:%llud:%lluc:%llus", 1337 VDEV_TYPE_DRAID, (u_longlong_t)parity, (u_longlong_t)data, 1338 (u_longlong_t)children, (u_longlong_t)spares); 1339 1340 return (name); 1341 } 1342 1343 /* 1344 * Return B_TRUE if the provided name is a dRAID spare name. 1345 */ 1346 boolean_t 1347 zpool_is_draid_spare(const char *name) 1348 { 1349 uint64_t spare_id, parity, vdev_id; 1350 1351 if (sscanf(name, VDEV_TYPE_DRAID "%llu-%llu-%llu", 1352 (u_longlong_t *)&parity, (u_longlong_t *)&vdev_id, 1353 (u_longlong_t *)&spare_id) == 3) { 1354 return (B_TRUE); 1355 } 1356 1357 return (B_FALSE); 1358 } 1359 1360 /* 1361 * Create the named pool, using the provided vdev list. It is assumed 1362 * that the consumer has already validated the contents of the nvlist, so we 1363 * don't have to worry about error semantics. 1364 */ 1365 int 1366 zpool_create(libzfs_handle_t *hdl, const char *pool, nvlist_t *nvroot, 1367 nvlist_t *props, nvlist_t *fsprops) 1368 { 1369 zfs_cmd_t zc = {"\0"}; 1370 nvlist_t *zc_fsprops = NULL; 1371 nvlist_t *zc_props = NULL; 1372 nvlist_t *hidden_args = NULL; 1373 uint8_t *wkeydata = NULL; 1374 uint_t wkeylen = 0; 1375 char errbuf[ERRBUFLEN]; 1376 int ret = -1; 1377 1378 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 1379 "cannot create '%s'"), pool); 1380 1381 if (!zpool_name_valid(hdl, B_FALSE, pool)) 1382 return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf)); 1383 1384 zcmd_write_conf_nvlist(hdl, &zc, nvroot); 1385 1386 if (props) { 1387 prop_flags_t flags = { .create = B_TRUE, .import = B_FALSE }; 1388 1389 if ((zc_props = zpool_valid_proplist(hdl, pool, props, 1390 SPA_VERSION_1, flags, errbuf)) == NULL) { 1391 goto create_failed; 1392 } 1393 } 1394 1395 if (fsprops) { 1396 uint64_t zoned; 1397 const char *zonestr; 1398 1399 zoned = ((nvlist_lookup_string(fsprops, 1400 zfs_prop_to_name(ZFS_PROP_ZONED), &zonestr) == 0) && 1401 strcmp(zonestr, "on") == 0); 1402 1403 if ((zc_fsprops = zfs_valid_proplist(hdl, ZFS_TYPE_FILESYSTEM, 1404 fsprops, zoned, NULL, NULL, B_TRUE, errbuf)) == NULL) { 1405 goto create_failed; 1406 } 1407 1408 if (nvlist_exists(zc_fsprops, 1409 zfs_prop_to_name(ZFS_PROP_SPECIAL_SMALL_BLOCKS)) && 1410 !zpool_has_special_vdev(nvroot)) { 1411 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1412 "%s property requires a special vdev"), 1413 zfs_prop_to_name(ZFS_PROP_SPECIAL_SMALL_BLOCKS)); 1414 (void) zfs_error(hdl, EZFS_BADPROP, errbuf); 1415 goto create_failed; 1416 } 1417 1418 if (!zc_props && 1419 (nvlist_alloc(&zc_props, NV_UNIQUE_NAME, 0) != 0)) { 1420 goto create_failed; 1421 } 1422 if (zfs_crypto_create(hdl, NULL, zc_fsprops, props, B_TRUE, 1423 &wkeydata, &wkeylen) != 0) { 1424 zfs_error(hdl, EZFS_CRYPTOFAILED, errbuf); 1425 goto create_failed; 1426 } 1427 if (nvlist_add_nvlist(zc_props, 1428 ZPOOL_ROOTFS_PROPS, zc_fsprops) != 0) { 1429 goto create_failed; 1430 } 1431 if (wkeydata != NULL) { 1432 if (nvlist_alloc(&hidden_args, NV_UNIQUE_NAME, 0) != 0) 1433 goto create_failed; 1434 1435 if (nvlist_add_uint8_array(hidden_args, "wkeydata", 1436 wkeydata, wkeylen) != 0) 1437 goto create_failed; 1438 1439 if (nvlist_add_nvlist(zc_props, ZPOOL_HIDDEN_ARGS, 1440 hidden_args) != 0) 1441 goto create_failed; 1442 } 1443 } 1444 1445 if (zc_props) 1446 zcmd_write_src_nvlist(hdl, &zc, zc_props); 1447 1448 (void) strlcpy(zc.zc_name, pool, sizeof (zc.zc_name)); 1449 1450 if ((ret = zfs_ioctl(hdl, ZFS_IOC_POOL_CREATE, &zc)) != 0) { 1451 1452 zcmd_free_nvlists(&zc); 1453 nvlist_free(zc_props); 1454 nvlist_free(zc_fsprops); 1455 nvlist_free(hidden_args); 1456 if (wkeydata != NULL) 1457 free(wkeydata); 1458 1459 switch (errno) { 1460 case EBUSY: 1461 /* 1462 * This can happen if the user has specified the same 1463 * device multiple times. We can't reliably detect this 1464 * until we try to add it and see we already have a 1465 * label. This can also happen under if the device is 1466 * part of an active md or lvm device. 1467 */ 1468 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1469 "one or more vdevs refer to the same device, or " 1470 "one of\nthe devices is part of an active md or " 1471 "lvm device")); 1472 return (zfs_error(hdl, EZFS_BADDEV, errbuf)); 1473 1474 case ERANGE: 1475 /* 1476 * This happens if the record size is smaller or larger 1477 * than the allowed size range, or not a power of 2. 1478 * 1479 * NOTE: although zfs_valid_proplist is called earlier, 1480 * this case may have slipped through since the 1481 * pool does not exist yet and it is therefore 1482 * impossible to read properties e.g. max blocksize 1483 * from the pool. 1484 */ 1485 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1486 "record size invalid")); 1487 return (zfs_error(hdl, EZFS_BADPROP, errbuf)); 1488 1489 case EOVERFLOW: 1490 /* 1491 * This occurs when one of the devices is below 1492 * SPA_MINDEVSIZE. Unfortunately, we can't detect which 1493 * device was the problem device since there's no 1494 * reliable way to determine device size from userland. 1495 */ 1496 { 1497 char buf[64]; 1498 1499 zfs_nicebytes(SPA_MINDEVSIZE, buf, 1500 sizeof (buf)); 1501 1502 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1503 "one or more devices is less than the " 1504 "minimum size (%s)"), buf); 1505 } 1506 return (zfs_error(hdl, EZFS_BADDEV, errbuf)); 1507 1508 case ENOSPC: 1509 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1510 "one or more devices is out of space")); 1511 return (zfs_error(hdl, EZFS_BADDEV, errbuf)); 1512 1513 case EINVAL: 1514 if (zpool_has_draid_vdev(nvroot) && 1515 zfeature_lookup_name("draid", NULL) != 0) { 1516 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1517 "dRAID vdevs are unsupported by the " 1518 "kernel")); 1519 return (zfs_error(hdl, EZFS_BADDEV, errbuf)); 1520 } else { 1521 return (zpool_standard_error(hdl, errno, 1522 errbuf)); 1523 } 1524 1525 default: 1526 return (zpool_standard_error(hdl, errno, errbuf)); 1527 } 1528 } 1529 1530 create_failed: 1531 zcmd_free_nvlists(&zc); 1532 nvlist_free(zc_props); 1533 nvlist_free(zc_fsprops); 1534 nvlist_free(hidden_args); 1535 if (wkeydata != NULL) 1536 free(wkeydata); 1537 return (ret); 1538 } 1539 1540 /* 1541 * Destroy the given pool. It is up to the caller to ensure that there are no 1542 * datasets left in the pool. 1543 */ 1544 int 1545 zpool_destroy(zpool_handle_t *zhp, const char *log_str) 1546 { 1547 zfs_cmd_t zc = {"\0"}; 1548 zfs_handle_t *zfp = NULL; 1549 libzfs_handle_t *hdl = zhp->zpool_hdl; 1550 char errbuf[ERRBUFLEN]; 1551 1552 if (zhp->zpool_state == POOL_STATE_ACTIVE && 1553 (zfp = zfs_open(hdl, zhp->zpool_name, ZFS_TYPE_FILESYSTEM)) == NULL) 1554 return (-1); 1555 1556 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name)); 1557 zc.zc_history = (uint64_t)(uintptr_t)log_str; 1558 1559 if (zfs_ioctl(hdl, ZFS_IOC_POOL_DESTROY, &zc) != 0) { 1560 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 1561 "cannot destroy '%s'"), zhp->zpool_name); 1562 1563 if (errno == EROFS) { 1564 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1565 "one or more devices is read only")); 1566 (void) zfs_error(hdl, EZFS_BADDEV, errbuf); 1567 } else { 1568 (void) zpool_standard_error(hdl, errno, errbuf); 1569 } 1570 1571 if (zfp) 1572 zfs_close(zfp); 1573 return (-1); 1574 } 1575 1576 if (zfp) { 1577 remove_mountpoint(zfp); 1578 zfs_close(zfp); 1579 } 1580 1581 return (0); 1582 } 1583 1584 /* 1585 * Create a checkpoint in the given pool. 1586 */ 1587 int 1588 zpool_checkpoint(zpool_handle_t *zhp) 1589 { 1590 libzfs_handle_t *hdl = zhp->zpool_hdl; 1591 char errbuf[ERRBUFLEN]; 1592 int error; 1593 1594 error = lzc_pool_checkpoint(zhp->zpool_name); 1595 if (error != 0) { 1596 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 1597 "cannot checkpoint '%s'"), zhp->zpool_name); 1598 (void) zpool_standard_error(hdl, error, errbuf); 1599 return (-1); 1600 } 1601 1602 return (0); 1603 } 1604 1605 /* 1606 * Discard the checkpoint from the given pool. 1607 */ 1608 int 1609 zpool_discard_checkpoint(zpool_handle_t *zhp) 1610 { 1611 libzfs_handle_t *hdl = zhp->zpool_hdl; 1612 char errbuf[ERRBUFLEN]; 1613 int error; 1614 1615 error = lzc_pool_checkpoint_discard(zhp->zpool_name); 1616 if (error != 0) { 1617 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 1618 "cannot discard checkpoint in '%s'"), zhp->zpool_name); 1619 (void) zpool_standard_error(hdl, error, errbuf); 1620 return (-1); 1621 } 1622 1623 return (0); 1624 } 1625 1626 /* 1627 * Add the given vdevs to the pool. The caller must have already performed the 1628 * necessary verification to ensure that the vdev specification is well-formed. 1629 */ 1630 int 1631 zpool_add(zpool_handle_t *zhp, nvlist_t *nvroot) 1632 { 1633 zfs_cmd_t zc = {"\0"}; 1634 int ret; 1635 libzfs_handle_t *hdl = zhp->zpool_hdl; 1636 char errbuf[ERRBUFLEN]; 1637 nvlist_t **spares, **l2cache; 1638 uint_t nspares, nl2cache; 1639 1640 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 1641 "cannot add to '%s'"), zhp->zpool_name); 1642 1643 if (zpool_get_prop_int(zhp, ZPOOL_PROP_VERSION, NULL) < 1644 SPA_VERSION_SPARES && 1645 nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, 1646 &spares, &nspares) == 0) { 1647 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "pool must be " 1648 "upgraded to add hot spares")); 1649 return (zfs_error(hdl, EZFS_BADVERSION, errbuf)); 1650 } 1651 1652 if (zpool_get_prop_int(zhp, ZPOOL_PROP_VERSION, NULL) < 1653 SPA_VERSION_L2CACHE && 1654 nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE, 1655 &l2cache, &nl2cache) == 0) { 1656 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "pool must be " 1657 "upgraded to add cache devices")); 1658 return (zfs_error(hdl, EZFS_BADVERSION, errbuf)); 1659 } 1660 1661 zcmd_write_conf_nvlist(hdl, &zc, nvroot); 1662 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name)); 1663 1664 if (zfs_ioctl(hdl, ZFS_IOC_VDEV_ADD, &zc) != 0) { 1665 switch (errno) { 1666 case EBUSY: 1667 /* 1668 * This can happen if the user has specified the same 1669 * device multiple times. We can't reliably detect this 1670 * until we try to add it and see we already have a 1671 * label. 1672 */ 1673 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1674 "one or more vdevs refer to the same device")); 1675 (void) zfs_error(hdl, EZFS_BADDEV, errbuf); 1676 break; 1677 1678 case EINVAL: 1679 1680 if (zpool_has_draid_vdev(nvroot) && 1681 zfeature_lookup_name("draid", NULL) != 0) { 1682 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1683 "dRAID vdevs are unsupported by the " 1684 "kernel")); 1685 } else { 1686 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1687 "invalid config; a pool with removing/" 1688 "removed vdevs does not support adding " 1689 "raidz or dRAID vdevs")); 1690 } 1691 1692 (void) zfs_error(hdl, EZFS_BADDEV, errbuf); 1693 break; 1694 1695 case EOVERFLOW: 1696 /* 1697 * This occurs when one of the devices is below 1698 * SPA_MINDEVSIZE. Unfortunately, we can't detect which 1699 * device was the problem device since there's no 1700 * reliable way to determine device size from userland. 1701 */ 1702 { 1703 char buf[64]; 1704 1705 zfs_nicebytes(SPA_MINDEVSIZE, buf, 1706 sizeof (buf)); 1707 1708 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1709 "device is less than the minimum " 1710 "size (%s)"), buf); 1711 } 1712 (void) zfs_error(hdl, EZFS_BADDEV, errbuf); 1713 break; 1714 1715 case ENOTSUP: 1716 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 1717 "pool must be upgraded to add these vdevs")); 1718 (void) zfs_error(hdl, EZFS_BADVERSION, errbuf); 1719 break; 1720 1721 default: 1722 (void) zpool_standard_error(hdl, errno, errbuf); 1723 } 1724 1725 ret = -1; 1726 } else { 1727 ret = 0; 1728 } 1729 1730 zcmd_free_nvlists(&zc); 1731 1732 return (ret); 1733 } 1734 1735 /* 1736 * Exports the pool from the system. The caller must ensure that there are no 1737 * mounted datasets in the pool. 1738 */ 1739 static int 1740 zpool_export_common(zpool_handle_t *zhp, boolean_t force, boolean_t hardforce, 1741 const char *log_str) 1742 { 1743 zfs_cmd_t zc = {"\0"}; 1744 1745 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name)); 1746 zc.zc_cookie = force; 1747 zc.zc_guid = hardforce; 1748 zc.zc_history = (uint64_t)(uintptr_t)log_str; 1749 1750 if (zfs_ioctl(zhp->zpool_hdl, ZFS_IOC_POOL_EXPORT, &zc) != 0) { 1751 switch (errno) { 1752 case EXDEV: 1753 zfs_error_aux(zhp->zpool_hdl, dgettext(TEXT_DOMAIN, 1754 "use '-f' to override the following errors:\n" 1755 "'%s' has an active shared spare which could be" 1756 " used by other pools once '%s' is exported."), 1757 zhp->zpool_name, zhp->zpool_name); 1758 return (zfs_error_fmt(zhp->zpool_hdl, EZFS_ACTIVE_SPARE, 1759 dgettext(TEXT_DOMAIN, "cannot export '%s'"), 1760 zhp->zpool_name)); 1761 default: 1762 return (zpool_standard_error_fmt(zhp->zpool_hdl, errno, 1763 dgettext(TEXT_DOMAIN, "cannot export '%s'"), 1764 zhp->zpool_name)); 1765 } 1766 } 1767 1768 return (0); 1769 } 1770 1771 int 1772 zpool_export(zpool_handle_t *zhp, boolean_t force, const char *log_str) 1773 { 1774 return (zpool_export_common(zhp, force, B_FALSE, log_str)); 1775 } 1776 1777 int 1778 zpool_export_force(zpool_handle_t *zhp, const char *log_str) 1779 { 1780 return (zpool_export_common(zhp, B_TRUE, B_TRUE, log_str)); 1781 } 1782 1783 static void 1784 zpool_rewind_exclaim(libzfs_handle_t *hdl, const char *name, boolean_t dryrun, 1785 nvlist_t *config) 1786 { 1787 nvlist_t *nv = NULL; 1788 uint64_t rewindto; 1789 int64_t loss = -1; 1790 struct tm t; 1791 char timestr[128]; 1792 1793 if (!hdl->libzfs_printerr || config == NULL) 1794 return; 1795 1796 if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_LOAD_INFO, &nv) != 0 || 1797 nvlist_lookup_nvlist(nv, ZPOOL_CONFIG_REWIND_INFO, &nv) != 0) { 1798 return; 1799 } 1800 1801 if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_LOAD_TIME, &rewindto) != 0) 1802 return; 1803 (void) nvlist_lookup_int64(nv, ZPOOL_CONFIG_REWIND_TIME, &loss); 1804 1805 if (localtime_r((time_t *)&rewindto, &t) != NULL && 1806 strftime(timestr, 128, "%c", &t) != 0) { 1807 if (dryrun) { 1808 (void) printf(dgettext(TEXT_DOMAIN, 1809 "Would be able to return %s " 1810 "to its state as of %s.\n"), 1811 name, timestr); 1812 } else { 1813 (void) printf(dgettext(TEXT_DOMAIN, 1814 "Pool %s returned to its state as of %s.\n"), 1815 name, timestr); 1816 } 1817 if (loss > 120) { 1818 (void) printf(dgettext(TEXT_DOMAIN, 1819 "%s approximately %lld "), 1820 dryrun ? "Would discard" : "Discarded", 1821 ((longlong_t)loss + 30) / 60); 1822 (void) printf(dgettext(TEXT_DOMAIN, 1823 "minutes of transactions.\n")); 1824 } else if (loss > 0) { 1825 (void) printf(dgettext(TEXT_DOMAIN, 1826 "%s approximately %lld "), 1827 dryrun ? "Would discard" : "Discarded", 1828 (longlong_t)loss); 1829 (void) printf(dgettext(TEXT_DOMAIN, 1830 "seconds of transactions.\n")); 1831 } 1832 } 1833 } 1834 1835 void 1836 zpool_explain_recover(libzfs_handle_t *hdl, const char *name, int reason, 1837 nvlist_t *config) 1838 { 1839 nvlist_t *nv = NULL; 1840 int64_t loss = -1; 1841 uint64_t edata = UINT64_MAX; 1842 uint64_t rewindto; 1843 struct tm t; 1844 char timestr[128]; 1845 1846 if (!hdl->libzfs_printerr) 1847 return; 1848 1849 if (reason >= 0) 1850 (void) printf(dgettext(TEXT_DOMAIN, "action: ")); 1851 else 1852 (void) printf(dgettext(TEXT_DOMAIN, "\t")); 1853 1854 /* All attempted rewinds failed if ZPOOL_CONFIG_LOAD_TIME missing */ 1855 if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_LOAD_INFO, &nv) != 0 || 1856 nvlist_lookup_nvlist(nv, ZPOOL_CONFIG_REWIND_INFO, &nv) != 0 || 1857 nvlist_lookup_uint64(nv, ZPOOL_CONFIG_LOAD_TIME, &rewindto) != 0) 1858 goto no_info; 1859 1860 (void) nvlist_lookup_int64(nv, ZPOOL_CONFIG_REWIND_TIME, &loss); 1861 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_LOAD_DATA_ERRORS, 1862 &edata); 1863 1864 (void) printf(dgettext(TEXT_DOMAIN, 1865 "Recovery is possible, but will result in some data loss.\n")); 1866 1867 if (localtime_r((time_t *)&rewindto, &t) != NULL && 1868 strftime(timestr, 128, "%c", &t) != 0) { 1869 (void) printf(dgettext(TEXT_DOMAIN, 1870 "\tReturning the pool to its state as of %s\n" 1871 "\tshould correct the problem. "), 1872 timestr); 1873 } else { 1874 (void) printf(dgettext(TEXT_DOMAIN, 1875 "\tReverting the pool to an earlier state " 1876 "should correct the problem.\n\t")); 1877 } 1878 1879 if (loss > 120) { 1880 (void) printf(dgettext(TEXT_DOMAIN, 1881 "Approximately %lld minutes of data\n" 1882 "\tmust be discarded, irreversibly. "), 1883 ((longlong_t)loss + 30) / 60); 1884 } else if (loss > 0) { 1885 (void) printf(dgettext(TEXT_DOMAIN, 1886 "Approximately %lld seconds of data\n" 1887 "\tmust be discarded, irreversibly. "), 1888 (longlong_t)loss); 1889 } 1890 if (edata != 0 && edata != UINT64_MAX) { 1891 if (edata == 1) { 1892 (void) printf(dgettext(TEXT_DOMAIN, 1893 "After rewind, at least\n" 1894 "\tone persistent user-data error will remain. ")); 1895 } else { 1896 (void) printf(dgettext(TEXT_DOMAIN, 1897 "After rewind, several\n" 1898 "\tpersistent user-data errors will remain. ")); 1899 } 1900 } 1901 (void) printf(dgettext(TEXT_DOMAIN, 1902 "Recovery can be attempted\n\tby executing 'zpool %s -F %s'. "), 1903 reason >= 0 ? "clear" : "import", name); 1904 1905 (void) printf(dgettext(TEXT_DOMAIN, 1906 "A scrub of the pool\n" 1907 "\tis strongly recommended after recovery.\n")); 1908 return; 1909 1910 no_info: 1911 (void) printf(dgettext(TEXT_DOMAIN, 1912 "Destroy and re-create the pool from\n\ta backup source.\n")); 1913 } 1914 1915 /* 1916 * zpool_import() is a contracted interface. Should be kept the same 1917 * if possible. 1918 * 1919 * Applications should use zpool_import_props() to import a pool with 1920 * new properties value to be set. 1921 */ 1922 int 1923 zpool_import(libzfs_handle_t *hdl, nvlist_t *config, const char *newname, 1924 char *altroot) 1925 { 1926 nvlist_t *props = NULL; 1927 int ret; 1928 1929 if (altroot != NULL) { 1930 if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0) { 1931 return (zfs_error_fmt(hdl, EZFS_NOMEM, 1932 dgettext(TEXT_DOMAIN, "cannot import '%s'"), 1933 newname)); 1934 } 1935 1936 if (nvlist_add_string(props, 1937 zpool_prop_to_name(ZPOOL_PROP_ALTROOT), altroot) != 0 || 1938 nvlist_add_string(props, 1939 zpool_prop_to_name(ZPOOL_PROP_CACHEFILE), "none") != 0) { 1940 nvlist_free(props); 1941 return (zfs_error_fmt(hdl, EZFS_NOMEM, 1942 dgettext(TEXT_DOMAIN, "cannot import '%s'"), 1943 newname)); 1944 } 1945 } 1946 1947 ret = zpool_import_props(hdl, config, newname, props, 1948 ZFS_IMPORT_NORMAL); 1949 nvlist_free(props); 1950 return (ret); 1951 } 1952 1953 static void 1954 print_vdev_tree(libzfs_handle_t *hdl, const char *name, nvlist_t *nv, 1955 int indent) 1956 { 1957 nvlist_t **child; 1958 uint_t c, children; 1959 char *vname; 1960 uint64_t is_log = 0; 1961 1962 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_IS_LOG, 1963 &is_log); 1964 1965 if (name != NULL) 1966 (void) printf("\t%*s%s%s\n", indent, "", name, 1967 is_log ? " [log]" : ""); 1968 1969 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 1970 &child, &children) != 0) 1971 return; 1972 1973 for (c = 0; c < children; c++) { 1974 vname = zpool_vdev_name(hdl, NULL, child[c], VDEV_NAME_TYPE_ID); 1975 print_vdev_tree(hdl, vname, child[c], indent + 2); 1976 free(vname); 1977 } 1978 } 1979 1980 void 1981 zpool_print_unsup_feat(nvlist_t *config) 1982 { 1983 nvlist_t *nvinfo, *unsup_feat; 1984 1985 nvinfo = fnvlist_lookup_nvlist(config, ZPOOL_CONFIG_LOAD_INFO); 1986 unsup_feat = fnvlist_lookup_nvlist(nvinfo, ZPOOL_CONFIG_UNSUP_FEAT); 1987 1988 for (nvpair_t *nvp = nvlist_next_nvpair(unsup_feat, NULL); 1989 nvp != NULL; nvp = nvlist_next_nvpair(unsup_feat, nvp)) { 1990 const char *desc = fnvpair_value_string(nvp); 1991 if (strlen(desc) > 0) 1992 (void) printf("\t%s (%s)\n", nvpair_name(nvp), desc); 1993 else 1994 (void) printf("\t%s\n", nvpair_name(nvp)); 1995 } 1996 } 1997 1998 /* 1999 * Import the given pool using the known configuration and a list of 2000 * properties to be set. The configuration should have come from 2001 * zpool_find_import(). The 'newname' parameters control whether the pool 2002 * is imported with a different name. 2003 */ 2004 int 2005 zpool_import_props(libzfs_handle_t *hdl, nvlist_t *config, const char *newname, 2006 nvlist_t *props, int flags) 2007 { 2008 zfs_cmd_t zc = {"\0"}; 2009 zpool_load_policy_t policy; 2010 nvlist_t *nv = NULL; 2011 nvlist_t *nvinfo = NULL; 2012 nvlist_t *missing = NULL; 2013 const char *thename; 2014 const char *origname; 2015 int ret; 2016 int error = 0; 2017 char errbuf[ERRBUFLEN]; 2018 2019 origname = fnvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME); 2020 2021 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 2022 "cannot import pool '%s'"), origname); 2023 2024 if (newname != NULL) { 2025 if (!zpool_name_valid(hdl, B_FALSE, newname)) 2026 return (zfs_error_fmt(hdl, EZFS_INVALIDNAME, 2027 dgettext(TEXT_DOMAIN, "cannot import '%s'"), 2028 newname)); 2029 thename = newname; 2030 } else { 2031 thename = origname; 2032 } 2033 2034 if (props != NULL) { 2035 uint64_t version; 2036 prop_flags_t flags = { .create = B_FALSE, .import = B_TRUE }; 2037 2038 version = fnvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION); 2039 2040 if ((props = zpool_valid_proplist(hdl, origname, 2041 props, version, flags, errbuf)) == NULL) 2042 return (-1); 2043 zcmd_write_src_nvlist(hdl, &zc, props); 2044 nvlist_free(props); 2045 } 2046 2047 (void) strlcpy(zc.zc_name, thename, sizeof (zc.zc_name)); 2048 2049 zc.zc_guid = fnvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID); 2050 2051 zcmd_write_conf_nvlist(hdl, &zc, config); 2052 zcmd_alloc_dst_nvlist(hdl, &zc, zc.zc_nvlist_conf_size * 2); 2053 2054 zc.zc_cookie = flags; 2055 while ((ret = zfs_ioctl(hdl, ZFS_IOC_POOL_IMPORT, &zc)) != 0 && 2056 errno == ENOMEM) 2057 zcmd_expand_dst_nvlist(hdl, &zc); 2058 if (ret != 0) 2059 error = errno; 2060 2061 (void) zcmd_read_dst_nvlist(hdl, &zc, &nv); 2062 2063 zcmd_free_nvlists(&zc); 2064 2065 zpool_get_load_policy(config, &policy); 2066 2067 if (error) { 2068 char desc[1024]; 2069 char aux[256]; 2070 2071 /* 2072 * Dry-run failed, but we print out what success 2073 * looks like if we found a best txg 2074 */ 2075 if (policy.zlp_rewind & ZPOOL_TRY_REWIND) { 2076 zpool_rewind_exclaim(hdl, newname ? origname : thename, 2077 B_TRUE, nv); 2078 nvlist_free(nv); 2079 return (-1); 2080 } 2081 2082 if (newname == NULL) 2083 (void) snprintf(desc, sizeof (desc), 2084 dgettext(TEXT_DOMAIN, "cannot import '%s'"), 2085 thename); 2086 else 2087 (void) snprintf(desc, sizeof (desc), 2088 dgettext(TEXT_DOMAIN, "cannot import '%s' as '%s'"), 2089 origname, thename); 2090 2091 switch (error) { 2092 case ENOTSUP: 2093 if (nv != NULL && nvlist_lookup_nvlist(nv, 2094 ZPOOL_CONFIG_LOAD_INFO, &nvinfo) == 0 && 2095 nvlist_exists(nvinfo, ZPOOL_CONFIG_UNSUP_FEAT)) { 2096 (void) printf(dgettext(TEXT_DOMAIN, "This " 2097 "pool uses the following feature(s) not " 2098 "supported by this system:\n")); 2099 zpool_print_unsup_feat(nv); 2100 if (nvlist_exists(nvinfo, 2101 ZPOOL_CONFIG_CAN_RDONLY)) { 2102 (void) printf(dgettext(TEXT_DOMAIN, 2103 "All unsupported features are only " 2104 "required for writing to the pool." 2105 "\nThe pool can be imported using " 2106 "'-o readonly=on'.\n")); 2107 } 2108 } 2109 /* 2110 * Unsupported version. 2111 */ 2112 (void) zfs_error(hdl, EZFS_BADVERSION, desc); 2113 break; 2114 2115 case EREMOTEIO: 2116 if (nv != NULL && nvlist_lookup_nvlist(nv, 2117 ZPOOL_CONFIG_LOAD_INFO, &nvinfo) == 0) { 2118 const char *hostname = "<unknown>"; 2119 uint64_t hostid = 0; 2120 mmp_state_t mmp_state; 2121 2122 mmp_state = fnvlist_lookup_uint64(nvinfo, 2123 ZPOOL_CONFIG_MMP_STATE); 2124 2125 if (nvlist_exists(nvinfo, 2126 ZPOOL_CONFIG_MMP_HOSTNAME)) 2127 hostname = fnvlist_lookup_string(nvinfo, 2128 ZPOOL_CONFIG_MMP_HOSTNAME); 2129 2130 if (nvlist_exists(nvinfo, 2131 ZPOOL_CONFIG_MMP_HOSTID)) 2132 hostid = fnvlist_lookup_uint64(nvinfo, 2133 ZPOOL_CONFIG_MMP_HOSTID); 2134 2135 if (mmp_state == MMP_STATE_ACTIVE) { 2136 (void) snprintf(aux, sizeof (aux), 2137 dgettext(TEXT_DOMAIN, "pool is imp" 2138 "orted on host '%s' (hostid=%lx).\n" 2139 "Export the pool on the other " 2140 "system, then run 'zpool import'."), 2141 hostname, (unsigned long) hostid); 2142 } else if (mmp_state == MMP_STATE_NO_HOSTID) { 2143 (void) snprintf(aux, sizeof (aux), 2144 dgettext(TEXT_DOMAIN, "pool has " 2145 "the multihost property on and " 2146 "the\nsystem's hostid is not set. " 2147 "Set a unique system hostid with " 2148 "the zgenhostid(8) command.\n")); 2149 } 2150 2151 (void) zfs_error_aux(hdl, "%s", aux); 2152 } 2153 (void) zfs_error(hdl, EZFS_ACTIVE_POOL, desc); 2154 break; 2155 2156 case EINVAL: 2157 (void) zfs_error(hdl, EZFS_INVALCONFIG, desc); 2158 break; 2159 2160 case EROFS: 2161 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 2162 "one or more devices is read only")); 2163 (void) zfs_error(hdl, EZFS_BADDEV, desc); 2164 break; 2165 2166 case ENXIO: 2167 if (nv && nvlist_lookup_nvlist(nv, 2168 ZPOOL_CONFIG_LOAD_INFO, &nvinfo) == 0 && 2169 nvlist_lookup_nvlist(nvinfo, 2170 ZPOOL_CONFIG_MISSING_DEVICES, &missing) == 0) { 2171 (void) printf(dgettext(TEXT_DOMAIN, 2172 "The devices below are missing or " 2173 "corrupted, use '-m' to import the pool " 2174 "anyway:\n")); 2175 print_vdev_tree(hdl, NULL, missing, 2); 2176 (void) printf("\n"); 2177 } 2178 (void) zpool_standard_error(hdl, error, desc); 2179 break; 2180 2181 case EEXIST: 2182 (void) zpool_standard_error(hdl, error, desc); 2183 break; 2184 2185 case EBUSY: 2186 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 2187 "one or more devices are already in use\n")); 2188 (void) zfs_error(hdl, EZFS_BADDEV, desc); 2189 break; 2190 case ENAMETOOLONG: 2191 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 2192 "new name of at least one dataset is longer than " 2193 "the maximum allowable length")); 2194 (void) zfs_error(hdl, EZFS_NAMETOOLONG, desc); 2195 break; 2196 default: 2197 (void) zpool_standard_error(hdl, error, desc); 2198 zpool_explain_recover(hdl, 2199 newname ? origname : thename, -error, nv); 2200 break; 2201 } 2202 2203 nvlist_free(nv); 2204 ret = -1; 2205 } else { 2206 zpool_handle_t *zhp; 2207 2208 /* 2209 * This should never fail, but play it safe anyway. 2210 */ 2211 if (zpool_open_silent(hdl, thename, &zhp) != 0) 2212 ret = -1; 2213 else if (zhp != NULL) 2214 zpool_close(zhp); 2215 if (policy.zlp_rewind & 2216 (ZPOOL_DO_REWIND | ZPOOL_TRY_REWIND)) { 2217 zpool_rewind_exclaim(hdl, newname ? origname : thename, 2218 ((policy.zlp_rewind & ZPOOL_TRY_REWIND) != 0), nv); 2219 } 2220 nvlist_free(nv); 2221 } 2222 2223 return (ret); 2224 } 2225 2226 /* 2227 * Translate vdev names to guids. If a vdev_path is determined to be 2228 * unsuitable then a vd_errlist is allocated and the vdev path and errno 2229 * are added to it. 2230 */ 2231 static int 2232 zpool_translate_vdev_guids(zpool_handle_t *zhp, nvlist_t *vds, 2233 nvlist_t *vdev_guids, nvlist_t *guids_to_paths, nvlist_t **vd_errlist) 2234 { 2235 nvlist_t *errlist = NULL; 2236 int error = 0; 2237 2238 for (nvpair_t *elem = nvlist_next_nvpair(vds, NULL); elem != NULL; 2239 elem = nvlist_next_nvpair(vds, elem)) { 2240 boolean_t spare, cache; 2241 2242 const char *vd_path = nvpair_name(elem); 2243 nvlist_t *tgt = zpool_find_vdev(zhp, vd_path, &spare, &cache, 2244 NULL); 2245 2246 if ((tgt == NULL) || cache || spare) { 2247 if (errlist == NULL) { 2248 errlist = fnvlist_alloc(); 2249 error = EINVAL; 2250 } 2251 2252 uint64_t err = (tgt == NULL) ? EZFS_NODEVICE : 2253 (spare ? EZFS_ISSPARE : EZFS_ISL2CACHE); 2254 fnvlist_add_int64(errlist, vd_path, err); 2255 continue; 2256 } 2257 2258 uint64_t guid = fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID); 2259 fnvlist_add_uint64(vdev_guids, vd_path, guid); 2260 2261 char msg[MAXNAMELEN]; 2262 (void) snprintf(msg, sizeof (msg), "%llu", (u_longlong_t)guid); 2263 fnvlist_add_string(guids_to_paths, msg, vd_path); 2264 } 2265 2266 if (error != 0) { 2267 verify(errlist != NULL); 2268 if (vd_errlist != NULL) 2269 *vd_errlist = errlist; 2270 else 2271 fnvlist_free(errlist); 2272 } 2273 2274 return (error); 2275 } 2276 2277 static int 2278 xlate_init_err(int err) 2279 { 2280 switch (err) { 2281 case ENODEV: 2282 return (EZFS_NODEVICE); 2283 case EINVAL: 2284 case EROFS: 2285 return (EZFS_BADDEV); 2286 case EBUSY: 2287 return (EZFS_INITIALIZING); 2288 case ESRCH: 2289 return (EZFS_NO_INITIALIZE); 2290 } 2291 return (err); 2292 } 2293 2294 /* 2295 * Begin, suspend, or cancel the initialization (initializing of all free 2296 * blocks) for the given vdevs in the given pool. 2297 */ 2298 static int 2299 zpool_initialize_impl(zpool_handle_t *zhp, pool_initialize_func_t cmd_type, 2300 nvlist_t *vds, boolean_t wait) 2301 { 2302 int err; 2303 2304 nvlist_t *vdev_guids = fnvlist_alloc(); 2305 nvlist_t *guids_to_paths = fnvlist_alloc(); 2306 nvlist_t *vd_errlist = NULL; 2307 nvlist_t *errlist; 2308 nvpair_t *elem; 2309 2310 err = zpool_translate_vdev_guids(zhp, vds, vdev_guids, 2311 guids_to_paths, &vd_errlist); 2312 2313 if (err != 0) { 2314 verify(vd_errlist != NULL); 2315 goto list_errors; 2316 } 2317 2318 err = lzc_initialize(zhp->zpool_name, cmd_type, 2319 vdev_guids, &errlist); 2320 2321 if (err != 0) { 2322 if (errlist != NULL) { 2323 vd_errlist = fnvlist_lookup_nvlist(errlist, 2324 ZPOOL_INITIALIZE_VDEVS); 2325 goto list_errors; 2326 } 2327 (void) zpool_standard_error(zhp->zpool_hdl, err, 2328 dgettext(TEXT_DOMAIN, "operation failed")); 2329 goto out; 2330 } 2331 2332 if (wait) { 2333 for (elem = nvlist_next_nvpair(vdev_guids, NULL); elem != NULL; 2334 elem = nvlist_next_nvpair(vdev_guids, elem)) { 2335 2336 uint64_t guid = fnvpair_value_uint64(elem); 2337 2338 err = lzc_wait_tag(zhp->zpool_name, 2339 ZPOOL_WAIT_INITIALIZE, guid, NULL); 2340 if (err != 0) { 2341 (void) zpool_standard_error_fmt(zhp->zpool_hdl, 2342 err, dgettext(TEXT_DOMAIN, "error " 2343 "waiting for '%s' to initialize"), 2344 nvpair_name(elem)); 2345 2346 goto out; 2347 } 2348 } 2349 } 2350 goto out; 2351 2352 list_errors: 2353 for (elem = nvlist_next_nvpair(vd_errlist, NULL); elem != NULL; 2354 elem = nvlist_next_nvpair(vd_errlist, elem)) { 2355 int64_t vd_error = xlate_init_err(fnvpair_value_int64(elem)); 2356 const char *path; 2357 2358 if (nvlist_lookup_string(guids_to_paths, nvpair_name(elem), 2359 &path) != 0) 2360 path = nvpair_name(elem); 2361 2362 (void) zfs_error_fmt(zhp->zpool_hdl, vd_error, 2363 "cannot initialize '%s'", path); 2364 } 2365 2366 out: 2367 fnvlist_free(vdev_guids); 2368 fnvlist_free(guids_to_paths); 2369 2370 if (vd_errlist != NULL) 2371 fnvlist_free(vd_errlist); 2372 2373 return (err == 0 ? 0 : -1); 2374 } 2375 2376 int 2377 zpool_initialize(zpool_handle_t *zhp, pool_initialize_func_t cmd_type, 2378 nvlist_t *vds) 2379 { 2380 return (zpool_initialize_impl(zhp, cmd_type, vds, B_FALSE)); 2381 } 2382 2383 int 2384 zpool_initialize_wait(zpool_handle_t *zhp, pool_initialize_func_t cmd_type, 2385 nvlist_t *vds) 2386 { 2387 return (zpool_initialize_impl(zhp, cmd_type, vds, B_TRUE)); 2388 } 2389 2390 static int 2391 xlate_trim_err(int err) 2392 { 2393 switch (err) { 2394 case ENODEV: 2395 return (EZFS_NODEVICE); 2396 case EINVAL: 2397 case EROFS: 2398 return (EZFS_BADDEV); 2399 case EBUSY: 2400 return (EZFS_TRIMMING); 2401 case ESRCH: 2402 return (EZFS_NO_TRIM); 2403 case EOPNOTSUPP: 2404 return (EZFS_TRIM_NOTSUP); 2405 } 2406 return (err); 2407 } 2408 2409 static int 2410 zpool_trim_wait(zpool_handle_t *zhp, nvlist_t *vdev_guids) 2411 { 2412 int err; 2413 nvpair_t *elem; 2414 2415 for (elem = nvlist_next_nvpair(vdev_guids, NULL); elem != NULL; 2416 elem = nvlist_next_nvpair(vdev_guids, elem)) { 2417 2418 uint64_t guid = fnvpair_value_uint64(elem); 2419 2420 err = lzc_wait_tag(zhp->zpool_name, 2421 ZPOOL_WAIT_TRIM, guid, NULL); 2422 if (err != 0) { 2423 (void) zpool_standard_error_fmt(zhp->zpool_hdl, 2424 err, dgettext(TEXT_DOMAIN, "error " 2425 "waiting to trim '%s'"), nvpair_name(elem)); 2426 2427 return (err); 2428 } 2429 } 2430 return (0); 2431 } 2432 2433 /* 2434 * Check errlist and report any errors, omitting ones which should be 2435 * suppressed. Returns B_TRUE if any errors were reported. 2436 */ 2437 static boolean_t 2438 check_trim_errs(zpool_handle_t *zhp, trimflags_t *trim_flags, 2439 nvlist_t *guids_to_paths, nvlist_t *vds, nvlist_t *errlist) 2440 { 2441 nvpair_t *elem; 2442 boolean_t reported_errs = B_FALSE; 2443 int num_vds = 0; 2444 int num_suppressed_errs = 0; 2445 2446 for (elem = nvlist_next_nvpair(vds, NULL); 2447 elem != NULL; elem = nvlist_next_nvpair(vds, elem)) { 2448 num_vds++; 2449 } 2450 2451 for (elem = nvlist_next_nvpair(errlist, NULL); 2452 elem != NULL; elem = nvlist_next_nvpair(errlist, elem)) { 2453 int64_t vd_error = xlate_trim_err(fnvpair_value_int64(elem)); 2454 const char *path; 2455 2456 /* 2457 * If only the pool was specified, and it was not a secure 2458 * trim then suppress warnings for individual vdevs which 2459 * do not support trimming. 2460 */ 2461 if (vd_error == EZFS_TRIM_NOTSUP && 2462 trim_flags->fullpool && 2463 !trim_flags->secure) { 2464 num_suppressed_errs++; 2465 continue; 2466 } 2467 2468 reported_errs = B_TRUE; 2469 if (nvlist_lookup_string(guids_to_paths, nvpair_name(elem), 2470 &path) != 0) 2471 path = nvpair_name(elem); 2472 2473 (void) zfs_error_fmt(zhp->zpool_hdl, vd_error, 2474 "cannot trim '%s'", path); 2475 } 2476 2477 if (num_suppressed_errs == num_vds) { 2478 (void) zfs_error_aux(zhp->zpool_hdl, dgettext(TEXT_DOMAIN, 2479 "no devices in pool support trim operations")); 2480 (void) (zfs_error(zhp->zpool_hdl, EZFS_TRIM_NOTSUP, 2481 dgettext(TEXT_DOMAIN, "cannot trim"))); 2482 reported_errs = B_TRUE; 2483 } 2484 2485 return (reported_errs); 2486 } 2487 2488 /* 2489 * Begin, suspend, or cancel the TRIM (discarding of all free blocks) for 2490 * the given vdevs in the given pool. 2491 */ 2492 int 2493 zpool_trim(zpool_handle_t *zhp, pool_trim_func_t cmd_type, nvlist_t *vds, 2494 trimflags_t *trim_flags) 2495 { 2496 int err; 2497 int retval = 0; 2498 2499 nvlist_t *vdev_guids = fnvlist_alloc(); 2500 nvlist_t *guids_to_paths = fnvlist_alloc(); 2501 nvlist_t *errlist = NULL; 2502 2503 err = zpool_translate_vdev_guids(zhp, vds, vdev_guids, 2504 guids_to_paths, &errlist); 2505 if (err != 0) { 2506 check_trim_errs(zhp, trim_flags, guids_to_paths, vds, errlist); 2507 retval = -1; 2508 goto out; 2509 } 2510 2511 err = lzc_trim(zhp->zpool_name, cmd_type, trim_flags->rate, 2512 trim_flags->secure, vdev_guids, &errlist); 2513 if (err != 0) { 2514 nvlist_t *vd_errlist; 2515 if (errlist != NULL && nvlist_lookup_nvlist(errlist, 2516 ZPOOL_TRIM_VDEVS, &vd_errlist) == 0) { 2517 if (check_trim_errs(zhp, trim_flags, guids_to_paths, 2518 vds, vd_errlist)) { 2519 retval = -1; 2520 goto out; 2521 } 2522 } else { 2523 char errbuf[ERRBUFLEN]; 2524 2525 (void) snprintf(errbuf, sizeof (errbuf), 2526 dgettext(TEXT_DOMAIN, "operation failed")); 2527 zpool_standard_error(zhp->zpool_hdl, err, errbuf); 2528 retval = -1; 2529 goto out; 2530 } 2531 } 2532 2533 2534 if (trim_flags->wait) 2535 retval = zpool_trim_wait(zhp, vdev_guids); 2536 2537 out: 2538 if (errlist != NULL) 2539 fnvlist_free(errlist); 2540 fnvlist_free(vdev_guids); 2541 fnvlist_free(guids_to_paths); 2542 return (retval); 2543 } 2544 2545 /* 2546 * Scan the pool. 2547 */ 2548 int 2549 zpool_scan(zpool_handle_t *zhp, pool_scan_func_t func, pool_scrub_cmd_t cmd) 2550 { 2551 zfs_cmd_t zc = {"\0"}; 2552 char errbuf[ERRBUFLEN]; 2553 int err; 2554 libzfs_handle_t *hdl = zhp->zpool_hdl; 2555 2556 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name)); 2557 zc.zc_cookie = func; 2558 zc.zc_flags = cmd; 2559 2560 if (zfs_ioctl(hdl, ZFS_IOC_POOL_SCAN, &zc) == 0) 2561 return (0); 2562 2563 err = errno; 2564 2565 /* ECANCELED on a scrub means we resumed a paused scrub */ 2566 if (err == ECANCELED && func == POOL_SCAN_SCRUB && 2567 cmd == POOL_SCRUB_NORMAL) 2568 return (0); 2569 2570 if (err == ENOENT && func != POOL_SCAN_NONE && cmd == POOL_SCRUB_NORMAL) 2571 return (0); 2572 2573 if (func == POOL_SCAN_SCRUB) { 2574 if (cmd == POOL_SCRUB_PAUSE) { 2575 (void) snprintf(errbuf, sizeof (errbuf), 2576 dgettext(TEXT_DOMAIN, "cannot pause scrubbing %s"), 2577 zc.zc_name); 2578 } else { 2579 assert(cmd == POOL_SCRUB_NORMAL); 2580 (void) snprintf(errbuf, sizeof (errbuf), 2581 dgettext(TEXT_DOMAIN, "cannot scrub %s"), 2582 zc.zc_name); 2583 } 2584 } else if (func == POOL_SCAN_RESILVER) { 2585 assert(cmd == POOL_SCRUB_NORMAL); 2586 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 2587 "cannot restart resilver on %s"), zc.zc_name); 2588 } else if (func == POOL_SCAN_NONE) { 2589 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 2590 "cannot cancel scrubbing %s"), zc.zc_name); 2591 } else { 2592 assert(!"unexpected result"); 2593 } 2594 2595 if (err == EBUSY) { 2596 nvlist_t *nvroot; 2597 pool_scan_stat_t *ps = NULL; 2598 uint_t psc; 2599 2600 nvroot = fnvlist_lookup_nvlist(zhp->zpool_config, 2601 ZPOOL_CONFIG_VDEV_TREE); 2602 (void) nvlist_lookup_uint64_array(nvroot, 2603 ZPOOL_CONFIG_SCAN_STATS, (uint64_t **)&ps, &psc); 2604 if (ps && ps->pss_func == POOL_SCAN_SCRUB && 2605 ps->pss_state == DSS_SCANNING) { 2606 if (cmd == POOL_SCRUB_PAUSE) 2607 return (zfs_error(hdl, EZFS_SCRUB_PAUSED, 2608 errbuf)); 2609 else 2610 return (zfs_error(hdl, EZFS_SCRUBBING, errbuf)); 2611 } else { 2612 return (zfs_error(hdl, EZFS_RESILVERING, errbuf)); 2613 } 2614 } else if (err == ENOENT) { 2615 return (zfs_error(hdl, EZFS_NO_SCRUB, errbuf)); 2616 } else if (err == ENOTSUP && func == POOL_SCAN_RESILVER) { 2617 return (zfs_error(hdl, EZFS_NO_RESILVER_DEFER, errbuf)); 2618 } else { 2619 return (zpool_standard_error(hdl, err, errbuf)); 2620 } 2621 } 2622 2623 /* 2624 * Find a vdev that matches the search criteria specified. We use the 2625 * the nvpair name to determine how we should look for the device. 2626 * 'avail_spare' is set to TRUE if the provided guid refers to an AVAIL 2627 * spare; but FALSE if its an INUSE spare. 2628 */ 2629 static nvlist_t * 2630 vdev_to_nvlist_iter(nvlist_t *nv, nvlist_t *search, boolean_t *avail_spare, 2631 boolean_t *l2cache, boolean_t *log) 2632 { 2633 uint_t c, children; 2634 nvlist_t **child; 2635 nvlist_t *ret; 2636 uint64_t is_log; 2637 const char *srchkey; 2638 nvpair_t *pair = nvlist_next_nvpair(search, NULL); 2639 2640 /* Nothing to look for */ 2641 if (search == NULL || pair == NULL) 2642 return (NULL); 2643 2644 /* Obtain the key we will use to search */ 2645 srchkey = nvpair_name(pair); 2646 2647 switch (nvpair_type(pair)) { 2648 case DATA_TYPE_UINT64: 2649 if (strcmp(srchkey, ZPOOL_CONFIG_GUID) == 0) { 2650 uint64_t srchval = fnvpair_value_uint64(pair); 2651 uint64_t theguid = fnvlist_lookup_uint64(nv, 2652 ZPOOL_CONFIG_GUID); 2653 if (theguid == srchval) 2654 return (nv); 2655 } 2656 break; 2657 2658 case DATA_TYPE_STRING: { 2659 const char *srchval, *val; 2660 2661 srchval = fnvpair_value_string(pair); 2662 if (nvlist_lookup_string(nv, srchkey, &val) != 0) 2663 break; 2664 2665 /* 2666 * Search for the requested value. Special cases: 2667 * 2668 * - ZPOOL_CONFIG_PATH for whole disk entries. These end in 2669 * "-part1", or "p1". The suffix is hidden from the user, 2670 * but included in the string, so this matches around it. 2671 * - ZPOOL_CONFIG_PATH for short names zfs_strcmp_shortname() 2672 * is used to check all possible expanded paths. 2673 * - looking for a top-level vdev name (i.e. ZPOOL_CONFIG_TYPE). 2674 * 2675 * Otherwise, all other searches are simple string compares. 2676 */ 2677 if (strcmp(srchkey, ZPOOL_CONFIG_PATH) == 0) { 2678 uint64_t wholedisk = 0; 2679 2680 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_WHOLE_DISK, 2681 &wholedisk); 2682 if (zfs_strcmp_pathname(srchval, val, wholedisk) == 0) 2683 return (nv); 2684 2685 } else if (strcmp(srchkey, ZPOOL_CONFIG_TYPE) == 0) { 2686 char *type, *idx, *end, *p; 2687 uint64_t id, vdev_id; 2688 2689 /* 2690 * Determine our vdev type, keeping in mind 2691 * that the srchval is composed of a type and 2692 * vdev id pair (i.e. mirror-4). 2693 */ 2694 if ((type = strdup(srchval)) == NULL) 2695 return (NULL); 2696 2697 if ((p = strrchr(type, '-')) == NULL) { 2698 free(type); 2699 break; 2700 } 2701 idx = p + 1; 2702 *p = '\0'; 2703 2704 /* 2705 * If the types don't match then keep looking. 2706 */ 2707 if (strncmp(val, type, strlen(val)) != 0) { 2708 free(type); 2709 break; 2710 } 2711 2712 verify(zpool_vdev_is_interior(type)); 2713 2714 id = fnvlist_lookup_uint64(nv, ZPOOL_CONFIG_ID); 2715 errno = 0; 2716 vdev_id = strtoull(idx, &end, 10); 2717 2718 /* 2719 * If we are looking for a raidz and a parity is 2720 * specified, make sure it matches. 2721 */ 2722 int rzlen = strlen(VDEV_TYPE_RAIDZ); 2723 assert(rzlen == strlen(VDEV_TYPE_DRAID)); 2724 int typlen = strlen(type); 2725 if ((strncmp(type, VDEV_TYPE_RAIDZ, rzlen) == 0 || 2726 strncmp(type, VDEV_TYPE_DRAID, rzlen) == 0) && 2727 typlen != rzlen) { 2728 uint64_t vdev_parity; 2729 int parity = *(type + rzlen) - '0'; 2730 2731 if (parity <= 0 || parity > 3 || 2732 (typlen - rzlen) != 1) { 2733 /* 2734 * Nonsense parity specified, can 2735 * never match 2736 */ 2737 free(type); 2738 return (NULL); 2739 } 2740 vdev_parity = fnvlist_lookup_uint64(nv, 2741 ZPOOL_CONFIG_NPARITY); 2742 if ((int)vdev_parity != parity) { 2743 free(type); 2744 break; 2745 } 2746 } 2747 2748 free(type); 2749 if (errno != 0) 2750 return (NULL); 2751 2752 /* 2753 * Now verify that we have the correct vdev id. 2754 */ 2755 if (vdev_id == id) 2756 return (nv); 2757 } 2758 2759 /* 2760 * Common case 2761 */ 2762 if (strcmp(srchval, val) == 0) 2763 return (nv); 2764 break; 2765 } 2766 2767 default: 2768 break; 2769 } 2770 2771 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, 2772 &child, &children) != 0) 2773 return (NULL); 2774 2775 for (c = 0; c < children; c++) { 2776 if ((ret = vdev_to_nvlist_iter(child[c], search, 2777 avail_spare, l2cache, NULL)) != NULL) { 2778 /* 2779 * The 'is_log' value is only set for the toplevel 2780 * vdev, not the leaf vdevs. So we always lookup the 2781 * log device from the root of the vdev tree (where 2782 * 'log' is non-NULL). 2783 */ 2784 if (log != NULL && 2785 nvlist_lookup_uint64(child[c], 2786 ZPOOL_CONFIG_IS_LOG, &is_log) == 0 && 2787 is_log) { 2788 *log = B_TRUE; 2789 } 2790 return (ret); 2791 } 2792 } 2793 2794 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES, 2795 &child, &children) == 0) { 2796 for (c = 0; c < children; c++) { 2797 if ((ret = vdev_to_nvlist_iter(child[c], search, 2798 avail_spare, l2cache, NULL)) != NULL) { 2799 *avail_spare = B_TRUE; 2800 return (ret); 2801 } 2802 } 2803 } 2804 2805 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE, 2806 &child, &children) == 0) { 2807 for (c = 0; c < children; c++) { 2808 if ((ret = vdev_to_nvlist_iter(child[c], search, 2809 avail_spare, l2cache, NULL)) != NULL) { 2810 *l2cache = B_TRUE; 2811 return (ret); 2812 } 2813 } 2814 } 2815 2816 return (NULL); 2817 } 2818 2819 /* 2820 * Given a physical path or guid, find the associated vdev. 2821 */ 2822 nvlist_t * 2823 zpool_find_vdev_by_physpath(zpool_handle_t *zhp, const char *ppath, 2824 boolean_t *avail_spare, boolean_t *l2cache, boolean_t *log) 2825 { 2826 nvlist_t *search, *nvroot, *ret; 2827 uint64_t guid; 2828 char *end; 2829 2830 search = fnvlist_alloc(); 2831 2832 guid = strtoull(ppath, &end, 0); 2833 if (guid != 0 && *end == '\0') { 2834 fnvlist_add_uint64(search, ZPOOL_CONFIG_GUID, guid); 2835 } else { 2836 fnvlist_add_string(search, ZPOOL_CONFIG_PHYS_PATH, ppath); 2837 } 2838 2839 nvroot = fnvlist_lookup_nvlist(zhp->zpool_config, 2840 ZPOOL_CONFIG_VDEV_TREE); 2841 2842 *avail_spare = B_FALSE; 2843 *l2cache = B_FALSE; 2844 if (log != NULL) 2845 *log = B_FALSE; 2846 ret = vdev_to_nvlist_iter(nvroot, search, avail_spare, l2cache, log); 2847 fnvlist_free(search); 2848 2849 return (ret); 2850 } 2851 2852 /* 2853 * Determine if we have an "interior" top-level vdev (i.e mirror/raidz). 2854 */ 2855 static boolean_t 2856 zpool_vdev_is_interior(const char *name) 2857 { 2858 if (strncmp(name, VDEV_TYPE_RAIDZ, strlen(VDEV_TYPE_RAIDZ)) == 0 || 2859 strncmp(name, VDEV_TYPE_SPARE, strlen(VDEV_TYPE_SPARE)) == 0 || 2860 strncmp(name, 2861 VDEV_TYPE_REPLACING, strlen(VDEV_TYPE_REPLACING)) == 0 || 2862 strncmp(name, VDEV_TYPE_MIRROR, strlen(VDEV_TYPE_MIRROR)) == 0) 2863 return (B_TRUE); 2864 2865 if (strncmp(name, VDEV_TYPE_DRAID, strlen(VDEV_TYPE_DRAID)) == 0 && 2866 !zpool_is_draid_spare(name)) 2867 return (B_TRUE); 2868 2869 return (B_FALSE); 2870 } 2871 2872 nvlist_t * 2873 zpool_find_vdev(zpool_handle_t *zhp, const char *path, boolean_t *avail_spare, 2874 boolean_t *l2cache, boolean_t *log) 2875 { 2876 char *end; 2877 nvlist_t *nvroot, *search, *ret; 2878 uint64_t guid; 2879 2880 search = fnvlist_alloc(); 2881 2882 guid = strtoull(path, &end, 0); 2883 if (guid != 0 && *end == '\0') { 2884 fnvlist_add_uint64(search, ZPOOL_CONFIG_GUID, guid); 2885 } else if (zpool_vdev_is_interior(path)) { 2886 fnvlist_add_string(search, ZPOOL_CONFIG_TYPE, path); 2887 } else { 2888 fnvlist_add_string(search, ZPOOL_CONFIG_PATH, path); 2889 } 2890 2891 nvroot = fnvlist_lookup_nvlist(zhp->zpool_config, 2892 ZPOOL_CONFIG_VDEV_TREE); 2893 2894 *avail_spare = B_FALSE; 2895 *l2cache = B_FALSE; 2896 if (log != NULL) 2897 *log = B_FALSE; 2898 ret = vdev_to_nvlist_iter(nvroot, search, avail_spare, l2cache, log); 2899 fnvlist_free(search); 2900 2901 return (ret); 2902 } 2903 2904 /* 2905 * Convert a vdev path to a GUID. Returns GUID or 0 on error. 2906 * 2907 * If is_spare, is_l2cache, or is_log is non-NULL, then store within it 2908 * if the VDEV is a spare, l2cache, or log device. If they're NULL then 2909 * ignore them. 2910 */ 2911 static uint64_t 2912 zpool_vdev_path_to_guid_impl(zpool_handle_t *zhp, const char *path, 2913 boolean_t *is_spare, boolean_t *is_l2cache, boolean_t *is_log) 2914 { 2915 boolean_t spare = B_FALSE, l2cache = B_FALSE, log = B_FALSE; 2916 nvlist_t *tgt; 2917 2918 if ((tgt = zpool_find_vdev(zhp, path, &spare, &l2cache, 2919 &log)) == NULL) 2920 return (0); 2921 2922 if (is_spare != NULL) 2923 *is_spare = spare; 2924 if (is_l2cache != NULL) 2925 *is_l2cache = l2cache; 2926 if (is_log != NULL) 2927 *is_log = log; 2928 2929 return (fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID)); 2930 } 2931 2932 /* Convert a vdev path to a GUID. Returns GUID or 0 on error. */ 2933 uint64_t 2934 zpool_vdev_path_to_guid(zpool_handle_t *zhp, const char *path) 2935 { 2936 return (zpool_vdev_path_to_guid_impl(zhp, path, NULL, NULL, NULL)); 2937 } 2938 2939 /* 2940 * Bring the specified vdev online. The 'flags' parameter is a set of the 2941 * ZFS_ONLINE_* flags. 2942 */ 2943 int 2944 zpool_vdev_online(zpool_handle_t *zhp, const char *path, int flags, 2945 vdev_state_t *newstate) 2946 { 2947 zfs_cmd_t zc = {"\0"}; 2948 char errbuf[ERRBUFLEN]; 2949 nvlist_t *tgt; 2950 boolean_t avail_spare, l2cache, islog; 2951 libzfs_handle_t *hdl = zhp->zpool_hdl; 2952 2953 if (flags & ZFS_ONLINE_EXPAND) { 2954 (void) snprintf(errbuf, sizeof (errbuf), 2955 dgettext(TEXT_DOMAIN, "cannot expand %s"), path); 2956 } else { 2957 (void) snprintf(errbuf, sizeof (errbuf), 2958 dgettext(TEXT_DOMAIN, "cannot online %s"), path); 2959 } 2960 2961 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name)); 2962 if ((tgt = zpool_find_vdev(zhp, path, &avail_spare, &l2cache, 2963 &islog)) == NULL) 2964 return (zfs_error(hdl, EZFS_NODEVICE, errbuf)); 2965 2966 zc.zc_guid = fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID); 2967 2968 if (!(flags & ZFS_ONLINE_SPARE) && avail_spare) 2969 return (zfs_error(hdl, EZFS_ISSPARE, errbuf)); 2970 2971 #ifndef __FreeBSD__ 2972 const char *pathname; 2973 if ((flags & ZFS_ONLINE_EXPAND || 2974 zpool_get_prop_int(zhp, ZPOOL_PROP_AUTOEXPAND, NULL)) && 2975 nvlist_lookup_string(tgt, ZPOOL_CONFIG_PATH, &pathname) == 0) { 2976 uint64_t wholedisk = 0; 2977 2978 (void) nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_WHOLE_DISK, 2979 &wholedisk); 2980 2981 /* 2982 * XXX - L2ARC 1.0 devices can't support expansion. 2983 */ 2984 if (l2cache) { 2985 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 2986 "cannot expand cache devices")); 2987 return (zfs_error(hdl, EZFS_VDEVNOTSUP, errbuf)); 2988 } 2989 2990 if (wholedisk) { 2991 const char *fullpath = path; 2992 char buf[MAXPATHLEN]; 2993 int error; 2994 2995 if (path[0] != '/') { 2996 error = zfs_resolve_shortname(path, buf, 2997 sizeof (buf)); 2998 if (error != 0) 2999 return (zfs_error(hdl, EZFS_NODEVICE, 3000 errbuf)); 3001 3002 fullpath = buf; 3003 } 3004 3005 error = zpool_relabel_disk(hdl, fullpath, errbuf); 3006 if (error != 0) 3007 return (error); 3008 } 3009 } 3010 #endif 3011 3012 zc.zc_cookie = VDEV_STATE_ONLINE; 3013 zc.zc_obj = flags; 3014 3015 if (zfs_ioctl(hdl, ZFS_IOC_VDEV_SET_STATE, &zc) != 0) { 3016 if (errno == EINVAL) { 3017 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "was split " 3018 "from this pool into a new one. Use '%s' " 3019 "instead"), "zpool detach"); 3020 return (zfs_error(hdl, EZFS_POSTSPLIT_ONLINE, errbuf)); 3021 } 3022 return (zpool_standard_error(hdl, errno, errbuf)); 3023 } 3024 3025 *newstate = zc.zc_cookie; 3026 return (0); 3027 } 3028 3029 /* 3030 * Take the specified vdev offline 3031 */ 3032 int 3033 zpool_vdev_offline(zpool_handle_t *zhp, const char *path, boolean_t istmp) 3034 { 3035 zfs_cmd_t zc = {"\0"}; 3036 char errbuf[ERRBUFLEN]; 3037 nvlist_t *tgt; 3038 boolean_t avail_spare, l2cache; 3039 libzfs_handle_t *hdl = zhp->zpool_hdl; 3040 3041 (void) snprintf(errbuf, sizeof (errbuf), 3042 dgettext(TEXT_DOMAIN, "cannot offline %s"), path); 3043 3044 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name)); 3045 if ((tgt = zpool_find_vdev(zhp, path, &avail_spare, &l2cache, 3046 NULL)) == NULL) 3047 return (zfs_error(hdl, EZFS_NODEVICE, errbuf)); 3048 3049 zc.zc_guid = fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID); 3050 3051 if (avail_spare) 3052 return (zfs_error(hdl, EZFS_ISSPARE, errbuf)); 3053 3054 zc.zc_cookie = VDEV_STATE_OFFLINE; 3055 zc.zc_obj = istmp ? ZFS_OFFLINE_TEMPORARY : 0; 3056 3057 if (zfs_ioctl(hdl, ZFS_IOC_VDEV_SET_STATE, &zc) == 0) 3058 return (0); 3059 3060 switch (errno) { 3061 case EBUSY: 3062 3063 /* 3064 * There are no other replicas of this device. 3065 */ 3066 return (zfs_error(hdl, EZFS_NOREPLICAS, errbuf)); 3067 3068 case EEXIST: 3069 /* 3070 * The log device has unplayed logs 3071 */ 3072 return (zfs_error(hdl, EZFS_UNPLAYED_LOGS, errbuf)); 3073 3074 default: 3075 return (zpool_standard_error(hdl, errno, errbuf)); 3076 } 3077 } 3078 3079 /* 3080 * Remove the specified vdev asynchronously from the configuration, so 3081 * that it may come ONLINE if reinserted. This is called from zed on 3082 * Udev remove event. 3083 * Note: We also have a similar function zpool_vdev_remove() that 3084 * removes the vdev from the pool. 3085 */ 3086 int 3087 zpool_vdev_remove_wanted(zpool_handle_t *zhp, const char *path) 3088 { 3089 zfs_cmd_t zc = {"\0"}; 3090 char errbuf[ERRBUFLEN]; 3091 nvlist_t *tgt; 3092 boolean_t avail_spare, l2cache; 3093 libzfs_handle_t *hdl = zhp->zpool_hdl; 3094 3095 (void) snprintf(errbuf, sizeof (errbuf), 3096 dgettext(TEXT_DOMAIN, "cannot remove %s"), path); 3097 3098 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name)); 3099 if ((tgt = zpool_find_vdev(zhp, path, &avail_spare, &l2cache, 3100 NULL)) == NULL) 3101 return (zfs_error(hdl, EZFS_NODEVICE, errbuf)); 3102 3103 zc.zc_guid = fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID); 3104 3105 zc.zc_cookie = VDEV_STATE_REMOVED; 3106 3107 if (zfs_ioctl(hdl, ZFS_IOC_VDEV_SET_STATE, &zc) == 0) 3108 return (0); 3109 3110 return (zpool_standard_error(hdl, errno, errbuf)); 3111 } 3112 3113 /* 3114 * Mark the given vdev faulted. 3115 */ 3116 int 3117 zpool_vdev_fault(zpool_handle_t *zhp, uint64_t guid, vdev_aux_t aux) 3118 { 3119 zfs_cmd_t zc = {"\0"}; 3120 char errbuf[ERRBUFLEN]; 3121 libzfs_handle_t *hdl = zhp->zpool_hdl; 3122 3123 (void) snprintf(errbuf, sizeof (errbuf), 3124 dgettext(TEXT_DOMAIN, "cannot fault %llu"), (u_longlong_t)guid); 3125 3126 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name)); 3127 zc.zc_guid = guid; 3128 zc.zc_cookie = VDEV_STATE_FAULTED; 3129 zc.zc_obj = aux; 3130 3131 if (zfs_ioctl(hdl, ZFS_IOC_VDEV_SET_STATE, &zc) == 0) 3132 return (0); 3133 3134 switch (errno) { 3135 case EBUSY: 3136 3137 /* 3138 * There are no other replicas of this device. 3139 */ 3140 return (zfs_error(hdl, EZFS_NOREPLICAS, errbuf)); 3141 3142 default: 3143 return (zpool_standard_error(hdl, errno, errbuf)); 3144 } 3145 3146 } 3147 3148 /* 3149 * Mark the given vdev degraded. 3150 */ 3151 int 3152 zpool_vdev_degrade(zpool_handle_t *zhp, uint64_t guid, vdev_aux_t aux) 3153 { 3154 zfs_cmd_t zc = {"\0"}; 3155 char errbuf[ERRBUFLEN]; 3156 libzfs_handle_t *hdl = zhp->zpool_hdl; 3157 3158 (void) snprintf(errbuf, sizeof (errbuf), 3159 dgettext(TEXT_DOMAIN, "cannot degrade %llu"), (u_longlong_t)guid); 3160 3161 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name)); 3162 zc.zc_guid = guid; 3163 zc.zc_cookie = VDEV_STATE_DEGRADED; 3164 zc.zc_obj = aux; 3165 3166 if (zfs_ioctl(hdl, ZFS_IOC_VDEV_SET_STATE, &zc) == 0) 3167 return (0); 3168 3169 return (zpool_standard_error(hdl, errno, errbuf)); 3170 } 3171 3172 /* 3173 * Returns TRUE if the given nvlist is a vdev that was originally swapped in as 3174 * a hot spare. 3175 */ 3176 static boolean_t 3177 is_replacing_spare(nvlist_t *search, nvlist_t *tgt, int which) 3178 { 3179 nvlist_t **child; 3180 uint_t c, children; 3181 3182 if (nvlist_lookup_nvlist_array(search, ZPOOL_CONFIG_CHILDREN, &child, 3183 &children) == 0) { 3184 const char *type = fnvlist_lookup_string(search, 3185 ZPOOL_CONFIG_TYPE); 3186 if ((strcmp(type, VDEV_TYPE_SPARE) == 0 || 3187 strcmp(type, VDEV_TYPE_DRAID_SPARE) == 0) && 3188 children == 2 && child[which] == tgt) 3189 return (B_TRUE); 3190 3191 for (c = 0; c < children; c++) 3192 if (is_replacing_spare(child[c], tgt, which)) 3193 return (B_TRUE); 3194 } 3195 3196 return (B_FALSE); 3197 } 3198 3199 /* 3200 * Attach new_disk (fully described by nvroot) to old_disk. 3201 * If 'replacing' is specified, the new disk will replace the old one. 3202 */ 3203 int 3204 zpool_vdev_attach(zpool_handle_t *zhp, const char *old_disk, 3205 const char *new_disk, nvlist_t *nvroot, int replacing, boolean_t rebuild) 3206 { 3207 zfs_cmd_t zc = {"\0"}; 3208 char errbuf[ERRBUFLEN]; 3209 int ret; 3210 nvlist_t *tgt; 3211 boolean_t avail_spare, l2cache, islog; 3212 uint64_t val; 3213 char *newname; 3214 nvlist_t **child; 3215 uint_t children; 3216 nvlist_t *config_root; 3217 libzfs_handle_t *hdl = zhp->zpool_hdl; 3218 3219 if (replacing) 3220 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 3221 "cannot replace %s with %s"), old_disk, new_disk); 3222 else 3223 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN, 3224 "cannot attach %s to %s"), new_disk, old_disk); 3225 3226 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name)); 3227 if ((tgt = zpool_find_vdev(zhp, old_disk, &avail_spare, &l2cache, 3228 &islog)) == NULL) 3229 return (zfs_error(hdl, EZFS_NODEVICE, errbuf)); 3230 3231 if (avail_spare) 3232 return (zfs_error(hdl, EZFS_ISSPARE, errbuf)); 3233 3234 if (l2cache) 3235 return (zfs_error(hdl, EZFS_ISL2CACHE, errbuf)); 3236 3237 zc.zc_guid = fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID); 3238 zc.zc_cookie = replacing; 3239 zc.zc_simple = rebuild; 3240 3241 if (rebuild && 3242 zfeature_lookup_guid("org.openzfs:device_rebuild", NULL) != 0) { 3243 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3244 "the loaded zfs module doesn't support device rebuilds")); 3245 return (zfs_error(hdl, EZFS_POOL_NOTSUP, errbuf)); 3246 } 3247 3248 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN, 3249 &child, &children) != 0 || children != 1) { 3250 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3251 "new device must be a single disk")); 3252 return (zfs_error(hdl, EZFS_INVALCONFIG, errbuf)); 3253 } 3254 3255 config_root = fnvlist_lookup_nvlist(zpool_get_config(zhp, NULL), 3256 ZPOOL_CONFIG_VDEV_TREE); 3257 3258 if ((newname = zpool_vdev_name(NULL, NULL, child[0], 0)) == NULL) 3259 return (-1); 3260 3261 /* 3262 * If the target is a hot spare that has been swapped in, we can only 3263 * replace it with another hot spare. 3264 */ 3265 if (replacing && 3266 nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_IS_SPARE, &val) == 0 && 3267 (zpool_find_vdev(zhp, newname, &avail_spare, &l2cache, 3268 NULL) == NULL || !avail_spare) && 3269 is_replacing_spare(config_root, tgt, 1)) { 3270 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3271 "can only be replaced by another hot spare")); 3272 free(newname); 3273 return (zfs_error(hdl, EZFS_BADTARGET, errbuf)); 3274 } 3275 3276 free(newname); 3277 3278 zcmd_write_conf_nvlist(hdl, &zc, nvroot); 3279 3280 ret = zfs_ioctl(hdl, ZFS_IOC_VDEV_ATTACH, &zc); 3281 3282 zcmd_free_nvlists(&zc); 3283 3284 if (ret == 0) 3285 return (0); 3286 3287 switch (errno) { 3288 case ENOTSUP: 3289 /* 3290 * Can't attach to or replace this type of vdev. 3291 */ 3292 if (replacing) { 3293 uint64_t version = zpool_get_prop_int(zhp, 3294 ZPOOL_PROP_VERSION, NULL); 3295 3296 if (islog) { 3297 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3298 "cannot replace a log with a spare")); 3299 } else if (rebuild) { 3300 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3301 "only mirror and dRAID vdevs support " 3302 "sequential reconstruction")); 3303 } else if (zpool_is_draid_spare(new_disk)) { 3304 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3305 "dRAID spares can only replace child " 3306 "devices in their parent's dRAID vdev")); 3307 } else if (version >= SPA_VERSION_MULTI_REPLACE) { 3308 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3309 "already in replacing/spare config; wait " 3310 "for completion or use 'zpool detach'")); 3311 } else { 3312 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3313 "cannot replace a replacing device")); 3314 } 3315 } else { 3316 char status[64] = {0}; 3317 zpool_prop_get_feature(zhp, 3318 "feature@device_rebuild", status, 63); 3319 if (rebuild && 3320 strncmp(status, ZFS_FEATURE_DISABLED, 64) == 0) { 3321 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3322 "device_rebuild feature must be enabled " 3323 "in order to use sequential " 3324 "reconstruction")); 3325 } else { 3326 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3327 "can only attach to mirrors and top-level " 3328 "disks")); 3329 } 3330 } 3331 (void) zfs_error(hdl, EZFS_BADTARGET, errbuf); 3332 break; 3333 3334 case EINVAL: 3335 /* 3336 * The new device must be a single disk. 3337 */ 3338 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3339 "new device must be a single disk")); 3340 (void) zfs_error(hdl, EZFS_INVALCONFIG, errbuf); 3341 break; 3342 3343 case EBUSY: 3344 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "%s is busy, " 3345 "or device removal is in progress"), 3346 new_disk); 3347 (void) zfs_error(hdl, EZFS_BADDEV, errbuf); 3348 break; 3349 3350 case EOVERFLOW: 3351 /* 3352 * The new device is too small. 3353 */ 3354 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3355 "device is too small")); 3356 (void) zfs_error(hdl, EZFS_BADDEV, errbuf); 3357 break; 3358 3359 case EDOM: 3360 /* 3361 * The new device has a different optimal sector size. 3362 */ 3363 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3364 "new device has a different optimal sector size; use the " 3365 "option '-o ashift=N' to override the optimal size")); 3366 (void) zfs_error(hdl, EZFS_BADDEV, errbuf); 3367 break; 3368 3369 case ENAMETOOLONG: 3370 /* 3371 * The resulting top-level vdev spec won't fit in the label. 3372 */ 3373 (void) zfs_error(hdl, EZFS_DEVOVERFLOW, errbuf); 3374 break; 3375 3376 default: 3377 (void) zpool_standard_error(hdl, errno, errbuf); 3378 } 3379 3380 return (-1); 3381 } 3382 3383 /* 3384 * Detach the specified device. 3385 */ 3386 int 3387 zpool_vdev_detach(zpool_handle_t *zhp, const char *path) 3388 { 3389 zfs_cmd_t zc = {"\0"}; 3390 char errbuf[ERRBUFLEN]; 3391 nvlist_t *tgt; 3392 boolean_t avail_spare, l2cache; 3393 libzfs_handle_t *hdl = zhp->zpool_hdl; 3394 3395 (void) snprintf(errbuf, sizeof (errbuf), 3396 dgettext(TEXT_DOMAIN, "cannot detach %s"), path); 3397 3398 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name)); 3399 if ((tgt = zpool_find_vdev(zhp, path, &avail_spare, &l2cache, 3400 NULL)) == NULL) 3401 return (zfs_error(hdl, EZFS_NODEVICE, errbuf)); 3402 3403 if (avail_spare) 3404 return (zfs_error(hdl, EZFS_ISSPARE, errbuf)); 3405 3406 if (l2cache) 3407 return (zfs_error(hdl, EZFS_ISL2CACHE, errbuf)); 3408 3409 zc.zc_guid = fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID); 3410 3411 if (zfs_ioctl(hdl, ZFS_IOC_VDEV_DETACH, &zc) == 0) 3412 return (0); 3413 3414 switch (errno) { 3415 3416 case ENOTSUP: 3417 /* 3418 * Can't detach from this type of vdev. 3419 */ 3420 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "only " 3421 "applicable to mirror and replacing vdevs")); 3422 (void) zfs_error(hdl, EZFS_BADTARGET, errbuf); 3423 break; 3424 3425 case EBUSY: 3426 /* 3427 * There are no other replicas of this device. 3428 */ 3429 (void) zfs_error(hdl, EZFS_NOREPLICAS, errbuf); 3430 break; 3431 3432 default: 3433 (void) zpool_standard_error(hdl, errno, errbuf); 3434 } 3435 3436 return (-1); 3437 } 3438 3439 /* 3440 * Find a mirror vdev in the source nvlist. 3441 * 3442 * The mchild array contains a list of disks in one of the top-level mirrors 3443 * of the source pool. The schild array contains a list of disks that the 3444 * user specified on the command line. We loop over the mchild array to 3445 * see if any entry in the schild array matches. 3446 * 3447 * If a disk in the mchild array is found in the schild array, we return 3448 * the index of that entry. Otherwise we return -1. 3449 */ 3450 static int 3451 find_vdev_entry(zpool_handle_t *zhp, nvlist_t **mchild, uint_t mchildren, 3452 nvlist_t **schild, uint_t schildren) 3453 { 3454 uint_t mc; 3455 3456 for (mc = 0; mc < mchildren; mc++) { 3457 uint_t sc; 3458 char *mpath = zpool_vdev_name(zhp->zpool_hdl, zhp, 3459 mchild[mc], 0); 3460 3461 for (sc = 0; sc < schildren; sc++) { 3462 char *spath = zpool_vdev_name(zhp->zpool_hdl, zhp, 3463 schild[sc], 0); 3464 boolean_t result = (strcmp(mpath, spath) == 0); 3465 3466 free(spath); 3467 if (result) { 3468 free(mpath); 3469 return (mc); 3470 } 3471 } 3472 3473 free(mpath); 3474 } 3475 3476 return (-1); 3477 } 3478 3479 /* 3480 * Split a mirror pool. If newroot points to null, then a new nvlist 3481 * is generated and it is the responsibility of the caller to free it. 3482 */ 3483 int 3484 zpool_vdev_split(zpool_handle_t *zhp, char *newname, nvlist_t **newroot, 3485 nvlist_t *props, splitflags_t flags) 3486 { 3487 zfs_cmd_t zc = {"\0"}; 3488 char errbuf[ERRBUFLEN]; 3489 const char *bias; 3490 nvlist_t *tree, *config, **child, **newchild, *newconfig = NULL; 3491 nvlist_t **varray = NULL, *zc_props = NULL; 3492 uint_t c, children, newchildren, lastlog = 0, vcount, found = 0; 3493 libzfs_handle_t *hdl = zhp->zpool_hdl; 3494 uint64_t vers, readonly = B_FALSE; 3495 boolean_t freelist = B_FALSE, memory_err = B_TRUE; 3496 int retval = 0; 3497 3498 (void) snprintf(errbuf, sizeof (errbuf), 3499 dgettext(TEXT_DOMAIN, "Unable to split %s"), zhp->zpool_name); 3500 3501 if (!zpool_name_valid(hdl, B_FALSE, newname)) 3502 return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf)); 3503 3504 if ((config = zpool_get_config(zhp, NULL)) == NULL) { 3505 (void) fprintf(stderr, gettext("Internal error: unable to " 3506 "retrieve pool configuration\n")); 3507 return (-1); 3508 } 3509 3510 tree = fnvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE); 3511 vers = fnvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION); 3512 3513 if (props) { 3514 prop_flags_t flags = { .create = B_FALSE, .import = B_TRUE }; 3515 if ((zc_props = zpool_valid_proplist(hdl, zhp->zpool_name, 3516 props, vers, flags, errbuf)) == NULL) 3517 return (-1); 3518 (void) nvlist_lookup_uint64(zc_props, 3519 zpool_prop_to_name(ZPOOL_PROP_READONLY), &readonly); 3520 if (readonly) { 3521 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3522 "property %s can only be set at import time"), 3523 zpool_prop_to_name(ZPOOL_PROP_READONLY)); 3524 return (-1); 3525 } 3526 } 3527 3528 if (nvlist_lookup_nvlist_array(tree, ZPOOL_CONFIG_CHILDREN, &child, 3529 &children) != 0) { 3530 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3531 "Source pool is missing vdev tree")); 3532 nvlist_free(zc_props); 3533 return (-1); 3534 } 3535 3536 varray = zfs_alloc(hdl, children * sizeof (nvlist_t *)); 3537 vcount = 0; 3538 3539 if (*newroot == NULL || 3540 nvlist_lookup_nvlist_array(*newroot, ZPOOL_CONFIG_CHILDREN, 3541 &newchild, &newchildren) != 0) 3542 newchildren = 0; 3543 3544 for (c = 0; c < children; c++) { 3545 uint64_t is_log = B_FALSE, is_hole = B_FALSE; 3546 boolean_t is_special = B_FALSE, is_dedup = B_FALSE; 3547 const char *type; 3548 nvlist_t **mchild, *vdev; 3549 uint_t mchildren; 3550 int entry; 3551 3552 /* 3553 * Unlike cache & spares, slogs are stored in the 3554 * ZPOOL_CONFIG_CHILDREN array. We filter them out here. 3555 */ 3556 (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG, 3557 &is_log); 3558 (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_HOLE, 3559 &is_hole); 3560 if (is_log || is_hole) { 3561 /* 3562 * Create a hole vdev and put it in the config. 3563 */ 3564 if (nvlist_alloc(&vdev, NV_UNIQUE_NAME, 0) != 0) 3565 goto out; 3566 if (nvlist_add_string(vdev, ZPOOL_CONFIG_TYPE, 3567 VDEV_TYPE_HOLE) != 0) 3568 goto out; 3569 if (nvlist_add_uint64(vdev, ZPOOL_CONFIG_IS_HOLE, 3570 1) != 0) 3571 goto out; 3572 if (lastlog == 0) 3573 lastlog = vcount; 3574 varray[vcount++] = vdev; 3575 continue; 3576 } 3577 lastlog = 0; 3578 type = fnvlist_lookup_string(child[c], ZPOOL_CONFIG_TYPE); 3579 3580 if (strcmp(type, VDEV_TYPE_INDIRECT) == 0) { 3581 vdev = child[c]; 3582 if (nvlist_dup(vdev, &varray[vcount++], 0) != 0) 3583 goto out; 3584 continue; 3585 } else if (strcmp(type, VDEV_TYPE_MIRROR) != 0) { 3586 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3587 "Source pool must be composed only of mirrors\n")); 3588 retval = zfs_error(hdl, EZFS_INVALCONFIG, errbuf); 3589 goto out; 3590 } 3591 3592 if (nvlist_lookup_string(child[c], 3593 ZPOOL_CONFIG_ALLOCATION_BIAS, &bias) == 0) { 3594 if (strcmp(bias, VDEV_ALLOC_BIAS_SPECIAL) == 0) 3595 is_special = B_TRUE; 3596 else if (strcmp(bias, VDEV_ALLOC_BIAS_DEDUP) == 0) 3597 is_dedup = B_TRUE; 3598 } 3599 verify(nvlist_lookup_nvlist_array(child[c], 3600 ZPOOL_CONFIG_CHILDREN, &mchild, &mchildren) == 0); 3601 3602 /* find or add an entry for this top-level vdev */ 3603 if (newchildren > 0 && 3604 (entry = find_vdev_entry(zhp, mchild, mchildren, 3605 newchild, newchildren)) >= 0) { 3606 /* We found a disk that the user specified. */ 3607 vdev = mchild[entry]; 3608 ++found; 3609 } else { 3610 /* User didn't specify a disk for this vdev. */ 3611 vdev = mchild[mchildren - 1]; 3612 } 3613 3614 if (nvlist_dup(vdev, &varray[vcount++], 0) != 0) 3615 goto out; 3616 3617 if (flags.dryrun != 0) { 3618 if (is_dedup == B_TRUE) { 3619 if (nvlist_add_string(varray[vcount - 1], 3620 ZPOOL_CONFIG_ALLOCATION_BIAS, 3621 VDEV_ALLOC_BIAS_DEDUP) != 0) 3622 goto out; 3623 } else if (is_special == B_TRUE) { 3624 if (nvlist_add_string(varray[vcount - 1], 3625 ZPOOL_CONFIG_ALLOCATION_BIAS, 3626 VDEV_ALLOC_BIAS_SPECIAL) != 0) 3627 goto out; 3628 } 3629 } 3630 } 3631 3632 /* did we find every disk the user specified? */ 3633 if (found != newchildren) { 3634 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "Device list must " 3635 "include at most one disk from each mirror")); 3636 retval = zfs_error(hdl, EZFS_INVALCONFIG, errbuf); 3637 goto out; 3638 } 3639 3640 /* Prepare the nvlist for populating. */ 3641 if (*newroot == NULL) { 3642 if (nvlist_alloc(newroot, NV_UNIQUE_NAME, 0) != 0) 3643 goto out; 3644 freelist = B_TRUE; 3645 if (nvlist_add_string(*newroot, ZPOOL_CONFIG_TYPE, 3646 VDEV_TYPE_ROOT) != 0) 3647 goto out; 3648 } else { 3649 verify(nvlist_remove_all(*newroot, ZPOOL_CONFIG_CHILDREN) == 0); 3650 } 3651 3652 /* Add all the children we found */ 3653 if (nvlist_add_nvlist_array(*newroot, ZPOOL_CONFIG_CHILDREN, 3654 (const nvlist_t **)varray, lastlog == 0 ? vcount : lastlog) != 0) 3655 goto out; 3656 3657 /* 3658 * If we're just doing a dry run, exit now with success. 3659 */ 3660 if (flags.dryrun) { 3661 memory_err = B_FALSE; 3662 freelist = B_FALSE; 3663 goto out; 3664 } 3665 3666 /* now build up the config list & call the ioctl */ 3667 if (nvlist_alloc(&newconfig, NV_UNIQUE_NAME, 0) != 0) 3668 goto out; 3669 3670 if (nvlist_add_nvlist(newconfig, 3671 ZPOOL_CONFIG_VDEV_TREE, *newroot) != 0 || 3672 nvlist_add_string(newconfig, 3673 ZPOOL_CONFIG_POOL_NAME, newname) != 0 || 3674 nvlist_add_uint64(newconfig, ZPOOL_CONFIG_VERSION, vers) != 0) 3675 goto out; 3676 3677 /* 3678 * The new pool is automatically part of the namespace unless we 3679 * explicitly export it. 3680 */ 3681 if (!flags.import) 3682 zc.zc_cookie = ZPOOL_EXPORT_AFTER_SPLIT; 3683 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name)); 3684 (void) strlcpy(zc.zc_string, newname, sizeof (zc.zc_string)); 3685 zcmd_write_conf_nvlist(hdl, &zc, newconfig); 3686 if (zc_props != NULL) 3687 zcmd_write_src_nvlist(hdl, &zc, zc_props); 3688 3689 if (zfs_ioctl(hdl, ZFS_IOC_VDEV_SPLIT, &zc) != 0) { 3690 retval = zpool_standard_error(hdl, errno, errbuf); 3691 goto out; 3692 } 3693 3694 freelist = B_FALSE; 3695 memory_err = B_FALSE; 3696 3697 out: 3698 if (varray != NULL) { 3699 int v; 3700 3701 for (v = 0; v < vcount; v++) 3702 nvlist_free(varray[v]); 3703 free(varray); 3704 } 3705 zcmd_free_nvlists(&zc); 3706 nvlist_free(zc_props); 3707 nvlist_free(newconfig); 3708 if (freelist) { 3709 nvlist_free(*newroot); 3710 *newroot = NULL; 3711 } 3712 3713 if (retval != 0) 3714 return (retval); 3715 3716 if (memory_err) 3717 return (no_memory(hdl)); 3718 3719 return (0); 3720 } 3721 3722 /* 3723 * Remove the given device. 3724 */ 3725 int 3726 zpool_vdev_remove(zpool_handle_t *zhp, const char *path) 3727 { 3728 zfs_cmd_t zc = {"\0"}; 3729 char errbuf[ERRBUFLEN]; 3730 nvlist_t *tgt; 3731 boolean_t avail_spare, l2cache, islog; 3732 libzfs_handle_t *hdl = zhp->zpool_hdl; 3733 uint64_t version; 3734 3735 (void) snprintf(errbuf, sizeof (errbuf), 3736 dgettext(TEXT_DOMAIN, "cannot remove %s"), path); 3737 3738 if (zpool_is_draid_spare(path)) { 3739 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3740 "dRAID spares cannot be removed")); 3741 return (zfs_error(hdl, EZFS_NODEVICE, errbuf)); 3742 } 3743 3744 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name)); 3745 if ((tgt = zpool_find_vdev(zhp, path, &avail_spare, &l2cache, 3746 &islog)) == NULL) 3747 return (zfs_error(hdl, EZFS_NODEVICE, errbuf)); 3748 3749 version = zpool_get_prop_int(zhp, ZPOOL_PROP_VERSION, NULL); 3750 if (islog && version < SPA_VERSION_HOLES) { 3751 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3752 "pool must be upgraded to support log removal")); 3753 return (zfs_error(hdl, EZFS_BADVERSION, errbuf)); 3754 } 3755 3756 zc.zc_guid = fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID); 3757 3758 if (zfs_ioctl(hdl, ZFS_IOC_VDEV_REMOVE, &zc) == 0) 3759 return (0); 3760 3761 switch (errno) { 3762 3763 case EINVAL: 3764 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3765 "invalid config; all top-level vdevs must " 3766 "have the same sector size and not be raidz.")); 3767 (void) zfs_error(hdl, EZFS_INVALCONFIG, errbuf); 3768 break; 3769 3770 case EBUSY: 3771 if (islog) { 3772 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3773 "Mount encrypted datasets to replay logs.")); 3774 } else { 3775 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3776 "Pool busy; removal may already be in progress")); 3777 } 3778 (void) zfs_error(hdl, EZFS_BUSY, errbuf); 3779 break; 3780 3781 case EACCES: 3782 if (islog) { 3783 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3784 "Mount encrypted datasets to replay logs.")); 3785 (void) zfs_error(hdl, EZFS_BUSY, errbuf); 3786 } else { 3787 (void) zpool_standard_error(hdl, errno, errbuf); 3788 } 3789 break; 3790 3791 default: 3792 (void) zpool_standard_error(hdl, errno, errbuf); 3793 } 3794 return (-1); 3795 } 3796 3797 int 3798 zpool_vdev_remove_cancel(zpool_handle_t *zhp) 3799 { 3800 zfs_cmd_t zc = {{0}}; 3801 char errbuf[ERRBUFLEN]; 3802 libzfs_handle_t *hdl = zhp->zpool_hdl; 3803 3804 (void) snprintf(errbuf, sizeof (errbuf), 3805 dgettext(TEXT_DOMAIN, "cannot cancel removal")); 3806 3807 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name)); 3808 zc.zc_cookie = 1; 3809 3810 if (zfs_ioctl(hdl, ZFS_IOC_VDEV_REMOVE, &zc) == 0) 3811 return (0); 3812 3813 return (zpool_standard_error(hdl, errno, errbuf)); 3814 } 3815 3816 int 3817 zpool_vdev_indirect_size(zpool_handle_t *zhp, const char *path, 3818 uint64_t *sizep) 3819 { 3820 char errbuf[ERRBUFLEN]; 3821 nvlist_t *tgt; 3822 boolean_t avail_spare, l2cache, islog; 3823 libzfs_handle_t *hdl = zhp->zpool_hdl; 3824 3825 (void) snprintf(errbuf, sizeof (errbuf), 3826 dgettext(TEXT_DOMAIN, "cannot determine indirect size of %s"), 3827 path); 3828 3829 if ((tgt = zpool_find_vdev(zhp, path, &avail_spare, &l2cache, 3830 &islog)) == NULL) 3831 return (zfs_error(hdl, EZFS_NODEVICE, errbuf)); 3832 3833 if (avail_spare || l2cache || islog) { 3834 *sizep = 0; 3835 return (0); 3836 } 3837 3838 if (nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_INDIRECT_SIZE, sizep) != 0) { 3839 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, 3840 "indirect size not available")); 3841 return (zfs_error(hdl, EINVAL, errbuf)); 3842 } 3843 return (0); 3844 } 3845 3846 /* 3847 * Clear the errors for the pool, or the particular device if specified. 3848 */ 3849 int 3850 zpool_clear(zpool_handle_t *zhp, const char *path, nvlist_t *rewindnvl) 3851 { 3852 zfs_cmd_t zc = {"\0"}; 3853 char errbuf[ERRBUFLEN]; 3854 nvlist_t *tgt; 3855 zpool_load_policy_t policy; 3856 boolean_t avail_spare, l2cache; 3857 libzfs_handle_t *hdl = zhp->zpool_hdl; 3858 nvlist_t *nvi = NULL; 3859 int error; 3860 3861 if (path) 3862 (void) snprintf(errbuf, sizeof (errbuf), 3863 dgettext(TEXT_DOMAIN, "cannot clear errors for %s"), 3864 path); 3865 else 3866 (void) snprintf(errbuf, sizeof (errbuf), 3867 dgettext(TEXT_DOMAIN, "cannot clear errors for %s"), 3868 zhp->zpool_name); 3869 3870 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name)); 3871 if (path) { 3872 if ((tgt = zpool_find_vdev(zhp, path, &avail_spare, 3873 &l2cache, NULL)) == NULL) 3874 return (zfs_error(hdl, EZFS_NODEVICE, errbuf)); 3875 3876 /* 3877 * Don't allow error clearing for hot spares. Do allow 3878 * error clearing for l2cache devices. 3879 */ 3880 if (avail_spare) 3881 return (zfs_error(hdl, EZFS_ISSPARE, errbuf)); 3882 3883 zc.zc_guid = fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID); 3884 } 3885 3886 zpool_get_load_policy(rewindnvl, &policy); 3887 zc.zc_cookie = policy.zlp_rewind; 3888 3889 zcmd_alloc_dst_nvlist(hdl, &zc, zhp->zpool_config_size * 2); 3890 zcmd_write_src_nvlist(hdl, &zc, rewindnvl); 3891 3892 while ((error = zfs_ioctl(hdl, ZFS_IOC_CLEAR, &zc)) != 0 && 3893 errno == ENOMEM) 3894 zcmd_expand_dst_nvlist(hdl, &zc); 3895 3896 if (!error || ((policy.zlp_rewind & ZPOOL_TRY_REWIND) && 3897 errno != EPERM && errno != EACCES)) { 3898 if (policy.zlp_rewind & 3899 (ZPOOL_DO_REWIND | ZPOOL_TRY_REWIND)) { 3900 (void) zcmd_read_dst_nvlist(hdl, &zc, &nvi); 3901 zpool_rewind_exclaim(hdl, zc.zc_name, 3902 ((policy.zlp_rewind & ZPOOL_TRY_REWIND) != 0), 3903 nvi); 3904 nvlist_free(nvi); 3905 } 3906 zcmd_free_nvlists(&zc); 3907 return (0); 3908 } 3909 3910 zcmd_free_nvlists(&zc); 3911 return (zpool_standard_error(hdl, errno, errbuf)); 3912 } 3913 3914 /* 3915 * Similar to zpool_clear(), but takes a GUID (used by fmd). 3916 */ 3917 int 3918 zpool_vdev_clear(zpool_handle_t *zhp, uint64_t guid) 3919 { 3920 zfs_cmd_t zc = {"\0"}; 3921 char errbuf[ERRBUFLEN]; 3922 libzfs_handle_t *hdl = zhp->zpool_hdl; 3923 3924 (void) snprintf(errbuf, sizeof (errbuf), 3925 dgettext(TEXT_DOMAIN, "cannot clear errors for %llx"), 3926 (u_longlong_t)guid); 3927 3928 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name)); 3929 zc.zc_guid = guid; 3930 zc.zc_cookie = ZPOOL_NO_REWIND; 3931 3932 if (zfs_ioctl(hdl, ZFS_IOC_CLEAR, &zc) == 0) 3933 return (0); 3934 3935 return (zpool_standard_error(hdl, errno, errbuf)); 3936 } 3937 3938 /* 3939 * Change the GUID for a pool. 3940 */ 3941 int 3942 zpool_reguid(zpool_handle_t *zhp) 3943 { 3944 char errbuf[ERRBUFLEN]; 3945 libzfs_handle_t *hdl = zhp->zpool_hdl; 3946 zfs_cmd_t zc = {"\0"}; 3947 3948 (void) snprintf(errbuf, sizeof (errbuf), 3949 dgettext(TEXT_DOMAIN, "cannot reguid '%s'"), zhp->zpool_name); 3950 3951 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name)); 3952 if (zfs_ioctl(hdl, ZFS_IOC_POOL_REGUID, &zc) == 0) 3953 return (0); 3954 3955 return (zpool_standard_error(hdl, errno, errbuf)); 3956 } 3957 3958 /* 3959 * Reopen the pool. 3960 */ 3961 int 3962 zpool_reopen_one(zpool_handle_t *zhp, void *data) 3963 { 3964 libzfs_handle_t *hdl = zpool_get_handle(zhp); 3965 const char *pool_name = zpool_get_name(zhp); 3966 boolean_t *scrub_restart = data; 3967 int error; 3968 3969 error = lzc_reopen(pool_name, *scrub_restart); 3970 if (error) { 3971 return (zpool_standard_error_fmt(hdl, error, 3972 dgettext(TEXT_DOMAIN, "cannot reopen '%s'"), pool_name)); 3973 } 3974 3975 return (0); 3976 } 3977 3978 /* call into libzfs_core to execute the sync IOCTL per pool */ 3979 int 3980 zpool_sync_one(zpool_handle_t *zhp, void *data) 3981 { 3982 int ret; 3983 libzfs_handle_t *hdl = zpool_get_handle(zhp); 3984 const char *pool_name = zpool_get_name(zhp); 3985 boolean_t *force = data; 3986 nvlist_t *innvl = fnvlist_alloc(); 3987 3988 fnvlist_add_boolean_value(innvl, "force", *force); 3989 if ((ret = lzc_sync(pool_name, innvl, NULL)) != 0) { 3990 nvlist_free(innvl); 3991 return (zpool_standard_error_fmt(hdl, ret, 3992 dgettext(TEXT_DOMAIN, "sync '%s' failed"), pool_name)); 3993 } 3994 nvlist_free(innvl); 3995 3996 return (0); 3997 } 3998 3999 #define PATH_BUF_LEN 64 4000 4001 /* 4002 * Given a vdev, return the name to display in iostat. If the vdev has a path, 4003 * we use that, stripping off any leading "/dev/dsk/"; if not, we use the type. 4004 * We also check if this is a whole disk, in which case we strip off the 4005 * trailing 's0' slice name. 4006 * 4007 * This routine is also responsible for identifying when disks have been 4008 * reconfigured in a new location. The kernel will have opened the device by 4009 * devid, but the path will still refer to the old location. To catch this, we 4010 * first do a path -> devid translation (which is fast for the common case). If 4011 * the devid matches, we're done. If not, we do a reverse devid -> path 4012 * translation and issue the appropriate ioctl() to update the path of the vdev. 4013 * If 'zhp' is NULL, then this is an exported pool, and we don't need to do any 4014 * of these checks. 4015 */ 4016 char * 4017 zpool_vdev_name(libzfs_handle_t *hdl, zpool_handle_t *zhp, nvlist_t *nv, 4018 int name_flags) 4019 { 4020 const char *type, *tpath; 4021 const char *path; 4022 uint64_t value; 4023 char buf[PATH_BUF_LEN]; 4024 char tmpbuf[PATH_BUF_LEN * 2]; 4025 4026 /* 4027 * vdev_name will be "root"/"root-0" for the root vdev, but it is the 4028 * zpool name that will be displayed to the user. 4029 */ 4030 type = fnvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE); 4031 if (zhp != NULL && strcmp(type, "root") == 0) 4032 return (zfs_strdup(hdl, zpool_get_name(zhp))); 4033 4034 if (libzfs_envvar_is_set("ZPOOL_VDEV_NAME_PATH")) 4035 name_flags |= VDEV_NAME_PATH; 4036 if (libzfs_envvar_is_set("ZPOOL_VDEV_NAME_GUID")) 4037 name_flags |= VDEV_NAME_GUID; 4038 if (libzfs_envvar_is_set("ZPOOL_VDEV_NAME_FOLLOW_LINKS")) 4039 name_flags |= VDEV_NAME_FOLLOW_LINKS; 4040 4041 if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NOT_PRESENT, &value) == 0 || 4042 name_flags & VDEV_NAME_GUID) { 4043 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &value); 4044 (void) snprintf(buf, sizeof (buf), "%llu", (u_longlong_t)value); 4045 path = buf; 4046 } else if (nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &tpath) == 0) { 4047 path = tpath; 4048 4049 if (name_flags & VDEV_NAME_FOLLOW_LINKS) { 4050 char *rp = realpath(path, NULL); 4051 if (rp) { 4052 strlcpy(buf, rp, sizeof (buf)); 4053 path = buf; 4054 free(rp); 4055 } 4056 } 4057 4058 /* 4059 * For a block device only use the name. 4060 */ 4061 if ((strcmp(type, VDEV_TYPE_DISK) == 0) && 4062 !(name_flags & VDEV_NAME_PATH)) { 4063 path = zfs_strip_path(path); 4064 } 4065 4066 /* 4067 * Remove the partition from the path if this is a whole disk. 4068 */ 4069 if (strcmp(type, VDEV_TYPE_DRAID_SPARE) != 0 && 4070 nvlist_lookup_uint64(nv, ZPOOL_CONFIG_WHOLE_DISK, &value) 4071 == 0 && value && !(name_flags & VDEV_NAME_PATH)) { 4072 return (zfs_strip_partition(path)); 4073 } 4074 } else { 4075 path = type; 4076 4077 /* 4078 * If it's a raidz device, we need to stick in the parity level. 4079 */ 4080 if (strcmp(path, VDEV_TYPE_RAIDZ) == 0) { 4081 value = fnvlist_lookup_uint64(nv, ZPOOL_CONFIG_NPARITY); 4082 (void) snprintf(buf, sizeof (buf), "%s%llu", path, 4083 (u_longlong_t)value); 4084 path = buf; 4085 } 4086 4087 /* 4088 * If it's a dRAID device, we add parity, groups, and spares. 4089 */ 4090 if (strcmp(path, VDEV_TYPE_DRAID) == 0) { 4091 uint64_t ndata, nparity, nspares; 4092 nvlist_t **child; 4093 uint_t children; 4094 4095 verify(nvlist_lookup_nvlist_array(nv, 4096 ZPOOL_CONFIG_CHILDREN, &child, &children) == 0); 4097 nparity = fnvlist_lookup_uint64(nv, 4098 ZPOOL_CONFIG_NPARITY); 4099 ndata = fnvlist_lookup_uint64(nv, 4100 ZPOOL_CONFIG_DRAID_NDATA); 4101 nspares = fnvlist_lookup_uint64(nv, 4102 ZPOOL_CONFIG_DRAID_NSPARES); 4103 4104 path = zpool_draid_name(buf, sizeof (buf), ndata, 4105 nparity, nspares, children); 4106 } 4107 4108 /* 4109 * We identify each top-level vdev by using a <type-id> 4110 * naming convention. 4111 */ 4112 if (name_flags & VDEV_NAME_TYPE_ID) { 4113 uint64_t id = fnvlist_lookup_uint64(nv, 4114 ZPOOL_CONFIG_ID); 4115 (void) snprintf(tmpbuf, sizeof (tmpbuf), "%s-%llu", 4116 path, (u_longlong_t)id); 4117 path = tmpbuf; 4118 } 4119 } 4120 4121 return (zfs_strdup(hdl, path)); 4122 } 4123 4124 static int 4125 zbookmark_mem_compare(const void *a, const void *b) 4126 { 4127 return (memcmp(a, b, sizeof (zbookmark_phys_t))); 4128 } 4129 4130 /* 4131 * Retrieve the persistent error log, uniquify the members, and return to the 4132 * caller. 4133 */ 4134 int 4135 zpool_get_errlog(zpool_handle_t *zhp, nvlist_t **nverrlistp) 4136 { 4137 zfs_cmd_t zc = {"\0"}; 4138 libzfs_handle_t *hdl = zhp->zpool_hdl; 4139 zbookmark_phys_t *buf; 4140 uint64_t buflen = 10000; /* approx. 1MB of RAM */ 4141 4142 if (fnvlist_lookup_uint64(zhp->zpool_config, 4143 ZPOOL_CONFIG_ERRCOUNT) == 0) 4144 return (0); 4145 4146 /* 4147 * Retrieve the raw error list from the kernel. If it doesn't fit, 4148 * allocate a larger buffer and retry. 4149 */ 4150 (void) strcpy(zc.zc_name, zhp->zpool_name); 4151 for (;;) { 4152 buf = zfs_alloc(zhp->zpool_hdl, 4153 buflen * sizeof (zbookmark_phys_t)); 4154 zc.zc_nvlist_dst = (uintptr_t)buf; 4155 zc.zc_nvlist_dst_size = buflen; 4156 if (zfs_ioctl(zhp->zpool_hdl, ZFS_IOC_ERROR_LOG, 4157 &zc) != 0) { 4158 free(buf); 4159 if (errno == ENOMEM) { 4160 buflen *= 2; 4161 } else { 4162 return (zpool_standard_error_fmt(hdl, errno, 4163 dgettext(TEXT_DOMAIN, "errors: List of " 4164 "errors unavailable"))); 4165 } 4166 } else { 4167 break; 4168 } 4169 } 4170 4171 /* 4172 * Sort the resulting bookmarks. This is a little confusing due to the 4173 * implementation of ZFS_IOC_ERROR_LOG. The bookmarks are copied last 4174 * to first, and 'zc_nvlist_dst_size' indicates the number of bookmarks 4175 * _not_ copied as part of the process. So we point the start of our 4176 * array appropriate and decrement the total number of elements. 4177 */ 4178 zbookmark_phys_t *zb = buf + zc.zc_nvlist_dst_size; 4179 uint64_t zblen = buflen - zc.zc_nvlist_dst_size; 4180 4181 qsort(zb, zblen, sizeof (zbookmark_phys_t), zbookmark_mem_compare); 4182 4183 verify(nvlist_alloc(nverrlistp, 0, KM_SLEEP) == 0); 4184 4185 /* 4186 * Fill in the nverrlistp with nvlist's of dataset and object numbers. 4187 */ 4188 for (uint64_t i = 0; i < zblen; i++) { 4189 nvlist_t *nv; 4190 4191 /* ignoring zb_blkid and zb_level for now */ 4192 if (i > 0 && zb[i-1].zb_objset == zb[i].zb_objset && 4193 zb[i-1].zb_object == zb[i].zb_object) 4194 continue; 4195 4196 if (nvlist_alloc(&nv, NV_UNIQUE_NAME, KM_SLEEP) != 0) 4197 goto nomem; 4198 if (nvlist_add_uint64(nv, ZPOOL_ERR_DATASET, 4199 zb[i].zb_objset) != 0) { 4200 nvlist_free(nv); 4201 goto nomem; 4202 } 4203 if (nvlist_add_uint64(nv, ZPOOL_ERR_OBJECT, 4204 zb[i].zb_object) != 0) { 4205 nvlist_free(nv); 4206 goto nomem; 4207 } 4208 if (nvlist_add_nvlist(*nverrlistp, "ejk", nv) != 0) { 4209 nvlist_free(nv); 4210 goto nomem; 4211 } 4212 nvlist_free(nv); 4213 } 4214 4215 free(buf); 4216 return (0); 4217 4218 nomem: 4219 free(buf); 4220 return (no_memory(zhp->zpool_hdl)); 4221 } 4222 4223 /* 4224 * Upgrade a ZFS pool to the latest on-disk version. 4225 */ 4226 int 4227 zpool_upgrade(zpool_handle_t *zhp, uint64_t new_version) 4228 { 4229 zfs_cmd_t zc = {"\0"}; 4230 libzfs_handle_t *hdl = zhp->zpool_hdl; 4231 4232 (void) strcpy(zc.zc_name, zhp->zpool_name); 4233 zc.zc_cookie = new_version; 4234 4235 if (zfs_ioctl(hdl, ZFS_IOC_POOL_UPGRADE, &zc) != 0) 4236 return (zpool_standard_error_fmt(hdl, errno, 4237 dgettext(TEXT_DOMAIN, "cannot upgrade '%s'"), 4238 zhp->zpool_name)); 4239 return (0); 4240 } 4241 4242 void 4243 zfs_save_arguments(int argc, char **argv, char *string, int len) 4244 { 4245 int i; 4246 4247 (void) strlcpy(string, zfs_basename(argv[0]), len); 4248 for (i = 1; i < argc; i++) { 4249 (void) strlcat(string, " ", len); 4250 (void) strlcat(string, argv[i], len); 4251 } 4252 } 4253 4254 int 4255 zpool_log_history(libzfs_handle_t *hdl, const char *message) 4256 { 4257 zfs_cmd_t zc = {"\0"}; 4258 nvlist_t *args; 4259 4260 args = fnvlist_alloc(); 4261 fnvlist_add_string(args, "message", message); 4262 zcmd_write_src_nvlist(hdl, &zc, args); 4263 int err = zfs_ioctl(hdl, ZFS_IOC_LOG_HISTORY, &zc); 4264 nvlist_free(args); 4265 zcmd_free_nvlists(&zc); 4266 return (err); 4267 } 4268 4269 /* 4270 * Perform ioctl to get some command history of a pool. 4271 * 4272 * 'buf' is the buffer to fill up to 'len' bytes. 'off' is the 4273 * logical offset of the history buffer to start reading from. 4274 * 4275 * Upon return, 'off' is the next logical offset to read from and 4276 * 'len' is the actual amount of bytes read into 'buf'. 4277 */ 4278 static int 4279 get_history(zpool_handle_t *zhp, char *buf, uint64_t *off, uint64_t *len) 4280 { 4281 zfs_cmd_t zc = {"\0"}; 4282 libzfs_handle_t *hdl = zhp->zpool_hdl; 4283 4284 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name)); 4285 4286 zc.zc_history = (uint64_t)(uintptr_t)buf; 4287 zc.zc_history_len = *len; 4288 zc.zc_history_offset = *off; 4289 4290 if (zfs_ioctl(hdl, ZFS_IOC_POOL_GET_HISTORY, &zc) != 0) { 4291 switch (errno) { 4292 case EPERM: 4293 return (zfs_error_fmt(hdl, EZFS_PERM, 4294 dgettext(TEXT_DOMAIN, 4295 "cannot show history for pool '%s'"), 4296 zhp->zpool_name)); 4297 case ENOENT: 4298 return (zfs_error_fmt(hdl, EZFS_NOHISTORY, 4299 dgettext(TEXT_DOMAIN, "cannot get history for pool " 4300 "'%s'"), zhp->zpool_name)); 4301 case ENOTSUP: 4302 return (zfs_error_fmt(hdl, EZFS_BADVERSION, 4303 dgettext(TEXT_DOMAIN, "cannot get history for pool " 4304 "'%s', pool must be upgraded"), zhp->zpool_name)); 4305 default: 4306 return (zpool_standard_error_fmt(hdl, errno, 4307 dgettext(TEXT_DOMAIN, 4308 "cannot get history for '%s'"), zhp->zpool_name)); 4309 } 4310 } 4311 4312 *len = zc.zc_history_len; 4313 *off = zc.zc_history_offset; 4314 4315 return (0); 4316 } 4317 4318 /* 4319 * Retrieve the command history of a pool. 4320 */ 4321 int 4322 zpool_get_history(zpool_handle_t *zhp, nvlist_t **nvhisp, uint64_t *off, 4323 boolean_t *eof) 4324 { 4325 libzfs_handle_t *hdl = zhp->zpool_hdl; 4326 char *buf; 4327 int buflen = 128 * 1024; 4328 nvlist_t **records = NULL; 4329 uint_t numrecords = 0; 4330 int err = 0, i; 4331 uint64_t start = *off; 4332 4333 buf = zfs_alloc(hdl, buflen); 4334 4335 /* process about 1MiB a time */ 4336 while (*off - start < 1024 * 1024) { 4337 uint64_t bytes_read = buflen; 4338 uint64_t leftover; 4339 4340 if ((err = get_history(zhp, buf, off, &bytes_read)) != 0) 4341 break; 4342 4343 /* if nothing else was read in, we're at EOF, just return */ 4344 if (!bytes_read) { 4345 *eof = B_TRUE; 4346 break; 4347 } 4348 4349 if ((err = zpool_history_unpack(buf, bytes_read, 4350 &leftover, &records, &numrecords)) != 0) { 4351 zpool_standard_error_fmt(hdl, err, 4352 dgettext(TEXT_DOMAIN, 4353 "cannot get history for '%s'"), zhp->zpool_name); 4354 break; 4355 } 4356 *off -= leftover; 4357 if (leftover == bytes_read) { 4358 /* 4359 * no progress made, because buffer is not big enough 4360 * to hold this record; resize and retry. 4361 */ 4362 buflen *= 2; 4363 free(buf); 4364 buf = zfs_alloc(hdl, buflen); 4365 } 4366 } 4367 4368 free(buf); 4369 4370 if (!err) { 4371 *nvhisp = fnvlist_alloc(); 4372 fnvlist_add_nvlist_array(*nvhisp, ZPOOL_HIST_RECORD, 4373 (const nvlist_t **)records, numrecords); 4374 } 4375 for (i = 0; i < numrecords; i++) 4376 nvlist_free(records[i]); 4377 free(records); 4378 4379 return (err); 4380 } 4381 4382 /* 4383 * Retrieve the next event given the passed 'zevent_fd' file descriptor. 4384 * If there is a new event available 'nvp' will contain a newly allocated 4385 * nvlist and 'dropped' will be set to the number of missed events since 4386 * the last call to this function. When 'nvp' is set to NULL it indicates 4387 * no new events are available. In either case the function returns 0 and 4388 * it is up to the caller to free 'nvp'. In the case of a fatal error the 4389 * function will return a non-zero value. When the function is called in 4390 * blocking mode (the default, unless the ZEVENT_NONBLOCK flag is passed), 4391 * it will not return until a new event is available. 4392 */ 4393 int 4394 zpool_events_next(libzfs_handle_t *hdl, nvlist_t **nvp, 4395 int *dropped, unsigned flags, int zevent_fd) 4396 { 4397 zfs_cmd_t zc = {"\0"}; 4398 int error = 0; 4399 4400 *nvp = NULL; 4401 *dropped = 0; 4402 zc.zc_cleanup_fd = zevent_fd; 4403 4404 if (flags & ZEVENT_NONBLOCK) 4405 zc.zc_guid = ZEVENT_NONBLOCK; 4406 4407 zcmd_alloc_dst_nvlist(hdl, &zc, ZEVENT_SIZE); 4408 4409 retry: 4410 if (zfs_ioctl(hdl, ZFS_IOC_EVENTS_NEXT, &zc) != 0) { 4411 switch (errno) { 4412 case ESHUTDOWN: 4413 error = zfs_error_fmt(hdl, EZFS_POOLUNAVAIL, 4414 dgettext(TEXT_DOMAIN, "zfs shutdown")); 4415 goto out; 4416 case ENOENT: 4417 /* Blocking error case should not occur */ 4418 if (!(flags & ZEVENT_NONBLOCK)) 4419 error = zpool_standard_error_fmt(hdl, errno, 4420 dgettext(TEXT_DOMAIN, "cannot get event")); 4421 4422 goto out; 4423 case ENOMEM: 4424 zcmd_expand_dst_nvlist(hdl, &zc); 4425 goto retry; 4426 default: 4427 error = zpool_standard_error_fmt(hdl, errno, 4428 dgettext(TEXT_DOMAIN, "cannot get event")); 4429 goto out; 4430 } 4431 } 4432 4433 error = zcmd_read_dst_nvlist(hdl, &zc, nvp); 4434 if (error != 0) 4435 goto out; 4436 4437 *dropped = (int)zc.zc_cookie; 4438 out: 4439 zcmd_free_nvlists(&zc); 4440 4441 return (error); 4442 } 4443 4444 /* 4445 * Clear all events. 4446 */ 4447 int 4448 zpool_events_clear(libzfs_handle_t *hdl, int *count) 4449 { 4450 zfs_cmd_t zc = {"\0"}; 4451 4452 if (zfs_ioctl(hdl, ZFS_IOC_EVENTS_CLEAR, &zc) != 0) 4453 return (zpool_standard_error(hdl, errno, 4454 dgettext(TEXT_DOMAIN, "cannot clear events"))); 4455 4456 if (count != NULL) 4457 *count = (int)zc.zc_cookie; /* # of events cleared */ 4458 4459 return (0); 4460 } 4461 4462 /* 4463 * Seek to a specific EID, ZEVENT_SEEK_START, or ZEVENT_SEEK_END for 4464 * the passed zevent_fd file handle. On success zero is returned, 4465 * otherwise -1 is returned and hdl->libzfs_error is set to the errno. 4466 */ 4467 int 4468 zpool_events_seek(libzfs_handle_t *hdl, uint64_t eid, int zevent_fd) 4469 { 4470 zfs_cmd_t zc = {"\0"}; 4471 int error = 0; 4472 4473 zc.zc_guid = eid; 4474 zc.zc_cleanup_fd = zevent_fd; 4475 4476 if (zfs_ioctl(hdl, ZFS_IOC_EVENTS_SEEK, &zc) != 0) { 4477 switch (errno) { 4478 case ENOENT: 4479 error = zfs_error_fmt(hdl, EZFS_NOENT, 4480 dgettext(TEXT_DOMAIN, "cannot get event")); 4481 break; 4482 4483 case ENOMEM: 4484 error = zfs_error_fmt(hdl, EZFS_NOMEM, 4485 dgettext(TEXT_DOMAIN, "cannot get event")); 4486 break; 4487 4488 default: 4489 error = zpool_standard_error_fmt(hdl, errno, 4490 dgettext(TEXT_DOMAIN, "cannot get event")); 4491 break; 4492 } 4493 } 4494 4495 return (error); 4496 } 4497 4498 static void 4499 zpool_obj_to_path_impl(zpool_handle_t *zhp, uint64_t dsobj, uint64_t obj, 4500 char *pathname, size_t len, boolean_t always_unmounted) 4501 { 4502 zfs_cmd_t zc = {"\0"}; 4503 boolean_t mounted = B_FALSE; 4504 char *mntpnt = NULL; 4505 char dsname[ZFS_MAX_DATASET_NAME_LEN]; 4506 4507 if (dsobj == 0) { 4508 /* special case for the MOS */ 4509 (void) snprintf(pathname, len, "<metadata>:<0x%llx>", 4510 (longlong_t)obj); 4511 return; 4512 } 4513 4514 /* get the dataset's name */ 4515 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name)); 4516 zc.zc_obj = dsobj; 4517 if (zfs_ioctl(zhp->zpool_hdl, 4518 ZFS_IOC_DSOBJ_TO_DSNAME, &zc) != 0) { 4519 /* just write out a path of two object numbers */ 4520 (void) snprintf(pathname, len, "<0x%llx>:<0x%llx>", 4521 (longlong_t)dsobj, (longlong_t)obj); 4522 return; 4523 } 4524 (void) strlcpy(dsname, zc.zc_value, sizeof (dsname)); 4525 4526 /* find out if the dataset is mounted */ 4527 mounted = !always_unmounted && is_mounted(zhp->zpool_hdl, dsname, 4528 &mntpnt); 4529 4530 /* get the corrupted object's path */ 4531 (void) strlcpy(zc.zc_name, dsname, sizeof (zc.zc_name)); 4532 zc.zc_obj = obj; 4533 if (zfs_ioctl(zhp->zpool_hdl, ZFS_IOC_OBJ_TO_PATH, 4534 &zc) == 0) { 4535 if (mounted) { 4536 (void) snprintf(pathname, len, "%s%s", mntpnt, 4537 zc.zc_value); 4538 } else { 4539 (void) snprintf(pathname, len, "%s:%s", 4540 dsname, zc.zc_value); 4541 } 4542 } else { 4543 (void) snprintf(pathname, len, "%s:<0x%llx>", dsname, 4544 (longlong_t)obj); 4545 } 4546 free(mntpnt); 4547 } 4548 4549 void 4550 zpool_obj_to_path(zpool_handle_t *zhp, uint64_t dsobj, uint64_t obj, 4551 char *pathname, size_t len) 4552 { 4553 zpool_obj_to_path_impl(zhp, dsobj, obj, pathname, len, B_FALSE); 4554 } 4555 4556 void 4557 zpool_obj_to_path_ds(zpool_handle_t *zhp, uint64_t dsobj, uint64_t obj, 4558 char *pathname, size_t len) 4559 { 4560 zpool_obj_to_path_impl(zhp, dsobj, obj, pathname, len, B_TRUE); 4561 } 4562 /* 4563 * Wait while the specified activity is in progress in the pool. 4564 */ 4565 int 4566 zpool_wait(zpool_handle_t *zhp, zpool_wait_activity_t activity) 4567 { 4568 boolean_t missing; 4569 4570 int error = zpool_wait_status(zhp, activity, &missing, NULL); 4571 4572 if (missing) { 4573 (void) zpool_standard_error_fmt(zhp->zpool_hdl, ENOENT, 4574 dgettext(TEXT_DOMAIN, "error waiting in pool '%s'"), 4575 zhp->zpool_name); 4576 return (ENOENT); 4577 } else { 4578 return (error); 4579 } 4580 } 4581 4582 /* 4583 * Wait for the given activity and return the status of the wait (whether or not 4584 * any waiting was done) in the 'waited' parameter. Non-existent pools are 4585 * reported via the 'missing' parameter, rather than by printing an error 4586 * message. This is convenient when this function is called in a loop over a 4587 * long period of time (as it is, for example, by zpool's wait cmd). In that 4588 * scenario, a pool being exported or destroyed should be considered a normal 4589 * event, so we don't want to print an error when we find that the pool doesn't 4590 * exist. 4591 */ 4592 int 4593 zpool_wait_status(zpool_handle_t *zhp, zpool_wait_activity_t activity, 4594 boolean_t *missing, boolean_t *waited) 4595 { 4596 int error = lzc_wait(zhp->zpool_name, activity, waited); 4597 *missing = (error == ENOENT); 4598 if (*missing) 4599 return (0); 4600 4601 if (error != 0) { 4602 (void) zpool_standard_error_fmt(zhp->zpool_hdl, error, 4603 dgettext(TEXT_DOMAIN, "error waiting in pool '%s'"), 4604 zhp->zpool_name); 4605 } 4606 4607 return (error); 4608 } 4609 4610 int 4611 zpool_set_bootenv(zpool_handle_t *zhp, const nvlist_t *envmap) 4612 { 4613 int error = lzc_set_bootenv(zhp->zpool_name, envmap); 4614 if (error != 0) { 4615 (void) zpool_standard_error_fmt(zhp->zpool_hdl, error, 4616 dgettext(TEXT_DOMAIN, 4617 "error setting bootenv in pool '%s'"), zhp->zpool_name); 4618 } 4619 4620 return (error); 4621 } 4622 4623 int 4624 zpool_get_bootenv(zpool_handle_t *zhp, nvlist_t **nvlp) 4625 { 4626 nvlist_t *nvl; 4627 int error; 4628 4629 nvl = NULL; 4630 error = lzc_get_bootenv(zhp->zpool_name, &nvl); 4631 if (error != 0) { 4632 (void) zpool_standard_error_fmt(zhp->zpool_hdl, error, 4633 dgettext(TEXT_DOMAIN, 4634 "error getting bootenv in pool '%s'"), zhp->zpool_name); 4635 } else { 4636 *nvlp = nvl; 4637 } 4638 4639 return (error); 4640 } 4641 4642 /* 4643 * Attempt to read and parse feature file(s) (from "compatibility" property). 4644 * Files contain zpool feature names, comma or whitespace-separated. 4645 * Comments (# character to next newline) are discarded. 4646 * 4647 * Arguments: 4648 * compatibility : string containing feature filenames 4649 * features : either NULL or pointer to array of boolean 4650 * report : either NULL or pointer to string buffer 4651 * rlen : length of "report" buffer 4652 * 4653 * compatibility is NULL (unset), "", "off", "legacy", or list of 4654 * comma-separated filenames. filenames should either be absolute, 4655 * or relative to: 4656 * 1) ZPOOL_SYSCONF_COMPAT_D (eg: /etc/zfs/compatibility.d) or 4657 * 2) ZPOOL_DATA_COMPAT_D (eg: /usr/share/zfs/compatibility.d). 4658 * (Unset), "" or "off" => enable all features 4659 * "legacy" => disable all features 4660 * 4661 * Any feature names read from files which match unames in spa_feature_table 4662 * will have the corresponding boolean set in the features array (if non-NULL). 4663 * If more than one feature set specified, only features present in *all* of 4664 * them will be set. 4665 * 4666 * "report" if not NULL will be populated with a suitable status message. 4667 * 4668 * Return values: 4669 * ZPOOL_COMPATIBILITY_OK : files read and parsed ok 4670 * ZPOOL_COMPATIBILITY_BADFILE : file too big or not a text file 4671 * ZPOOL_COMPATIBILITY_BADTOKEN : SYSCONF file contains invalid feature name 4672 * ZPOOL_COMPATIBILITY_WARNTOKEN : DATA file contains invalid feature name 4673 * ZPOOL_COMPATIBILITY_NOFILES : no feature files found 4674 */ 4675 zpool_compat_status_t 4676 zpool_load_compat(const char *compat, boolean_t *features, char *report, 4677 size_t rlen) 4678 { 4679 int sdirfd, ddirfd, featfd; 4680 struct stat fs; 4681 char *fc; 4682 char *ps, *ls, *ws; 4683 char *file, *line, *word; 4684 4685 char l_compat[ZFS_MAXPROPLEN]; 4686 4687 boolean_t ret_nofiles = B_TRUE; 4688 boolean_t ret_badfile = B_FALSE; 4689 boolean_t ret_badtoken = B_FALSE; 4690 boolean_t ret_warntoken = B_FALSE; 4691 4692 /* special cases (unset), "" and "off" => enable all features */ 4693 if (compat == NULL || compat[0] == '\0' || 4694 strcmp(compat, ZPOOL_COMPAT_OFF) == 0) { 4695 if (features != NULL) 4696 for (uint_t i = 0; i < SPA_FEATURES; i++) 4697 features[i] = B_TRUE; 4698 if (report != NULL) 4699 strlcpy(report, gettext("all features enabled"), rlen); 4700 return (ZPOOL_COMPATIBILITY_OK); 4701 } 4702 4703 /* Final special case "legacy" => disable all features */ 4704 if (strcmp(compat, ZPOOL_COMPAT_LEGACY) == 0) { 4705 if (features != NULL) 4706 for (uint_t i = 0; i < SPA_FEATURES; i++) 4707 features[i] = B_FALSE; 4708 if (report != NULL) 4709 strlcpy(report, gettext("all features disabled"), rlen); 4710 return (ZPOOL_COMPATIBILITY_OK); 4711 } 4712 4713 /* 4714 * Start with all true; will be ANDed with results from each file 4715 */ 4716 if (features != NULL) 4717 for (uint_t i = 0; i < SPA_FEATURES; i++) 4718 features[i] = B_TRUE; 4719 4720 char err_badfile[ZFS_MAXPROPLEN] = ""; 4721 char err_badtoken[ZFS_MAXPROPLEN] = ""; 4722 4723 /* 4724 * We ignore errors from the directory open() 4725 * as they're only needed if the filename is relative 4726 * which will be checked during the openat(). 4727 */ 4728 4729 /* O_PATH safer than O_RDONLY if system allows it */ 4730 #if defined(O_PATH) 4731 #define ZC_DIR_FLAGS (O_DIRECTORY | O_CLOEXEC | O_PATH) 4732 #else 4733 #define ZC_DIR_FLAGS (O_DIRECTORY | O_CLOEXEC | O_RDONLY) 4734 #endif 4735 4736 sdirfd = open(ZPOOL_SYSCONF_COMPAT_D, ZC_DIR_FLAGS); 4737 ddirfd = open(ZPOOL_DATA_COMPAT_D, ZC_DIR_FLAGS); 4738 4739 (void) strlcpy(l_compat, compat, ZFS_MAXPROPLEN); 4740 4741 for (file = strtok_r(l_compat, ",", &ps); 4742 file != NULL; 4743 file = strtok_r(NULL, ",", &ps)) { 4744 4745 boolean_t l_features[SPA_FEATURES]; 4746 4747 enum { Z_SYSCONF, Z_DATA } source; 4748 4749 /* try sysconfdir first, then datadir */ 4750 source = Z_SYSCONF; 4751 if ((featfd = openat(sdirfd, file, O_RDONLY | O_CLOEXEC)) < 0) { 4752 featfd = openat(ddirfd, file, O_RDONLY | O_CLOEXEC); 4753 source = Z_DATA; 4754 } 4755 4756 /* File readable and correct size? */ 4757 if (featfd < 0 || 4758 fstat(featfd, &fs) < 0 || 4759 fs.st_size < 1 || 4760 fs.st_size > ZPOOL_COMPAT_MAXSIZE) { 4761 (void) close(featfd); 4762 strlcat(err_badfile, file, ZFS_MAXPROPLEN); 4763 strlcat(err_badfile, " ", ZFS_MAXPROPLEN); 4764 ret_badfile = B_TRUE; 4765 continue; 4766 } 4767 4768 /* Prefault the file if system allows */ 4769 #if defined(MAP_POPULATE) 4770 #define ZC_MMAP_FLAGS (MAP_PRIVATE | MAP_POPULATE) 4771 #elif defined(MAP_PREFAULT_READ) 4772 #define ZC_MMAP_FLAGS (MAP_PRIVATE | MAP_PREFAULT_READ) 4773 #else 4774 #define ZC_MMAP_FLAGS (MAP_PRIVATE) 4775 #endif 4776 4777 /* private mmap() so we can strtok safely */ 4778 fc = (char *)mmap(NULL, fs.st_size, PROT_READ | PROT_WRITE, 4779 ZC_MMAP_FLAGS, featfd, 0); 4780 (void) close(featfd); 4781 4782 /* map ok, and last character == newline? */ 4783 if (fc == MAP_FAILED || fc[fs.st_size - 1] != '\n') { 4784 (void) munmap((void *) fc, fs.st_size); 4785 strlcat(err_badfile, file, ZFS_MAXPROPLEN); 4786 strlcat(err_badfile, " ", ZFS_MAXPROPLEN); 4787 ret_badfile = B_TRUE; 4788 continue; 4789 } 4790 4791 ret_nofiles = B_FALSE; 4792 4793 for (uint_t i = 0; i < SPA_FEATURES; i++) 4794 l_features[i] = B_FALSE; 4795 4796 /* replace final newline with NULL to ensure string ends */ 4797 fc[fs.st_size - 1] = '\0'; 4798 4799 for (line = strtok_r(fc, "\n", &ls); 4800 line != NULL; 4801 line = strtok_r(NULL, "\n", &ls)) { 4802 /* discard comments */ 4803 char *r = strchr(line, '#'); 4804 if (r != NULL) 4805 *r = '\0'; 4806 4807 for (word = strtok_r(line, ", \t", &ws); 4808 word != NULL; 4809 word = strtok_r(NULL, ", \t", &ws)) { 4810 /* Find matching feature name */ 4811 uint_t f; 4812 for (f = 0; f < SPA_FEATURES; f++) { 4813 zfeature_info_t *fi = 4814 &spa_feature_table[f]; 4815 if (strcmp(word, fi->fi_uname) == 0) { 4816 l_features[f] = B_TRUE; 4817 break; 4818 } 4819 } 4820 if (f < SPA_FEATURES) 4821 continue; 4822 4823 /* found an unrecognized word */ 4824 /* lightly sanitize it */ 4825 if (strlen(word) > 32) 4826 word[32] = '\0'; 4827 for (char *c = word; *c != '\0'; c++) 4828 if (!isprint(*c)) 4829 *c = '?'; 4830 4831 strlcat(err_badtoken, word, ZFS_MAXPROPLEN); 4832 strlcat(err_badtoken, " ", ZFS_MAXPROPLEN); 4833 if (source == Z_SYSCONF) 4834 ret_badtoken = B_TRUE; 4835 else 4836 ret_warntoken = B_TRUE; 4837 } 4838 } 4839 (void) munmap((void *) fc, fs.st_size); 4840 4841 if (features != NULL) 4842 for (uint_t i = 0; i < SPA_FEATURES; i++) 4843 features[i] &= l_features[i]; 4844 } 4845 (void) close(sdirfd); 4846 (void) close(ddirfd); 4847 4848 /* Return the most serious error */ 4849 if (ret_badfile) { 4850 if (report != NULL) 4851 snprintf(report, rlen, gettext("could not read/" 4852 "parse feature file(s): %s"), err_badfile); 4853 return (ZPOOL_COMPATIBILITY_BADFILE); 4854 } 4855 if (ret_nofiles) { 4856 if (report != NULL) 4857 strlcpy(report, 4858 gettext("no valid compatibility files specified"), 4859 rlen); 4860 return (ZPOOL_COMPATIBILITY_NOFILES); 4861 } 4862 if (ret_badtoken) { 4863 if (report != NULL) 4864 snprintf(report, rlen, gettext("invalid feature " 4865 "name(s) in local compatibility files: %s"), 4866 err_badtoken); 4867 return (ZPOOL_COMPATIBILITY_BADTOKEN); 4868 } 4869 if (ret_warntoken) { 4870 if (report != NULL) 4871 snprintf(report, rlen, gettext("unrecognized feature " 4872 "name(s) in distribution compatibility files: %s"), 4873 err_badtoken); 4874 return (ZPOOL_COMPATIBILITY_WARNTOKEN); 4875 } 4876 if (report != NULL) 4877 strlcpy(report, gettext("compatibility set ok"), rlen); 4878 return (ZPOOL_COMPATIBILITY_OK); 4879 } 4880 4881 static int 4882 zpool_vdev_guid(zpool_handle_t *zhp, const char *vdevname, uint64_t *vdev_guid) 4883 { 4884 nvlist_t *tgt; 4885 boolean_t avail_spare, l2cache; 4886 4887 verify(zhp != NULL); 4888 if (zpool_get_state(zhp) == POOL_STATE_UNAVAIL) { 4889 char errbuf[ERRBUFLEN]; 4890 (void) snprintf(errbuf, sizeof (errbuf), 4891 dgettext(TEXT_DOMAIN, "pool is in an unavailable state")); 4892 return (zfs_error(zhp->zpool_hdl, EZFS_POOLUNAVAIL, errbuf)); 4893 } 4894 4895 if ((tgt = zpool_find_vdev(zhp, vdevname, &avail_spare, &l2cache, 4896 NULL)) == NULL) { 4897 char errbuf[ERRBUFLEN]; 4898 (void) snprintf(errbuf, sizeof (errbuf), 4899 dgettext(TEXT_DOMAIN, "can not find %s in %s"), 4900 vdevname, zhp->zpool_name); 4901 return (zfs_error(zhp->zpool_hdl, EZFS_NODEVICE, errbuf)); 4902 } 4903 4904 *vdev_guid = fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID); 4905 return (0); 4906 } 4907 4908 /* 4909 * Get a vdev property value for 'prop' and return the value in 4910 * a pre-allocated buffer. 4911 */ 4912 int 4913 zpool_get_vdev_prop_value(nvlist_t *nvprop, vdev_prop_t prop, char *prop_name, 4914 char *buf, size_t len, zprop_source_t *srctype, boolean_t literal) 4915 { 4916 nvlist_t *nv; 4917 const char *strval; 4918 uint64_t intval; 4919 zprop_source_t src = ZPROP_SRC_NONE; 4920 4921 if (prop == VDEV_PROP_USERPROP) { 4922 /* user property, prop_name must contain the property name */ 4923 assert(prop_name != NULL); 4924 if (nvlist_lookup_nvlist(nvprop, prop_name, &nv) == 0) { 4925 src = fnvlist_lookup_uint64(nv, ZPROP_SOURCE); 4926 strval = fnvlist_lookup_string(nv, ZPROP_VALUE); 4927 } else { 4928 /* user prop not found */ 4929 return (-1); 4930 } 4931 (void) strlcpy(buf, strval, len); 4932 if (srctype) 4933 *srctype = src; 4934 return (0); 4935 } 4936 4937 if (prop_name == NULL) 4938 prop_name = (char *)vdev_prop_to_name(prop); 4939 4940 switch (vdev_prop_get_type(prop)) { 4941 case PROP_TYPE_STRING: 4942 if (nvlist_lookup_nvlist(nvprop, prop_name, &nv) == 0) { 4943 src = fnvlist_lookup_uint64(nv, ZPROP_SOURCE); 4944 strval = fnvlist_lookup_string(nv, ZPROP_VALUE); 4945 } else { 4946 src = ZPROP_SRC_DEFAULT; 4947 if ((strval = vdev_prop_default_string(prop)) == NULL) 4948 strval = "-"; 4949 } 4950 (void) strlcpy(buf, strval, len); 4951 break; 4952 4953 case PROP_TYPE_NUMBER: 4954 if (nvlist_lookup_nvlist(nvprop, prop_name, &nv) == 0) { 4955 src = fnvlist_lookup_uint64(nv, ZPROP_SOURCE); 4956 intval = fnvlist_lookup_uint64(nv, ZPROP_VALUE); 4957 } else { 4958 src = ZPROP_SRC_DEFAULT; 4959 intval = vdev_prop_default_numeric(prop); 4960 } 4961 4962 switch (prop) { 4963 case VDEV_PROP_ASIZE: 4964 case VDEV_PROP_PSIZE: 4965 case VDEV_PROP_SIZE: 4966 case VDEV_PROP_BOOTSIZE: 4967 case VDEV_PROP_ALLOCATED: 4968 case VDEV_PROP_FREE: 4969 case VDEV_PROP_READ_ERRORS: 4970 case VDEV_PROP_WRITE_ERRORS: 4971 case VDEV_PROP_CHECKSUM_ERRORS: 4972 case VDEV_PROP_INITIALIZE_ERRORS: 4973 case VDEV_PROP_OPS_NULL: 4974 case VDEV_PROP_OPS_READ: 4975 case VDEV_PROP_OPS_WRITE: 4976 case VDEV_PROP_OPS_FREE: 4977 case VDEV_PROP_OPS_CLAIM: 4978 case VDEV_PROP_OPS_TRIM: 4979 case VDEV_PROP_BYTES_NULL: 4980 case VDEV_PROP_BYTES_READ: 4981 case VDEV_PROP_BYTES_WRITE: 4982 case VDEV_PROP_BYTES_FREE: 4983 case VDEV_PROP_BYTES_CLAIM: 4984 case VDEV_PROP_BYTES_TRIM: 4985 if (literal) { 4986 (void) snprintf(buf, len, "%llu", 4987 (u_longlong_t)intval); 4988 } else { 4989 (void) zfs_nicenum(intval, buf, len); 4990 } 4991 break; 4992 case VDEV_PROP_EXPANDSZ: 4993 if (intval == 0) { 4994 (void) strlcpy(buf, "-", len); 4995 } else if (literal) { 4996 (void) snprintf(buf, len, "%llu", 4997 (u_longlong_t)intval); 4998 } else { 4999 (void) zfs_nicenum(intval, buf, len); 5000 } 5001 break; 5002 case VDEV_PROP_CAPACITY: 5003 if (literal) { 5004 (void) snprintf(buf, len, "%llu", 5005 (u_longlong_t)intval); 5006 } else { 5007 (void) snprintf(buf, len, "%llu%%", 5008 (u_longlong_t)intval); 5009 } 5010 break; 5011 case VDEV_PROP_CHECKSUM_N: 5012 case VDEV_PROP_CHECKSUM_T: 5013 case VDEV_PROP_IO_N: 5014 case VDEV_PROP_IO_T: 5015 if (intval == UINT64_MAX) { 5016 (void) strlcpy(buf, "-", len); 5017 } else { 5018 (void) snprintf(buf, len, "%llu", 5019 (u_longlong_t)intval); 5020 } 5021 break; 5022 case VDEV_PROP_FRAGMENTATION: 5023 if (intval == UINT64_MAX) { 5024 (void) strlcpy(buf, "-", len); 5025 } else { 5026 (void) snprintf(buf, len, "%llu%%", 5027 (u_longlong_t)intval); 5028 } 5029 break; 5030 case VDEV_PROP_STATE: 5031 if (literal) { 5032 (void) snprintf(buf, len, "%llu", 5033 (u_longlong_t)intval); 5034 } else { 5035 (void) strlcpy(buf, zpool_state_to_name(intval, 5036 VDEV_AUX_NONE), len); 5037 } 5038 break; 5039 default: 5040 (void) snprintf(buf, len, "%llu", 5041 (u_longlong_t)intval); 5042 } 5043 break; 5044 5045 case PROP_TYPE_INDEX: 5046 if (nvlist_lookup_nvlist(nvprop, prop_name, &nv) == 0) { 5047 src = fnvlist_lookup_uint64(nv, ZPROP_SOURCE); 5048 intval = fnvlist_lookup_uint64(nv, ZPROP_VALUE); 5049 } else { 5050 src = ZPROP_SRC_DEFAULT; 5051 intval = vdev_prop_default_numeric(prop); 5052 } 5053 if (vdev_prop_index_to_string(prop, intval, 5054 (const char **)&strval) != 0) 5055 return (-1); 5056 (void) strlcpy(buf, strval, len); 5057 break; 5058 5059 default: 5060 abort(); 5061 } 5062 5063 if (srctype) 5064 *srctype = src; 5065 5066 return (0); 5067 } 5068 5069 /* 5070 * Get a vdev property value for 'prop_name' and return the value in 5071 * a pre-allocated buffer. 5072 */ 5073 int 5074 zpool_get_vdev_prop(zpool_handle_t *zhp, const char *vdevname, vdev_prop_t prop, 5075 char *prop_name, char *buf, size_t len, zprop_source_t *srctype, 5076 boolean_t literal) 5077 { 5078 nvlist_t *reqnvl, *reqprops; 5079 nvlist_t *retprops = NULL; 5080 uint64_t vdev_guid = 0; 5081 int ret; 5082 5083 if ((ret = zpool_vdev_guid(zhp, vdevname, &vdev_guid)) != 0) 5084 return (ret); 5085 5086 if (nvlist_alloc(&reqnvl, NV_UNIQUE_NAME, 0) != 0) 5087 return (no_memory(zhp->zpool_hdl)); 5088 if (nvlist_alloc(&reqprops, NV_UNIQUE_NAME, 0) != 0) 5089 return (no_memory(zhp->zpool_hdl)); 5090 5091 fnvlist_add_uint64(reqnvl, ZPOOL_VDEV_PROPS_GET_VDEV, vdev_guid); 5092 5093 if (prop != VDEV_PROP_USERPROP) { 5094 /* prop_name overrides prop value */ 5095 if (prop_name != NULL) 5096 prop = vdev_name_to_prop(prop_name); 5097 else 5098 prop_name = (char *)vdev_prop_to_name(prop); 5099 assert(prop < VDEV_NUM_PROPS); 5100 } 5101 5102 assert(prop_name != NULL); 5103 if (nvlist_add_uint64(reqprops, prop_name, prop) != 0) { 5104 nvlist_free(reqnvl); 5105 nvlist_free(reqprops); 5106 return (no_memory(zhp->zpool_hdl)); 5107 } 5108 5109 fnvlist_add_nvlist(reqnvl, ZPOOL_VDEV_PROPS_GET_PROPS, reqprops); 5110 5111 ret = lzc_get_vdev_prop(zhp->zpool_name, reqnvl, &retprops); 5112 5113 if (ret == 0) { 5114 ret = zpool_get_vdev_prop_value(retprops, prop, prop_name, buf, 5115 len, srctype, literal); 5116 } else { 5117 char errbuf[ERRBUFLEN]; 5118 (void) snprintf(errbuf, sizeof (errbuf), 5119 dgettext(TEXT_DOMAIN, "cannot get vdev property %s from" 5120 " %s in %s"), prop_name, vdevname, zhp->zpool_name); 5121 (void) zpool_standard_error(zhp->zpool_hdl, ret, errbuf); 5122 } 5123 5124 nvlist_free(reqnvl); 5125 nvlist_free(reqprops); 5126 nvlist_free(retprops); 5127 5128 return (ret); 5129 } 5130 5131 /* 5132 * Get all vdev properties 5133 */ 5134 int 5135 zpool_get_all_vdev_props(zpool_handle_t *zhp, const char *vdevname, 5136 nvlist_t **outnvl) 5137 { 5138 nvlist_t *nvl = NULL; 5139 uint64_t vdev_guid = 0; 5140 int ret; 5141 5142 if ((ret = zpool_vdev_guid(zhp, vdevname, &vdev_guid)) != 0) 5143 return (ret); 5144 5145 if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) 5146 return (no_memory(zhp->zpool_hdl)); 5147 5148 fnvlist_add_uint64(nvl, ZPOOL_VDEV_PROPS_GET_VDEV, vdev_guid); 5149 5150 ret = lzc_get_vdev_prop(zhp->zpool_name, nvl, outnvl); 5151 5152 nvlist_free(nvl); 5153 5154 if (ret) { 5155 char errbuf[ERRBUFLEN]; 5156 (void) snprintf(errbuf, sizeof (errbuf), 5157 dgettext(TEXT_DOMAIN, "cannot get vdev properties for" 5158 " %s in %s"), vdevname, zhp->zpool_name); 5159 (void) zpool_standard_error(zhp->zpool_hdl, errno, errbuf); 5160 } 5161 5162 return (ret); 5163 } 5164 5165 /* 5166 * Set vdev property 5167 */ 5168 int 5169 zpool_set_vdev_prop(zpool_handle_t *zhp, const char *vdevname, 5170 const char *propname, const char *propval) 5171 { 5172 int ret; 5173 nvlist_t *nvl = NULL; 5174 nvlist_t *outnvl = NULL; 5175 nvlist_t *props; 5176 nvlist_t *realprops; 5177 prop_flags_t flags = { 0 }; 5178 uint64_t version; 5179 uint64_t vdev_guid; 5180 5181 if ((ret = zpool_vdev_guid(zhp, vdevname, &vdev_guid)) != 0) 5182 return (ret); 5183 5184 if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) 5185 return (no_memory(zhp->zpool_hdl)); 5186 if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0) 5187 return (no_memory(zhp->zpool_hdl)); 5188 5189 fnvlist_add_uint64(nvl, ZPOOL_VDEV_PROPS_SET_VDEV, vdev_guid); 5190 5191 if (nvlist_add_string(props, propname, propval) != 0) { 5192 nvlist_free(props); 5193 return (no_memory(zhp->zpool_hdl)); 5194 } 5195 5196 char errbuf[ERRBUFLEN]; 5197 (void) snprintf(errbuf, sizeof (errbuf), 5198 dgettext(TEXT_DOMAIN, "cannot set property %s for %s on %s"), 5199 propname, vdevname, zhp->zpool_name); 5200 5201 flags.vdevprop = 1; 5202 version = zpool_get_prop_int(zhp, ZPOOL_PROP_VERSION, NULL); 5203 if ((realprops = zpool_valid_proplist(zhp->zpool_hdl, 5204 zhp->zpool_name, props, version, flags, errbuf)) == NULL) { 5205 nvlist_free(props); 5206 nvlist_free(nvl); 5207 return (-1); 5208 } 5209 5210 nvlist_free(props); 5211 props = realprops; 5212 5213 fnvlist_add_nvlist(nvl, ZPOOL_VDEV_PROPS_SET_PROPS, props); 5214 5215 ret = lzc_set_vdev_prop(zhp->zpool_name, nvl, &outnvl); 5216 5217 nvlist_free(props); 5218 nvlist_free(nvl); 5219 nvlist_free(outnvl); 5220 5221 if (ret) 5222 (void) zpool_standard_error(zhp->zpool_hdl, errno, errbuf); 5223 5224 return (ret); 5225 } 5226