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