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