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