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