]> 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
zpool_valid_proplist() should not corrupt nvpair name string on error
[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 char *strval;
463 uint64_t intval;
464 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 *slash = '\0';
693
694 if (strval[0] != '\0' &&
695 (stat64(strval, &statbuf) != 0 ||
696 !S_ISDIR(statbuf.st_mode))) {
697 *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 *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 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 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 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 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 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 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 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 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 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 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 char *srchval, *val;
2660
2661 srchval = fnvpair_value_string(pair);
2662 if (nvlist_lookup_string(nv, srchkey, &val) != 0)
2663 break;
2664
2665 /*
2666 * Search for the requested value. Special cases:
2667 *
2668 * - ZPOOL_CONFIG_PATH for whole disk entries. These end in
2669 * "-part1", or "p1". The suffix is hidden from the user,
2670 * but included in the string, so this matches around it.
2671 * - ZPOOL_CONFIG_PATH for short names zfs_strcmp_shortname()
2672 * is used to check all possible expanded paths.
2673 * - looking for a top-level vdev name (i.e. ZPOOL_CONFIG_TYPE).
2674 *
2675 * Otherwise, all other searches are simple string compares.
2676 */
2677 if (strcmp(srchkey, ZPOOL_CONFIG_PATH) == 0) {
2678 uint64_t wholedisk = 0;
2679
2680 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_WHOLE_DISK,
2681 &wholedisk);
2682 if (zfs_strcmp_pathname(srchval, val, wholedisk) == 0)
2683 return (nv);
2684
2685 } else if (strcmp(srchkey, ZPOOL_CONFIG_TYPE) == 0) {
2686 char *type, *idx, *end, *p;
2687 uint64_t id, vdev_id;
2688
2689 /*
2690 * Determine our vdev type, keeping in mind
2691 * that the srchval is composed of a type and
2692 * vdev id pair (i.e. mirror-4).
2693 */
2694 if ((type = strdup(srchval)) == NULL)
2695 return (NULL);
2696
2697 if ((p = strrchr(type, '-')) == NULL) {
2698 free(type);
2699 break;
2700 }
2701 idx = p + 1;
2702 *p = '\0';
2703
2704 /*
2705 * If the types don't match then keep looking.
2706 */
2707 if (strncmp(val, type, strlen(val)) != 0) {
2708 free(type);
2709 break;
2710 }
2711
2712 verify(zpool_vdev_is_interior(type));
2713
2714 id = fnvlist_lookup_uint64(nv, ZPOOL_CONFIG_ID);
2715 errno = 0;
2716 vdev_id = strtoull(idx, &end, 10);
2717
2718 /*
2719 * If we are looking for a raidz and a parity is
2720 * specified, make sure it matches.
2721 */
2722 int rzlen = strlen(VDEV_TYPE_RAIDZ);
2723 assert(rzlen == strlen(VDEV_TYPE_DRAID));
2724 int typlen = strlen(type);
2725 if ((strncmp(type, VDEV_TYPE_RAIDZ, rzlen) == 0 ||
2726 strncmp(type, VDEV_TYPE_DRAID, rzlen) == 0) &&
2727 typlen != rzlen) {
2728 uint64_t vdev_parity;
2729 int parity = *(type + rzlen) - '0';
2730
2731 if (parity <= 0 || parity > 3 ||
2732 (typlen - rzlen) != 1) {
2733 /*
2734 * Nonsense parity specified, can
2735 * never match
2736 */
2737 free(type);
2738 return (NULL);
2739 }
2740 vdev_parity = fnvlist_lookup_uint64(nv,
2741 ZPOOL_CONFIG_NPARITY);
2742 if ((int)vdev_parity != parity) {
2743 free(type);
2744 break;
2745 }
2746 }
2747
2748 free(type);
2749 if (errno != 0)
2750 return (NULL);
2751
2752 /*
2753 * Now verify that we have the correct vdev id.
2754 */
2755 if (vdev_id == id)
2756 return (nv);
2757 }
2758
2759 /*
2760 * Common case
2761 */
2762 if (strcmp(srchval, val) == 0)
2763 return (nv);
2764 break;
2765 }
2766
2767 default:
2768 break;
2769 }
2770
2771 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
2772 &child, &children) != 0)
2773 return (NULL);
2774
2775 for (c = 0; c < children; c++) {
2776 if ((ret = vdev_to_nvlist_iter(child[c], search,
2777 avail_spare, l2cache, NULL)) != NULL) {
2778 /*
2779 * The 'is_log' value is only set for the toplevel
2780 * vdev, not the leaf vdevs. So we always lookup the
2781 * log device from the root of the vdev tree (where
2782 * 'log' is non-NULL).
2783 */
2784 if (log != NULL &&
2785 nvlist_lookup_uint64(child[c],
2786 ZPOOL_CONFIG_IS_LOG, &is_log) == 0 &&
2787 is_log) {
2788 *log = B_TRUE;
2789 }
2790 return (ret);
2791 }
2792 }
2793
2794 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES,
2795 &child, &children) == 0) {
2796 for (c = 0; c < children; c++) {
2797 if ((ret = vdev_to_nvlist_iter(child[c], search,
2798 avail_spare, l2cache, NULL)) != NULL) {
2799 *avail_spare = B_TRUE;
2800 return (ret);
2801 }
2802 }
2803 }
2804
2805 if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE,
2806 &child, &children) == 0) {
2807 for (c = 0; c < children; c++) {
2808 if ((ret = vdev_to_nvlist_iter(child[c], search,
2809 avail_spare, l2cache, NULL)) != NULL) {
2810 *l2cache = B_TRUE;
2811 return (ret);
2812 }
2813 }
2814 }
2815
2816 return (NULL);
2817 }
2818
2819 /*
2820 * Given a physical path or guid, find the associated vdev.
2821 */
2822 nvlist_t *
2823 zpool_find_vdev_by_physpath(zpool_handle_t *zhp, const char *ppath,
2824 boolean_t *avail_spare, boolean_t *l2cache, boolean_t *log)
2825 {
2826 nvlist_t *search, *nvroot, *ret;
2827 uint64_t guid;
2828 char *end;
2829
2830 search = fnvlist_alloc();
2831
2832 guid = strtoull(ppath, &end, 0);
2833 if (guid != 0 && *end == '\0') {
2834 fnvlist_add_uint64(search, ZPOOL_CONFIG_GUID, guid);
2835 } else {
2836 fnvlist_add_string(search, ZPOOL_CONFIG_PHYS_PATH, ppath);
2837 }
2838
2839 nvroot = fnvlist_lookup_nvlist(zhp->zpool_config,
2840 ZPOOL_CONFIG_VDEV_TREE);
2841
2842 *avail_spare = B_FALSE;
2843 *l2cache = B_FALSE;
2844 if (log != NULL)
2845 *log = B_FALSE;
2846 ret = vdev_to_nvlist_iter(nvroot, search, avail_spare, l2cache, log);
2847 fnvlist_free(search);
2848
2849 return (ret);
2850 }
2851
2852 /*
2853 * Determine if we have an "interior" top-level vdev (i.e mirror/raidz).
2854 */
2855 static boolean_t
2856 zpool_vdev_is_interior(const char *name)
2857 {
2858 if (strncmp(name, VDEV_TYPE_RAIDZ, strlen(VDEV_TYPE_RAIDZ)) == 0 ||
2859 strncmp(name, VDEV_TYPE_SPARE, strlen(VDEV_TYPE_SPARE)) == 0 ||
2860 strncmp(name,
2861 VDEV_TYPE_REPLACING, strlen(VDEV_TYPE_REPLACING)) == 0 ||
2862 strncmp(name, VDEV_TYPE_MIRROR, strlen(VDEV_TYPE_MIRROR)) == 0)
2863 return (B_TRUE);
2864
2865 if (strncmp(name, VDEV_TYPE_DRAID, strlen(VDEV_TYPE_DRAID)) == 0 &&
2866 !zpool_is_draid_spare(name))
2867 return (B_TRUE);
2868
2869 return (B_FALSE);
2870 }
2871
2872 nvlist_t *
2873 zpool_find_vdev(zpool_handle_t *zhp, const char *path, boolean_t *avail_spare,
2874 boolean_t *l2cache, boolean_t *log)
2875 {
2876 char *end;
2877 nvlist_t *nvroot, *search, *ret;
2878 uint64_t guid;
2879
2880 search = fnvlist_alloc();
2881
2882 guid = strtoull(path, &end, 0);
2883 if (guid != 0 && *end == '\0') {
2884 fnvlist_add_uint64(search, ZPOOL_CONFIG_GUID, guid);
2885 } else if (zpool_vdev_is_interior(path)) {
2886 fnvlist_add_string(search, ZPOOL_CONFIG_TYPE, path);
2887 } else {
2888 fnvlist_add_string(search, ZPOOL_CONFIG_PATH, path);
2889 }
2890
2891 nvroot = fnvlist_lookup_nvlist(zhp->zpool_config,
2892 ZPOOL_CONFIG_VDEV_TREE);
2893
2894 *avail_spare = B_FALSE;
2895 *l2cache = B_FALSE;
2896 if (log != NULL)
2897 *log = B_FALSE;
2898 ret = vdev_to_nvlist_iter(nvroot, search, avail_spare, l2cache, log);
2899 fnvlist_free(search);
2900
2901 return (ret);
2902 }
2903
2904 /*
2905 * Convert a vdev path to a GUID. Returns GUID or 0 on error.
2906 *
2907 * If is_spare, is_l2cache, or is_log is non-NULL, then store within it
2908 * if the VDEV is a spare, l2cache, or log device. If they're NULL then
2909 * ignore them.
2910 */
2911 static uint64_t
2912 zpool_vdev_path_to_guid_impl(zpool_handle_t *zhp, const char *path,
2913 boolean_t *is_spare, boolean_t *is_l2cache, boolean_t *is_log)
2914 {
2915 boolean_t spare = B_FALSE, l2cache = B_FALSE, log = B_FALSE;
2916 nvlist_t *tgt;
2917
2918 if ((tgt = zpool_find_vdev(zhp, path, &spare, &l2cache,
2919 &log)) == NULL)
2920 return (0);
2921
2922 if (is_spare != NULL)
2923 *is_spare = spare;
2924 if (is_l2cache != NULL)
2925 *is_l2cache = l2cache;
2926 if (is_log != NULL)
2927 *is_log = log;
2928
2929 return (fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID));
2930 }
2931
2932 /* Convert a vdev path to a GUID. Returns GUID or 0 on error. */
2933 uint64_t
2934 zpool_vdev_path_to_guid(zpool_handle_t *zhp, const char *path)
2935 {
2936 return (zpool_vdev_path_to_guid_impl(zhp, path, NULL, NULL, NULL));
2937 }
2938
2939 /*
2940 * Bring the specified vdev online. The 'flags' parameter is a set of the
2941 * ZFS_ONLINE_* flags.
2942 */
2943 int
2944 zpool_vdev_online(zpool_handle_t *zhp, const char *path, int flags,
2945 vdev_state_t *newstate)
2946 {
2947 zfs_cmd_t zc = {"\0"};
2948 char errbuf[ERRBUFLEN];
2949 nvlist_t *tgt;
2950 boolean_t avail_spare, l2cache, islog;
2951 libzfs_handle_t *hdl = zhp->zpool_hdl;
2952
2953 if (flags & ZFS_ONLINE_EXPAND) {
2954 (void) snprintf(errbuf, sizeof (errbuf),
2955 dgettext(TEXT_DOMAIN, "cannot expand %s"), path);
2956 } else {
2957 (void) snprintf(errbuf, sizeof (errbuf),
2958 dgettext(TEXT_DOMAIN, "cannot online %s"), path);
2959 }
2960
2961 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
2962 if ((tgt = zpool_find_vdev(zhp, path, &avail_spare, &l2cache,
2963 &islog)) == NULL)
2964 return (zfs_error(hdl, EZFS_NODEVICE, errbuf));
2965
2966 zc.zc_guid = fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID);
2967
2968 if (!(flags & ZFS_ONLINE_SPARE) && avail_spare)
2969 return (zfs_error(hdl, EZFS_ISSPARE, errbuf));
2970
2971 #ifndef __FreeBSD__
2972 char *pathname;
2973 if ((flags & ZFS_ONLINE_EXPAND ||
2974 zpool_get_prop_int(zhp, ZPOOL_PROP_AUTOEXPAND, NULL)) &&
2975 nvlist_lookup_string(tgt, ZPOOL_CONFIG_PATH, &pathname) == 0) {
2976 uint64_t wholedisk = 0;
2977
2978 (void) nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_WHOLE_DISK,
2979 &wholedisk);
2980
2981 /*
2982 * XXX - L2ARC 1.0 devices can't support expansion.
2983 */
2984 if (l2cache) {
2985 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2986 "cannot expand cache devices"));
2987 return (zfs_error(hdl, EZFS_VDEVNOTSUP, errbuf));
2988 }
2989
2990 if (wholedisk) {
2991 const char *fullpath = path;
2992 char buf[MAXPATHLEN];
2993 int error;
2994
2995 if (path[0] != '/') {
2996 error = zfs_resolve_shortname(path, buf,
2997 sizeof (buf));
2998 if (error != 0)
2999 return (zfs_error(hdl, EZFS_NODEVICE,
3000 errbuf));
3001
3002 fullpath = buf;
3003 }
3004
3005 error = zpool_relabel_disk(hdl, fullpath, errbuf);
3006 if (error != 0)
3007 return (error);
3008 }
3009 }
3010 #endif
3011
3012 zc.zc_cookie = VDEV_STATE_ONLINE;
3013 zc.zc_obj = flags;
3014
3015 if (zfs_ioctl(hdl, ZFS_IOC_VDEV_SET_STATE, &zc) != 0) {
3016 if (errno == EINVAL) {
3017 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "was split "
3018 "from this pool into a new one. Use '%s' "
3019 "instead"), "zpool detach");
3020 return (zfs_error(hdl, EZFS_POSTSPLIT_ONLINE, errbuf));
3021 }
3022 return (zpool_standard_error(hdl, errno, errbuf));
3023 }
3024
3025 *newstate = zc.zc_cookie;
3026 return (0);
3027 }
3028
3029 /*
3030 * Take the specified vdev offline
3031 */
3032 int
3033 zpool_vdev_offline(zpool_handle_t *zhp, const char *path, boolean_t istmp)
3034 {
3035 zfs_cmd_t zc = {"\0"};
3036 char errbuf[ERRBUFLEN];
3037 nvlist_t *tgt;
3038 boolean_t avail_spare, l2cache;
3039 libzfs_handle_t *hdl = zhp->zpool_hdl;
3040
3041 (void) snprintf(errbuf, sizeof (errbuf),
3042 dgettext(TEXT_DOMAIN, "cannot offline %s"), path);
3043
3044 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
3045 if ((tgt = zpool_find_vdev(zhp, path, &avail_spare, &l2cache,
3046 NULL)) == NULL)
3047 return (zfs_error(hdl, EZFS_NODEVICE, errbuf));
3048
3049 zc.zc_guid = fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID);
3050
3051 if (avail_spare)
3052 return (zfs_error(hdl, EZFS_ISSPARE, errbuf));
3053
3054 zc.zc_cookie = VDEV_STATE_OFFLINE;
3055 zc.zc_obj = istmp ? ZFS_OFFLINE_TEMPORARY : 0;
3056
3057 if (zfs_ioctl(hdl, ZFS_IOC_VDEV_SET_STATE, &zc) == 0)
3058 return (0);
3059
3060 switch (errno) {
3061 case EBUSY:
3062
3063 /*
3064 * There are no other replicas of this device.
3065 */
3066 return (zfs_error(hdl, EZFS_NOREPLICAS, errbuf));
3067
3068 case EEXIST:
3069 /*
3070 * The log device has unplayed logs
3071 */
3072 return (zfs_error(hdl, EZFS_UNPLAYED_LOGS, errbuf));
3073
3074 default:
3075 return (zpool_standard_error(hdl, errno, errbuf));
3076 }
3077 }
3078
3079 /*
3080 * Remove the specified vdev asynchronously from the configuration, so
3081 * that it may come ONLINE if reinserted. This is called from zed on
3082 * Udev remove event.
3083 * Note: We also have a similar function zpool_vdev_remove() that
3084 * removes the vdev from the pool.
3085 */
3086 int
3087 zpool_vdev_remove_wanted(zpool_handle_t *zhp, const char *path)
3088 {
3089 zfs_cmd_t zc = {"\0"};
3090 char errbuf[ERRBUFLEN];
3091 nvlist_t *tgt;
3092 boolean_t avail_spare, l2cache;
3093 libzfs_handle_t *hdl = zhp->zpool_hdl;
3094
3095 (void) snprintf(errbuf, sizeof (errbuf),
3096 dgettext(TEXT_DOMAIN, "cannot remove %s"), path);
3097
3098 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
3099 if ((tgt = zpool_find_vdev(zhp, path, &avail_spare, &l2cache,
3100 NULL)) == NULL)
3101 return (zfs_error(hdl, EZFS_NODEVICE, errbuf));
3102
3103 zc.zc_guid = fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID);
3104
3105 zc.zc_cookie = VDEV_STATE_REMOVED;
3106
3107 if (zfs_ioctl(hdl, ZFS_IOC_VDEV_SET_STATE, &zc) == 0)
3108 return (0);
3109
3110 return (zpool_standard_error(hdl, errno, errbuf));
3111 }
3112
3113 /*
3114 * Mark the given vdev faulted.
3115 */
3116 int
3117 zpool_vdev_fault(zpool_handle_t *zhp, uint64_t guid, vdev_aux_t aux)
3118 {
3119 zfs_cmd_t zc = {"\0"};
3120 char errbuf[ERRBUFLEN];
3121 libzfs_handle_t *hdl = zhp->zpool_hdl;
3122
3123 (void) snprintf(errbuf, sizeof (errbuf),
3124 dgettext(TEXT_DOMAIN, "cannot fault %llu"), (u_longlong_t)guid);
3125
3126 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
3127 zc.zc_guid = guid;
3128 zc.zc_cookie = VDEV_STATE_FAULTED;
3129 zc.zc_obj = aux;
3130
3131 if (zfs_ioctl(hdl, ZFS_IOC_VDEV_SET_STATE, &zc) == 0)
3132 return (0);
3133
3134 switch (errno) {
3135 case EBUSY:
3136
3137 /*
3138 * There are no other replicas of this device.
3139 */
3140 return (zfs_error(hdl, EZFS_NOREPLICAS, errbuf));
3141
3142 default:
3143 return (zpool_standard_error(hdl, errno, errbuf));
3144 }
3145
3146 }
3147
3148 /*
3149 * Mark the given vdev degraded.
3150 */
3151 int
3152 zpool_vdev_degrade(zpool_handle_t *zhp, uint64_t guid, vdev_aux_t aux)
3153 {
3154 zfs_cmd_t zc = {"\0"};
3155 char errbuf[ERRBUFLEN];
3156 libzfs_handle_t *hdl = zhp->zpool_hdl;
3157
3158 (void) snprintf(errbuf, sizeof (errbuf),
3159 dgettext(TEXT_DOMAIN, "cannot degrade %llu"), (u_longlong_t)guid);
3160
3161 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
3162 zc.zc_guid = guid;
3163 zc.zc_cookie = VDEV_STATE_DEGRADED;
3164 zc.zc_obj = aux;
3165
3166 if (zfs_ioctl(hdl, ZFS_IOC_VDEV_SET_STATE, &zc) == 0)
3167 return (0);
3168
3169 return (zpool_standard_error(hdl, errno, errbuf));
3170 }
3171
3172 /*
3173 * Returns TRUE if the given nvlist is a vdev that was originally swapped in as
3174 * a hot spare.
3175 */
3176 static boolean_t
3177 is_replacing_spare(nvlist_t *search, nvlist_t *tgt, int which)
3178 {
3179 nvlist_t **child;
3180 uint_t c, children;
3181
3182 if (nvlist_lookup_nvlist_array(search, ZPOOL_CONFIG_CHILDREN, &child,
3183 &children) == 0) {
3184 char *type = fnvlist_lookup_string(search, ZPOOL_CONFIG_TYPE);
3185 if ((strcmp(type, VDEV_TYPE_SPARE) == 0 ||
3186 strcmp(type, VDEV_TYPE_DRAID_SPARE) == 0) &&
3187 children == 2 && child[which] == tgt)
3188 return (B_TRUE);
3189
3190 for (c = 0; c < children; c++)
3191 if (is_replacing_spare(child[c], tgt, which))
3192 return (B_TRUE);
3193 }
3194
3195 return (B_FALSE);
3196 }
3197
3198 /*
3199 * Attach new_disk (fully described by nvroot) to old_disk.
3200 * If 'replacing' is specified, the new disk will replace the old one.
3201 */
3202 int
3203 zpool_vdev_attach(zpool_handle_t *zhp, const char *old_disk,
3204 const char *new_disk, nvlist_t *nvroot, int replacing, boolean_t rebuild)
3205 {
3206 zfs_cmd_t zc = {"\0"};
3207 char errbuf[ERRBUFLEN];
3208 int ret;
3209 nvlist_t *tgt;
3210 boolean_t avail_spare, l2cache, islog;
3211 uint64_t val;
3212 char *newname;
3213 nvlist_t **child;
3214 uint_t children;
3215 nvlist_t *config_root;
3216 libzfs_handle_t *hdl = zhp->zpool_hdl;
3217
3218 if (replacing)
3219 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
3220 "cannot replace %s with %s"), old_disk, new_disk);
3221 else
3222 (void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
3223 "cannot attach %s to %s"), new_disk, old_disk);
3224
3225 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
3226 if ((tgt = zpool_find_vdev(zhp, old_disk, &avail_spare, &l2cache,
3227 &islog)) == NULL)
3228 return (zfs_error(hdl, EZFS_NODEVICE, errbuf));
3229
3230 if (avail_spare)
3231 return (zfs_error(hdl, EZFS_ISSPARE, errbuf));
3232
3233 if (l2cache)
3234 return (zfs_error(hdl, EZFS_ISL2CACHE, errbuf));
3235
3236 zc.zc_guid = fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID);
3237 zc.zc_cookie = replacing;
3238 zc.zc_simple = rebuild;
3239
3240 if (rebuild &&
3241 zfeature_lookup_guid("org.openzfs:device_rebuild", NULL) != 0) {
3242 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3243 "the loaded zfs module doesn't support device rebuilds"));
3244 return (zfs_error(hdl, EZFS_POOL_NOTSUP, errbuf));
3245 }
3246
3247 if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN,
3248 &child, &children) != 0 || children != 1) {
3249 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3250 "new device must be a single disk"));
3251 return (zfs_error(hdl, EZFS_INVALCONFIG, errbuf));
3252 }
3253
3254 config_root = fnvlist_lookup_nvlist(zpool_get_config(zhp, NULL),
3255 ZPOOL_CONFIG_VDEV_TREE);
3256
3257 if ((newname = zpool_vdev_name(NULL, NULL, child[0], 0)) == NULL)
3258 return (-1);
3259
3260 /*
3261 * If the target is a hot spare that has been swapped in, we can only
3262 * replace it with another hot spare.
3263 */
3264 if (replacing &&
3265 nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_IS_SPARE, &val) == 0 &&
3266 (zpool_find_vdev(zhp, newname, &avail_spare, &l2cache,
3267 NULL) == NULL || !avail_spare) &&
3268 is_replacing_spare(config_root, tgt, 1)) {
3269 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3270 "can only be replaced by another hot spare"));
3271 free(newname);
3272 return (zfs_error(hdl, EZFS_BADTARGET, errbuf));
3273 }
3274
3275 free(newname);
3276
3277 zcmd_write_conf_nvlist(hdl, &zc, nvroot);
3278
3279 ret = zfs_ioctl(hdl, ZFS_IOC_VDEV_ATTACH, &zc);
3280
3281 zcmd_free_nvlists(&zc);
3282
3283 if (ret == 0)
3284 return (0);
3285
3286 switch (errno) {
3287 case ENOTSUP:
3288 /*
3289 * Can't attach to or replace this type of vdev.
3290 */
3291 if (replacing) {
3292 uint64_t version = zpool_get_prop_int(zhp,
3293 ZPOOL_PROP_VERSION, NULL);
3294
3295 if (islog) {
3296 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3297 "cannot replace a log with a spare"));
3298 } else if (rebuild) {
3299 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3300 "only mirror and dRAID vdevs support "
3301 "sequential reconstruction"));
3302 } else if (zpool_is_draid_spare(new_disk)) {
3303 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3304 "dRAID spares can only replace child "
3305 "devices in their parent's dRAID vdev"));
3306 } else if (version >= SPA_VERSION_MULTI_REPLACE) {
3307 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3308 "already in replacing/spare config; wait "
3309 "for completion or use 'zpool detach'"));
3310 } else {
3311 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3312 "cannot replace a replacing device"));
3313 }
3314 } else {
3315 char status[64] = {0};
3316 zpool_prop_get_feature(zhp,
3317 "feature@device_rebuild", status, 63);
3318 if (rebuild &&
3319 strncmp(status, ZFS_FEATURE_DISABLED, 64) == 0) {
3320 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3321 "device_rebuild feature must be enabled "
3322 "in order to use sequential "
3323 "reconstruction"));
3324 } else {
3325 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3326 "can only attach to mirrors and top-level "
3327 "disks"));
3328 }
3329 }
3330 (void) zfs_error(hdl, EZFS_BADTARGET, errbuf);
3331 break;
3332
3333 case EINVAL:
3334 /*
3335 * The new device must be a single disk.
3336 */
3337 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3338 "new device must be a single disk"));
3339 (void) zfs_error(hdl, EZFS_INVALCONFIG, errbuf);
3340 break;
3341
3342 case EBUSY:
3343 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "%s is busy, "
3344 "or device removal is in progress"),
3345 new_disk);
3346 (void) zfs_error(hdl, EZFS_BADDEV, errbuf);
3347 break;
3348
3349 case EOVERFLOW:
3350 /*
3351 * The new device is too small.
3352 */
3353 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3354 "device is too small"));
3355 (void) zfs_error(hdl, EZFS_BADDEV, errbuf);
3356 break;
3357
3358 case EDOM:
3359 /*
3360 * The new device has a different optimal sector size.
3361 */
3362 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3363 "new device has a different optimal sector size; use the "
3364 "option '-o ashift=N' to override the optimal size"));
3365 (void) zfs_error(hdl, EZFS_BADDEV, errbuf);
3366 break;
3367
3368 case ENAMETOOLONG:
3369 /*
3370 * The resulting top-level vdev spec won't fit in the label.
3371 */
3372 (void) zfs_error(hdl, EZFS_DEVOVERFLOW, errbuf);
3373 break;
3374
3375 default:
3376 (void) zpool_standard_error(hdl, errno, errbuf);
3377 }
3378
3379 return (-1);
3380 }
3381
3382 /*
3383 * Detach the specified device.
3384 */
3385 int
3386 zpool_vdev_detach(zpool_handle_t *zhp, const char *path)
3387 {
3388 zfs_cmd_t zc = {"\0"};
3389 char errbuf[ERRBUFLEN];
3390 nvlist_t *tgt;
3391 boolean_t avail_spare, l2cache;
3392 libzfs_handle_t *hdl = zhp->zpool_hdl;
3393
3394 (void) snprintf(errbuf, sizeof (errbuf),
3395 dgettext(TEXT_DOMAIN, "cannot detach %s"), path);
3396
3397 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
3398 if ((tgt = zpool_find_vdev(zhp, path, &avail_spare, &l2cache,
3399 NULL)) == NULL)
3400 return (zfs_error(hdl, EZFS_NODEVICE, errbuf));
3401
3402 if (avail_spare)
3403 return (zfs_error(hdl, EZFS_ISSPARE, errbuf));
3404
3405 if (l2cache)
3406 return (zfs_error(hdl, EZFS_ISL2CACHE, errbuf));
3407
3408 zc.zc_guid = fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID);
3409
3410 if (zfs_ioctl(hdl, ZFS_IOC_VDEV_DETACH, &zc) == 0)
3411 return (0);
3412
3413 switch (errno) {
3414
3415 case ENOTSUP:
3416 /*
3417 * Can't detach from this type of vdev.
3418 */
3419 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "only "
3420 "applicable to mirror and replacing vdevs"));
3421 (void) zfs_error(hdl, EZFS_BADTARGET, errbuf);
3422 break;
3423
3424 case EBUSY:
3425 /*
3426 * There are no other replicas of this device.
3427 */
3428 (void) zfs_error(hdl, EZFS_NOREPLICAS, errbuf);
3429 break;
3430
3431 default:
3432 (void) zpool_standard_error(hdl, errno, errbuf);
3433 }
3434
3435 return (-1);
3436 }
3437
3438 /*
3439 * Find a mirror vdev in the source nvlist.
3440 *
3441 * The mchild array contains a list of disks in one of the top-level mirrors
3442 * of the source pool. The schild array contains a list of disks that the
3443 * user specified on the command line. We loop over the mchild array to
3444 * see if any entry in the schild array matches.
3445 *
3446 * If a disk in the mchild array is found in the schild array, we return
3447 * the index of that entry. Otherwise we return -1.
3448 */
3449 static int
3450 find_vdev_entry(zpool_handle_t *zhp, nvlist_t **mchild, uint_t mchildren,
3451 nvlist_t **schild, uint_t schildren)
3452 {
3453 uint_t mc;
3454
3455 for (mc = 0; mc < mchildren; mc++) {
3456 uint_t sc;
3457 char *mpath = zpool_vdev_name(zhp->zpool_hdl, zhp,
3458 mchild[mc], 0);
3459
3460 for (sc = 0; sc < schildren; sc++) {
3461 char *spath = zpool_vdev_name(zhp->zpool_hdl, zhp,
3462 schild[sc], 0);
3463 boolean_t result = (strcmp(mpath, spath) == 0);
3464
3465 free(spath);
3466 if (result) {
3467 free(mpath);
3468 return (mc);
3469 }
3470 }
3471
3472 free(mpath);
3473 }
3474
3475 return (-1);
3476 }
3477
3478 /*
3479 * Split a mirror pool. If newroot points to null, then a new nvlist
3480 * is generated and it is the responsibility of the caller to free it.
3481 */
3482 int
3483 zpool_vdev_split(zpool_handle_t *zhp, char *newname, nvlist_t **newroot,
3484 nvlist_t *props, splitflags_t flags)
3485 {
3486 zfs_cmd_t zc = {"\0"};
3487 char errbuf[ERRBUFLEN], *bias;
3488 nvlist_t *tree, *config, **child, **newchild, *newconfig = NULL;
3489 nvlist_t **varray = NULL, *zc_props = NULL;
3490 uint_t c, children, newchildren, lastlog = 0, vcount, found = 0;
3491 libzfs_handle_t *hdl = zhp->zpool_hdl;
3492 uint64_t vers, readonly = B_FALSE;
3493 boolean_t freelist = B_FALSE, memory_err = B_TRUE;
3494 int retval = 0;
3495
3496 (void) snprintf(errbuf, sizeof (errbuf),
3497 dgettext(TEXT_DOMAIN, "Unable to split %s"), zhp->zpool_name);
3498
3499 if (!zpool_name_valid(hdl, B_FALSE, newname))
3500 return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
3501
3502 if ((config = zpool_get_config(zhp, NULL)) == NULL) {
3503 (void) fprintf(stderr, gettext("Internal error: unable to "
3504 "retrieve pool configuration\n"));
3505 return (-1);
3506 }
3507
3508 tree = fnvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE);
3509 vers = fnvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION);
3510
3511 if (props) {
3512 prop_flags_t flags = { .create = B_FALSE, .import = B_TRUE };
3513 if ((zc_props = zpool_valid_proplist(hdl, zhp->zpool_name,
3514 props, vers, flags, errbuf)) == NULL)
3515 return (-1);
3516 (void) nvlist_lookup_uint64(zc_props,
3517 zpool_prop_to_name(ZPOOL_PROP_READONLY), &readonly);
3518 if (readonly) {
3519 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3520 "property %s can only be set at import time"),
3521 zpool_prop_to_name(ZPOOL_PROP_READONLY));
3522 return (-1);
3523 }
3524 }
3525
3526 if (nvlist_lookup_nvlist_array(tree, ZPOOL_CONFIG_CHILDREN, &child,
3527 &children) != 0) {
3528 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3529 "Source pool is missing vdev tree"));
3530 nvlist_free(zc_props);
3531 return (-1);
3532 }
3533
3534 varray = zfs_alloc(hdl, children * sizeof (nvlist_t *));
3535 vcount = 0;
3536
3537 if (*newroot == NULL ||
3538 nvlist_lookup_nvlist_array(*newroot, ZPOOL_CONFIG_CHILDREN,
3539 &newchild, &newchildren) != 0)
3540 newchildren = 0;
3541
3542 for (c = 0; c < children; c++) {
3543 uint64_t is_log = B_FALSE, is_hole = B_FALSE;
3544 boolean_t is_special = B_FALSE, is_dedup = B_FALSE;
3545 char *type;
3546 nvlist_t **mchild, *vdev;
3547 uint_t mchildren;
3548 int entry;
3549
3550 /*
3551 * Unlike cache & spares, slogs are stored in the
3552 * ZPOOL_CONFIG_CHILDREN array. We filter them out here.
3553 */
3554 (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG,
3555 &is_log);
3556 (void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_HOLE,
3557 &is_hole);
3558 if (is_log || is_hole) {
3559 /*
3560 * Create a hole vdev and put it in the config.
3561 */
3562 if (nvlist_alloc(&vdev, NV_UNIQUE_NAME, 0) != 0)
3563 goto out;
3564 if (nvlist_add_string(vdev, ZPOOL_CONFIG_TYPE,
3565 VDEV_TYPE_HOLE) != 0)
3566 goto out;
3567 if (nvlist_add_uint64(vdev, ZPOOL_CONFIG_IS_HOLE,
3568 1) != 0)
3569 goto out;
3570 if (lastlog == 0)
3571 lastlog = vcount;
3572 varray[vcount++] = vdev;
3573 continue;
3574 }
3575 lastlog = 0;
3576 type = fnvlist_lookup_string(child[c], ZPOOL_CONFIG_TYPE);
3577
3578 if (strcmp(type, VDEV_TYPE_INDIRECT) == 0) {
3579 vdev = child[c];
3580 if (nvlist_dup(vdev, &varray[vcount++], 0) != 0)
3581 goto out;
3582 continue;
3583 } else if (strcmp(type, VDEV_TYPE_MIRROR) != 0) {
3584 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3585 "Source pool must be composed only of mirrors\n"));
3586 retval = zfs_error(hdl, EZFS_INVALCONFIG, errbuf);
3587 goto out;
3588 }
3589
3590 if (nvlist_lookup_string(child[c],
3591 ZPOOL_CONFIG_ALLOCATION_BIAS, &bias) == 0) {
3592 if (strcmp(bias, VDEV_ALLOC_BIAS_SPECIAL) == 0)
3593 is_special = B_TRUE;
3594 else if (strcmp(bias, VDEV_ALLOC_BIAS_DEDUP) == 0)
3595 is_dedup = B_TRUE;
3596 }
3597 verify(nvlist_lookup_nvlist_array(child[c],
3598 ZPOOL_CONFIG_CHILDREN, &mchild, &mchildren) == 0);
3599
3600 /* find or add an entry for this top-level vdev */
3601 if (newchildren > 0 &&
3602 (entry = find_vdev_entry(zhp, mchild, mchildren,
3603 newchild, newchildren)) >= 0) {
3604 /* We found a disk that the user specified. */
3605 vdev = mchild[entry];
3606 ++found;
3607 } else {
3608 /* User didn't specify a disk for this vdev. */
3609 vdev = mchild[mchildren - 1];
3610 }
3611
3612 if (nvlist_dup(vdev, &varray[vcount++], 0) != 0)
3613 goto out;
3614
3615 if (flags.dryrun != 0) {
3616 if (is_dedup == B_TRUE) {
3617 if (nvlist_add_string(varray[vcount - 1],
3618 ZPOOL_CONFIG_ALLOCATION_BIAS,
3619 VDEV_ALLOC_BIAS_DEDUP) != 0)
3620 goto out;
3621 } else if (is_special == B_TRUE) {
3622 if (nvlist_add_string(varray[vcount - 1],
3623 ZPOOL_CONFIG_ALLOCATION_BIAS,
3624 VDEV_ALLOC_BIAS_SPECIAL) != 0)
3625 goto out;
3626 }
3627 }
3628 }
3629
3630 /* did we find every disk the user specified? */
3631 if (found != newchildren) {
3632 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "Device list must "
3633 "include at most one disk from each mirror"));
3634 retval = zfs_error(hdl, EZFS_INVALCONFIG, errbuf);
3635 goto out;
3636 }
3637
3638 /* Prepare the nvlist for populating. */
3639 if (*newroot == NULL) {
3640 if (nvlist_alloc(newroot, NV_UNIQUE_NAME, 0) != 0)
3641 goto out;
3642 freelist = B_TRUE;
3643 if (nvlist_add_string(*newroot, ZPOOL_CONFIG_TYPE,
3644 VDEV_TYPE_ROOT) != 0)
3645 goto out;
3646 } else {
3647 verify(nvlist_remove_all(*newroot, ZPOOL_CONFIG_CHILDREN) == 0);
3648 }
3649
3650 /* Add all the children we found */
3651 if (nvlist_add_nvlist_array(*newroot, ZPOOL_CONFIG_CHILDREN,
3652 (const nvlist_t **)varray, lastlog == 0 ? vcount : lastlog) != 0)
3653 goto out;
3654
3655 /*
3656 * If we're just doing a dry run, exit now with success.
3657 */
3658 if (flags.dryrun) {
3659 memory_err = B_FALSE;
3660 freelist = B_FALSE;
3661 goto out;
3662 }
3663
3664 /* now build up the config list & call the ioctl */
3665 if (nvlist_alloc(&newconfig, NV_UNIQUE_NAME, 0) != 0)
3666 goto out;
3667
3668 if (nvlist_add_nvlist(newconfig,
3669 ZPOOL_CONFIG_VDEV_TREE, *newroot) != 0 ||
3670 nvlist_add_string(newconfig,
3671 ZPOOL_CONFIG_POOL_NAME, newname) != 0 ||
3672 nvlist_add_uint64(newconfig, ZPOOL_CONFIG_VERSION, vers) != 0)
3673 goto out;
3674
3675 /*
3676 * The new pool is automatically part of the namespace unless we
3677 * explicitly export it.
3678 */
3679 if (!flags.import)
3680 zc.zc_cookie = ZPOOL_EXPORT_AFTER_SPLIT;
3681 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
3682 (void) strlcpy(zc.zc_string, newname, sizeof (zc.zc_string));
3683 zcmd_write_conf_nvlist(hdl, &zc, newconfig);
3684 if (zc_props != NULL)
3685 zcmd_write_src_nvlist(hdl, &zc, zc_props);
3686
3687 if (zfs_ioctl(hdl, ZFS_IOC_VDEV_SPLIT, &zc) != 0) {
3688 retval = zpool_standard_error(hdl, errno, errbuf);
3689 goto out;
3690 }
3691
3692 freelist = B_FALSE;
3693 memory_err = B_FALSE;
3694
3695 out:
3696 if (varray != NULL) {
3697 int v;
3698
3699 for (v = 0; v < vcount; v++)
3700 nvlist_free(varray[v]);
3701 free(varray);
3702 }
3703 zcmd_free_nvlists(&zc);
3704 nvlist_free(zc_props);
3705 nvlist_free(newconfig);
3706 if (freelist) {
3707 nvlist_free(*newroot);
3708 *newroot = NULL;
3709 }
3710
3711 if (retval != 0)
3712 return (retval);
3713
3714 if (memory_err)
3715 return (no_memory(hdl));
3716
3717 return (0);
3718 }
3719
3720 /*
3721 * Remove the given device.
3722 */
3723 int
3724 zpool_vdev_remove(zpool_handle_t *zhp, const char *path)
3725 {
3726 zfs_cmd_t zc = {"\0"};
3727 char errbuf[ERRBUFLEN];
3728 nvlist_t *tgt;
3729 boolean_t avail_spare, l2cache, islog;
3730 libzfs_handle_t *hdl = zhp->zpool_hdl;
3731 uint64_t version;
3732
3733 (void) snprintf(errbuf, sizeof (errbuf),
3734 dgettext(TEXT_DOMAIN, "cannot remove %s"), path);
3735
3736 if (zpool_is_draid_spare(path)) {
3737 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3738 "dRAID spares cannot be removed"));
3739 return (zfs_error(hdl, EZFS_NODEVICE, errbuf));
3740 }
3741
3742 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
3743 if ((tgt = zpool_find_vdev(zhp, path, &avail_spare, &l2cache,
3744 &islog)) == NULL)
3745 return (zfs_error(hdl, EZFS_NODEVICE, errbuf));
3746
3747 version = zpool_get_prop_int(zhp, ZPOOL_PROP_VERSION, NULL);
3748 if (islog && version < SPA_VERSION_HOLES) {
3749 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3750 "pool must be upgraded to support log removal"));
3751 return (zfs_error(hdl, EZFS_BADVERSION, errbuf));
3752 }
3753
3754 zc.zc_guid = fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID);
3755
3756 if (zfs_ioctl(hdl, ZFS_IOC_VDEV_REMOVE, &zc) == 0)
3757 return (0);
3758
3759 switch (errno) {
3760
3761 case EINVAL:
3762 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3763 "invalid config; all top-level vdevs must "
3764 "have the same sector size and not be raidz."));
3765 (void) zfs_error(hdl, EZFS_INVALCONFIG, errbuf);
3766 break;
3767
3768 case EBUSY:
3769 if (islog) {
3770 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3771 "Mount encrypted datasets to replay logs."));
3772 } else {
3773 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3774 "Pool busy; removal may already be in progress"));
3775 }
3776 (void) zfs_error(hdl, EZFS_BUSY, errbuf);
3777 break;
3778
3779 case EACCES:
3780 if (islog) {
3781 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3782 "Mount encrypted datasets to replay logs."));
3783 (void) zfs_error(hdl, EZFS_BUSY, errbuf);
3784 } else {
3785 (void) zpool_standard_error(hdl, errno, errbuf);
3786 }
3787 break;
3788
3789 default:
3790 (void) zpool_standard_error(hdl, errno, errbuf);
3791 }
3792 return (-1);
3793 }
3794
3795 int
3796 zpool_vdev_remove_cancel(zpool_handle_t *zhp)
3797 {
3798 zfs_cmd_t zc = {{0}};
3799 char errbuf[ERRBUFLEN];
3800 libzfs_handle_t *hdl = zhp->zpool_hdl;
3801
3802 (void) snprintf(errbuf, sizeof (errbuf),
3803 dgettext(TEXT_DOMAIN, "cannot cancel removal"));
3804
3805 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
3806 zc.zc_cookie = 1;
3807
3808 if (zfs_ioctl(hdl, ZFS_IOC_VDEV_REMOVE, &zc) == 0)
3809 return (0);
3810
3811 return (zpool_standard_error(hdl, errno, errbuf));
3812 }
3813
3814 int
3815 zpool_vdev_indirect_size(zpool_handle_t *zhp, const char *path,
3816 uint64_t *sizep)
3817 {
3818 char errbuf[ERRBUFLEN];
3819 nvlist_t *tgt;
3820 boolean_t avail_spare, l2cache, islog;
3821 libzfs_handle_t *hdl = zhp->zpool_hdl;
3822
3823 (void) snprintf(errbuf, sizeof (errbuf),
3824 dgettext(TEXT_DOMAIN, "cannot determine indirect size of %s"),
3825 path);
3826
3827 if ((tgt = zpool_find_vdev(zhp, path, &avail_spare, &l2cache,
3828 &islog)) == NULL)
3829 return (zfs_error(hdl, EZFS_NODEVICE, errbuf));
3830
3831 if (avail_spare || l2cache || islog) {
3832 *sizep = 0;
3833 return (0);
3834 }
3835
3836 if (nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_INDIRECT_SIZE, sizep) != 0) {
3837 zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3838 "indirect size not available"));
3839 return (zfs_error(hdl, EINVAL, errbuf));
3840 }
3841 return (0);
3842 }
3843
3844 /*
3845 * Clear the errors for the pool, or the particular device if specified.
3846 */
3847 int
3848 zpool_clear(zpool_handle_t *zhp, const char *path, nvlist_t *rewindnvl)
3849 {
3850 zfs_cmd_t zc = {"\0"};
3851 char errbuf[ERRBUFLEN];
3852 nvlist_t *tgt;
3853 zpool_load_policy_t policy;
3854 boolean_t avail_spare, l2cache;
3855 libzfs_handle_t *hdl = zhp->zpool_hdl;
3856 nvlist_t *nvi = NULL;
3857 int error;
3858
3859 if (path)
3860 (void) snprintf(errbuf, sizeof (errbuf),
3861 dgettext(TEXT_DOMAIN, "cannot clear errors for %s"),
3862 path);
3863 else
3864 (void) snprintf(errbuf, sizeof (errbuf),
3865 dgettext(TEXT_DOMAIN, "cannot clear errors for %s"),
3866 zhp->zpool_name);
3867
3868 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
3869 if (path) {
3870 if ((tgt = zpool_find_vdev(zhp, path, &avail_spare,
3871 &l2cache, NULL)) == NULL)
3872 return (zfs_error(hdl, EZFS_NODEVICE, errbuf));
3873
3874 /*
3875 * Don't allow error clearing for hot spares. Do allow
3876 * error clearing for l2cache devices.
3877 */
3878 if (avail_spare)
3879 return (zfs_error(hdl, EZFS_ISSPARE, errbuf));
3880
3881 zc.zc_guid = fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID);
3882 }
3883
3884 zpool_get_load_policy(rewindnvl, &policy);
3885 zc.zc_cookie = policy.zlp_rewind;
3886
3887 zcmd_alloc_dst_nvlist(hdl, &zc, zhp->zpool_config_size * 2);
3888 zcmd_write_src_nvlist(hdl, &zc, rewindnvl);
3889
3890 while ((error = zfs_ioctl(hdl, ZFS_IOC_CLEAR, &zc)) != 0 &&
3891 errno == ENOMEM)
3892 zcmd_expand_dst_nvlist(hdl, &zc);
3893
3894 if (!error || ((policy.zlp_rewind & ZPOOL_TRY_REWIND) &&
3895 errno != EPERM && errno != EACCES)) {
3896 if (policy.zlp_rewind &
3897 (ZPOOL_DO_REWIND | ZPOOL_TRY_REWIND)) {
3898 (void) zcmd_read_dst_nvlist(hdl, &zc, &nvi);
3899 zpool_rewind_exclaim(hdl, zc.zc_name,
3900 ((policy.zlp_rewind & ZPOOL_TRY_REWIND) != 0),
3901 nvi);
3902 nvlist_free(nvi);
3903 }
3904 zcmd_free_nvlists(&zc);
3905 return (0);
3906 }
3907
3908 zcmd_free_nvlists(&zc);
3909 return (zpool_standard_error(hdl, errno, errbuf));
3910 }
3911
3912 /*
3913 * Similar to zpool_clear(), but takes a GUID (used by fmd).
3914 */
3915 int
3916 zpool_vdev_clear(zpool_handle_t *zhp, uint64_t guid)
3917 {
3918 zfs_cmd_t zc = {"\0"};
3919 char errbuf[ERRBUFLEN];
3920 libzfs_handle_t *hdl = zhp->zpool_hdl;
3921
3922 (void) snprintf(errbuf, sizeof (errbuf),
3923 dgettext(TEXT_DOMAIN, "cannot clear errors for %llx"),
3924 (u_longlong_t)guid);
3925
3926 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
3927 zc.zc_guid = guid;
3928 zc.zc_cookie = ZPOOL_NO_REWIND;
3929
3930 if (zfs_ioctl(hdl, ZFS_IOC_CLEAR, &zc) == 0)
3931 return (0);
3932
3933 return (zpool_standard_error(hdl, errno, errbuf));
3934 }
3935
3936 /*
3937 * Change the GUID for a pool.
3938 */
3939 int
3940 zpool_reguid(zpool_handle_t *zhp)
3941 {
3942 char errbuf[ERRBUFLEN];
3943 libzfs_handle_t *hdl = zhp->zpool_hdl;
3944 zfs_cmd_t zc = {"\0"};
3945
3946 (void) snprintf(errbuf, sizeof (errbuf),
3947 dgettext(TEXT_DOMAIN, "cannot reguid '%s'"), zhp->zpool_name);
3948
3949 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
3950 if (zfs_ioctl(hdl, ZFS_IOC_POOL_REGUID, &zc) == 0)
3951 return (0);
3952
3953 return (zpool_standard_error(hdl, errno, errbuf));
3954 }
3955
3956 /*
3957 * Reopen the pool.
3958 */
3959 int
3960 zpool_reopen_one(zpool_handle_t *zhp, void *data)
3961 {
3962 libzfs_handle_t *hdl = zpool_get_handle(zhp);
3963 const char *pool_name = zpool_get_name(zhp);
3964 boolean_t *scrub_restart = data;
3965 int error;
3966
3967 error = lzc_reopen(pool_name, *scrub_restart);
3968 if (error) {
3969 return (zpool_standard_error_fmt(hdl, error,
3970 dgettext(TEXT_DOMAIN, "cannot reopen '%s'"), pool_name));
3971 }
3972
3973 return (0);
3974 }
3975
3976 /* call into libzfs_core to execute the sync IOCTL per pool */
3977 int
3978 zpool_sync_one(zpool_handle_t *zhp, void *data)
3979 {
3980 int ret;
3981 libzfs_handle_t *hdl = zpool_get_handle(zhp);
3982 const char *pool_name = zpool_get_name(zhp);
3983 boolean_t *force = data;
3984 nvlist_t *innvl = fnvlist_alloc();
3985
3986 fnvlist_add_boolean_value(innvl, "force", *force);
3987 if ((ret = lzc_sync(pool_name, innvl, NULL)) != 0) {
3988 nvlist_free(innvl);
3989 return (zpool_standard_error_fmt(hdl, ret,
3990 dgettext(TEXT_DOMAIN, "sync '%s' failed"), pool_name));
3991 }
3992 nvlist_free(innvl);
3993
3994 return (0);
3995 }
3996
3997 #define PATH_BUF_LEN 64
3998
3999 /*
4000 * Given a vdev, return the name to display in iostat. If the vdev has a path,
4001 * we use that, stripping off any leading "/dev/dsk/"; if not, we use the type.
4002 * We also check if this is a whole disk, in which case we strip off the
4003 * trailing 's0' slice name.
4004 *
4005 * This routine is also responsible for identifying when disks have been
4006 * reconfigured in a new location. The kernel will have opened the device by
4007 * devid, but the path will still refer to the old location. To catch this, we
4008 * first do a path -> devid translation (which is fast for the common case). If
4009 * the devid matches, we're done. If not, we do a reverse devid -> path
4010 * translation and issue the appropriate ioctl() to update the path of the vdev.
4011 * If 'zhp' is NULL, then this is an exported pool, and we don't need to do any
4012 * of these checks.
4013 */
4014 char *
4015 zpool_vdev_name(libzfs_handle_t *hdl, zpool_handle_t *zhp, nvlist_t *nv,
4016 int name_flags)
4017 {
4018 char *type, *tpath;
4019 const char *path;
4020 uint64_t value;
4021 char buf[PATH_BUF_LEN];
4022 char tmpbuf[PATH_BUF_LEN * 2];
4023
4024 /*
4025 * vdev_name will be "root"/"root-0" for the root vdev, but it is the
4026 * zpool name that will be displayed to the user.
4027 */
4028 type = fnvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE);
4029 if (zhp != NULL && strcmp(type, "root") == 0)
4030 return (zfs_strdup(hdl, zpool_get_name(zhp)));
4031
4032 if (libzfs_envvar_is_set("ZPOOL_VDEV_NAME_PATH"))
4033 name_flags |= VDEV_NAME_PATH;
4034 if (libzfs_envvar_is_set("ZPOOL_VDEV_NAME_GUID"))
4035 name_flags |= VDEV_NAME_GUID;
4036 if (libzfs_envvar_is_set("ZPOOL_VDEV_NAME_FOLLOW_LINKS"))
4037 name_flags |= VDEV_NAME_FOLLOW_LINKS;
4038
4039 if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NOT_PRESENT, &value) == 0 ||
4040 name_flags & VDEV_NAME_GUID) {
4041 (void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &value);
4042 (void) snprintf(buf, sizeof (buf), "%llu", (u_longlong_t)value);
4043 path = buf;
4044 } else if (nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &tpath) == 0) {
4045 path = tpath;
4046
4047 if (name_flags & VDEV_NAME_FOLLOW_LINKS) {
4048 char *rp = realpath(path, NULL);
4049 if (rp) {
4050 strlcpy(buf, rp, sizeof (buf));
4051 path = buf;
4052 free(rp);
4053 }
4054 }
4055
4056 /*
4057 * For a block device only use the name.
4058 */
4059 if ((strcmp(type, VDEV_TYPE_DISK) == 0) &&
4060 !(name_flags & VDEV_NAME_PATH)) {
4061 path = zfs_strip_path(path);
4062 }
4063
4064 /*
4065 * Remove the partition from the path if this is a whole disk.
4066 */
4067 if (strcmp(type, VDEV_TYPE_DRAID_SPARE) != 0 &&
4068 nvlist_lookup_uint64(nv, ZPOOL_CONFIG_WHOLE_DISK, &value)
4069 == 0 && value && !(name_flags & VDEV_NAME_PATH)) {
4070 return (zfs_strip_partition(path));
4071 }
4072 } else {
4073 path = type;
4074
4075 /*
4076 * If it's a raidz device, we need to stick in the parity level.
4077 */
4078 if (strcmp(path, VDEV_TYPE_RAIDZ) == 0) {
4079 value = fnvlist_lookup_uint64(nv, ZPOOL_CONFIG_NPARITY);
4080 (void) snprintf(buf, sizeof (buf), "%s%llu", path,
4081 (u_longlong_t)value);
4082 path = buf;
4083 }
4084
4085 /*
4086 * If it's a dRAID device, we add parity, groups, and spares.
4087 */
4088 if (strcmp(path, VDEV_TYPE_DRAID) == 0) {
4089 uint64_t ndata, nparity, nspares;
4090 nvlist_t **child;
4091 uint_t children;
4092
4093 verify(nvlist_lookup_nvlist_array(nv,
4094 ZPOOL_CONFIG_CHILDREN, &child, &children) == 0);
4095 nparity = fnvlist_lookup_uint64(nv,
4096 ZPOOL_CONFIG_NPARITY);
4097 ndata = fnvlist_lookup_uint64(nv,
4098 ZPOOL_CONFIG_DRAID_NDATA);
4099 nspares = fnvlist_lookup_uint64(nv,
4100 ZPOOL_CONFIG_DRAID_NSPARES);
4101
4102 path = zpool_draid_name(buf, sizeof (buf), ndata,
4103 nparity, nspares, children);
4104 }
4105
4106 /*
4107 * We identify each top-level vdev by using a <type-id>
4108 * naming convention.
4109 */
4110 if (name_flags & VDEV_NAME_TYPE_ID) {
4111 uint64_t id = fnvlist_lookup_uint64(nv,
4112 ZPOOL_CONFIG_ID);
4113 (void) snprintf(tmpbuf, sizeof (tmpbuf), "%s-%llu",
4114 path, (u_longlong_t)id);
4115 path = tmpbuf;
4116 }
4117 }
4118
4119 return (zfs_strdup(hdl, path));
4120 }
4121
4122 static int
4123 zbookmark_mem_compare(const void *a, const void *b)
4124 {
4125 return (memcmp(a, b, sizeof (zbookmark_phys_t)));
4126 }
4127
4128 /*
4129 * Retrieve the persistent error log, uniquify the members, and return to the
4130 * caller.
4131 */
4132 int
4133 zpool_get_errlog(zpool_handle_t *zhp, nvlist_t **nverrlistp)
4134 {
4135 zfs_cmd_t zc = {"\0"};
4136 libzfs_handle_t *hdl = zhp->zpool_hdl;
4137 zbookmark_phys_t *buf;
4138 uint64_t buflen = 10000; /* approx. 1MB of RAM */
4139
4140 if (fnvlist_lookup_uint64(zhp->zpool_config,
4141 ZPOOL_CONFIG_ERRCOUNT) == 0)
4142 return (0);
4143
4144 /*
4145 * Retrieve the raw error list from the kernel. If it doesn't fit,
4146 * allocate a larger buffer and retry.
4147 */
4148 (void) strcpy(zc.zc_name, zhp->zpool_name);
4149 for (;;) {
4150 buf = zfs_alloc(zhp->zpool_hdl,
4151 buflen * sizeof (zbookmark_phys_t));
4152 zc.zc_nvlist_dst = (uintptr_t)buf;
4153 zc.zc_nvlist_dst_size = buflen;
4154 if (zfs_ioctl(zhp->zpool_hdl, ZFS_IOC_ERROR_LOG,
4155 &zc) != 0) {
4156 free(buf);
4157 if (errno == ENOMEM) {
4158 buflen *= 2;
4159 } else {
4160 return (zpool_standard_error_fmt(hdl, errno,
4161 dgettext(TEXT_DOMAIN, "errors: List of "
4162 "errors unavailable")));
4163 }
4164 } else {
4165 break;
4166 }
4167 }
4168
4169 /*
4170 * Sort the resulting bookmarks. This is a little confusing due to the
4171 * implementation of ZFS_IOC_ERROR_LOG. The bookmarks are copied last
4172 * to first, and 'zc_nvlist_dst_size' indicates the number of bookmarks
4173 * _not_ copied as part of the process. So we point the start of our
4174 * array appropriate and decrement the total number of elements.
4175 */
4176 zbookmark_phys_t *zb = buf + zc.zc_nvlist_dst_size;
4177 uint64_t zblen = buflen - zc.zc_nvlist_dst_size;
4178
4179 qsort(zb, zblen, sizeof (zbookmark_phys_t), zbookmark_mem_compare);
4180
4181 verify(nvlist_alloc(nverrlistp, 0, KM_SLEEP) == 0);
4182
4183 /*
4184 * Fill in the nverrlistp with nvlist's of dataset and object numbers.
4185 */
4186 for (uint64_t i = 0; i < zblen; i++) {
4187 nvlist_t *nv;
4188
4189 /* ignoring zb_blkid and zb_level for now */
4190 if (i > 0 && zb[i-1].zb_objset == zb[i].zb_objset &&
4191 zb[i-1].zb_object == zb[i].zb_object)
4192 continue;
4193
4194 if (nvlist_alloc(&nv, NV_UNIQUE_NAME, KM_SLEEP) != 0)
4195 goto nomem;
4196 if (nvlist_add_uint64(nv, ZPOOL_ERR_DATASET,
4197 zb[i].zb_objset) != 0) {
4198 nvlist_free(nv);
4199 goto nomem;
4200 }
4201 if (nvlist_add_uint64(nv, ZPOOL_ERR_OBJECT,
4202 zb[i].zb_object) != 0) {
4203 nvlist_free(nv);
4204 goto nomem;
4205 }
4206 if (nvlist_add_nvlist(*nverrlistp, "ejk", nv) != 0) {
4207 nvlist_free(nv);
4208 goto nomem;
4209 }
4210 nvlist_free(nv);
4211 }
4212
4213 free(buf);
4214 return (0);
4215
4216 nomem:
4217 free(buf);
4218 return (no_memory(zhp->zpool_hdl));
4219 }
4220
4221 /*
4222 * Upgrade a ZFS pool to the latest on-disk version.
4223 */
4224 int
4225 zpool_upgrade(zpool_handle_t *zhp, uint64_t new_version)
4226 {
4227 zfs_cmd_t zc = {"\0"};
4228 libzfs_handle_t *hdl = zhp->zpool_hdl;
4229
4230 (void) strcpy(zc.zc_name, zhp->zpool_name);
4231 zc.zc_cookie = new_version;
4232
4233 if (zfs_ioctl(hdl, ZFS_IOC_POOL_UPGRADE, &zc) != 0)
4234 return (zpool_standard_error_fmt(hdl, errno,
4235 dgettext(TEXT_DOMAIN, "cannot upgrade '%s'"),
4236 zhp->zpool_name));
4237 return (0);
4238 }
4239
4240 void
4241 zfs_save_arguments(int argc, char **argv, char *string, int len)
4242 {
4243 int i;
4244
4245 (void) strlcpy(string, zfs_basename(argv[0]), len);
4246 for (i = 1; i < argc; i++) {
4247 (void) strlcat(string, " ", len);
4248 (void) strlcat(string, argv[i], len);
4249 }
4250 }
4251
4252 int
4253 zpool_log_history(libzfs_handle_t *hdl, const char *message)
4254 {
4255 zfs_cmd_t zc = {"\0"};
4256 nvlist_t *args;
4257
4258 args = fnvlist_alloc();
4259 fnvlist_add_string(args, "message", message);
4260 zcmd_write_src_nvlist(hdl, &zc, args);
4261 int err = zfs_ioctl(hdl, ZFS_IOC_LOG_HISTORY, &zc);
4262 nvlist_free(args);
4263 zcmd_free_nvlists(&zc);
4264 return (err);
4265 }
4266
4267 /*
4268 * Perform ioctl to get some command history of a pool.
4269 *
4270 * 'buf' is the buffer to fill up to 'len' bytes. 'off' is the
4271 * logical offset of the history buffer to start reading from.
4272 *
4273 * Upon return, 'off' is the next logical offset to read from and
4274 * 'len' is the actual amount of bytes read into 'buf'.
4275 */
4276 static int
4277 get_history(zpool_handle_t *zhp, char *buf, uint64_t *off, uint64_t *len)
4278 {
4279 zfs_cmd_t zc = {"\0"};
4280 libzfs_handle_t *hdl = zhp->zpool_hdl;
4281
4282 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
4283
4284 zc.zc_history = (uint64_t)(uintptr_t)buf;
4285 zc.zc_history_len = *len;
4286 zc.zc_history_offset = *off;
4287
4288 if (zfs_ioctl(hdl, ZFS_IOC_POOL_GET_HISTORY, &zc) != 0) {
4289 switch (errno) {
4290 case EPERM:
4291 return (zfs_error_fmt(hdl, EZFS_PERM,
4292 dgettext(TEXT_DOMAIN,
4293 "cannot show history for pool '%s'"),
4294 zhp->zpool_name));
4295 case ENOENT:
4296 return (zfs_error_fmt(hdl, EZFS_NOHISTORY,
4297 dgettext(TEXT_DOMAIN, "cannot get history for pool "
4298 "'%s'"), zhp->zpool_name));
4299 case ENOTSUP:
4300 return (zfs_error_fmt(hdl, EZFS_BADVERSION,
4301 dgettext(TEXT_DOMAIN, "cannot get history for pool "
4302 "'%s', pool must be upgraded"), zhp->zpool_name));
4303 default:
4304 return (zpool_standard_error_fmt(hdl, errno,
4305 dgettext(TEXT_DOMAIN,
4306 "cannot get history for '%s'"), zhp->zpool_name));
4307 }
4308 }
4309
4310 *len = zc.zc_history_len;
4311 *off = zc.zc_history_offset;
4312
4313 return (0);
4314 }
4315
4316 /*
4317 * Retrieve the command history of a pool.
4318 */
4319 int
4320 zpool_get_history(zpool_handle_t *zhp, nvlist_t **nvhisp, uint64_t *off,
4321 boolean_t *eof)
4322 {
4323 libzfs_handle_t *hdl = zhp->zpool_hdl;
4324 char *buf;
4325 int buflen = 128 * 1024;
4326 nvlist_t **records = NULL;
4327 uint_t numrecords = 0;
4328 int err = 0, i;
4329 uint64_t start = *off;
4330
4331 buf = zfs_alloc(hdl, buflen);
4332
4333 /* process about 1MiB a time */
4334 while (*off - start < 1024 * 1024) {
4335 uint64_t bytes_read = buflen;
4336 uint64_t leftover;
4337
4338 if ((err = get_history(zhp, buf, off, &bytes_read)) != 0)
4339 break;
4340
4341 /* if nothing else was read in, we're at EOF, just return */
4342 if (!bytes_read) {
4343 *eof = B_TRUE;
4344 break;
4345 }
4346
4347 if ((err = zpool_history_unpack(buf, bytes_read,
4348 &leftover, &records, &numrecords)) != 0) {
4349 zpool_standard_error_fmt(hdl, err,
4350 dgettext(TEXT_DOMAIN,
4351 "cannot get history for '%s'"), zhp->zpool_name);
4352 break;
4353 }
4354 *off -= leftover;
4355 if (leftover == bytes_read) {
4356 /*
4357 * no progress made, because buffer is not big enough
4358 * to hold this record; resize and retry.
4359 */
4360 buflen *= 2;
4361 free(buf);
4362 buf = zfs_alloc(hdl, buflen);
4363 }
4364 }
4365
4366 free(buf);
4367
4368 if (!err) {
4369 *nvhisp = fnvlist_alloc();
4370 fnvlist_add_nvlist_array(*nvhisp, ZPOOL_HIST_RECORD,
4371 (const nvlist_t **)records, numrecords);
4372 }
4373 for (i = 0; i < numrecords; i++)
4374 nvlist_free(records[i]);
4375 free(records);
4376
4377 return (err);
4378 }
4379
4380 /*
4381 * Retrieve the next event given the passed 'zevent_fd' file descriptor.
4382 * If there is a new event available 'nvp' will contain a newly allocated
4383 * nvlist and 'dropped' will be set to the number of missed events since
4384 * the last call to this function. When 'nvp' is set to NULL it indicates
4385 * no new events are available. In either case the function returns 0 and
4386 * it is up to the caller to free 'nvp'. In the case of a fatal error the
4387 * function will return a non-zero value. When the function is called in
4388 * blocking mode (the default, unless the ZEVENT_NONBLOCK flag is passed),
4389 * it will not return until a new event is available.
4390 */
4391 int
4392 zpool_events_next(libzfs_handle_t *hdl, nvlist_t **nvp,
4393 int *dropped, unsigned flags, int zevent_fd)
4394 {
4395 zfs_cmd_t zc = {"\0"};
4396 int error = 0;
4397
4398 *nvp = NULL;
4399 *dropped = 0;
4400 zc.zc_cleanup_fd = zevent_fd;
4401
4402 if (flags & ZEVENT_NONBLOCK)
4403 zc.zc_guid = ZEVENT_NONBLOCK;
4404
4405 zcmd_alloc_dst_nvlist(hdl, &zc, ZEVENT_SIZE);
4406
4407 retry:
4408 if (zfs_ioctl(hdl, ZFS_IOC_EVENTS_NEXT, &zc) != 0) {
4409 switch (errno) {
4410 case ESHUTDOWN:
4411 error = zfs_error_fmt(hdl, EZFS_POOLUNAVAIL,
4412 dgettext(TEXT_DOMAIN, "zfs shutdown"));
4413 goto out;
4414 case ENOENT:
4415 /* Blocking error case should not occur */
4416 if (!(flags & ZEVENT_NONBLOCK))
4417 error = zpool_standard_error_fmt(hdl, errno,
4418 dgettext(TEXT_DOMAIN, "cannot get event"));
4419
4420 goto out;
4421 case ENOMEM:
4422 zcmd_expand_dst_nvlist(hdl, &zc);
4423 goto retry;
4424 default:
4425 error = zpool_standard_error_fmt(hdl, errno,
4426 dgettext(TEXT_DOMAIN, "cannot get event"));
4427 goto out;
4428 }
4429 }
4430
4431 error = zcmd_read_dst_nvlist(hdl, &zc, nvp);
4432 if (error != 0)
4433 goto out;
4434
4435 *dropped = (int)zc.zc_cookie;
4436 out:
4437 zcmd_free_nvlists(&zc);
4438
4439 return (error);
4440 }
4441
4442 /*
4443 * Clear all events.
4444 */
4445 int
4446 zpool_events_clear(libzfs_handle_t *hdl, int *count)
4447 {
4448 zfs_cmd_t zc = {"\0"};
4449
4450 if (zfs_ioctl(hdl, ZFS_IOC_EVENTS_CLEAR, &zc) != 0)
4451 return (zpool_standard_error(hdl, errno,
4452 dgettext(TEXT_DOMAIN, "cannot clear events")));
4453
4454 if (count != NULL)
4455 *count = (int)zc.zc_cookie; /* # of events cleared */
4456
4457 return (0);
4458 }
4459
4460 /*
4461 * Seek to a specific EID, ZEVENT_SEEK_START, or ZEVENT_SEEK_END for
4462 * the passed zevent_fd file handle. On success zero is returned,
4463 * otherwise -1 is returned and hdl->libzfs_error is set to the errno.
4464 */
4465 int
4466 zpool_events_seek(libzfs_handle_t *hdl, uint64_t eid, int zevent_fd)
4467 {
4468 zfs_cmd_t zc = {"\0"};
4469 int error = 0;
4470
4471 zc.zc_guid = eid;
4472 zc.zc_cleanup_fd = zevent_fd;
4473
4474 if (zfs_ioctl(hdl, ZFS_IOC_EVENTS_SEEK, &zc) != 0) {
4475 switch (errno) {
4476 case ENOENT:
4477 error = zfs_error_fmt(hdl, EZFS_NOENT,
4478 dgettext(TEXT_DOMAIN, "cannot get event"));
4479 break;
4480
4481 case ENOMEM:
4482 error = zfs_error_fmt(hdl, EZFS_NOMEM,
4483 dgettext(TEXT_DOMAIN, "cannot get event"));
4484 break;
4485
4486 default:
4487 error = zpool_standard_error_fmt(hdl, errno,
4488 dgettext(TEXT_DOMAIN, "cannot get event"));
4489 break;
4490 }
4491 }
4492
4493 return (error);
4494 }
4495
4496 static void
4497 zpool_obj_to_path_impl(zpool_handle_t *zhp, uint64_t dsobj, uint64_t obj,
4498 char *pathname, size_t len, boolean_t always_unmounted)
4499 {
4500 zfs_cmd_t zc = {"\0"};
4501 boolean_t mounted = B_FALSE;
4502 char *mntpnt = NULL;
4503 char dsname[ZFS_MAX_DATASET_NAME_LEN];
4504
4505 if (dsobj == 0) {
4506 /* special case for the MOS */
4507 (void) snprintf(pathname, len, "<metadata>:<0x%llx>",
4508 (longlong_t)obj);
4509 return;
4510 }
4511
4512 /* get the dataset's name */
4513 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
4514 zc.zc_obj = dsobj;
4515 if (zfs_ioctl(zhp->zpool_hdl,
4516 ZFS_IOC_DSOBJ_TO_DSNAME, &zc) != 0) {
4517 /* just write out a path of two object numbers */
4518 (void) snprintf(pathname, len, "<0x%llx>:<0x%llx>",
4519 (longlong_t)dsobj, (longlong_t)obj);
4520 return;
4521 }
4522 (void) strlcpy(dsname, zc.zc_value, sizeof (dsname));
4523
4524 /* find out if the dataset is mounted */
4525 mounted = !always_unmounted && is_mounted(zhp->zpool_hdl, dsname,
4526 &mntpnt);
4527
4528 /* get the corrupted object's path */
4529 (void) strlcpy(zc.zc_name, dsname, sizeof (zc.zc_name));
4530 zc.zc_obj = obj;
4531 if (zfs_ioctl(zhp->zpool_hdl, ZFS_IOC_OBJ_TO_PATH,
4532 &zc) == 0) {
4533 if (mounted) {
4534 (void) snprintf(pathname, len, "%s%s", mntpnt,
4535 zc.zc_value);
4536 } else {
4537 (void) snprintf(pathname, len, "%s:%s",
4538 dsname, zc.zc_value);
4539 }
4540 } else {
4541 (void) snprintf(pathname, len, "%s:<0x%llx>", dsname,
4542 (longlong_t)obj);
4543 }
4544 free(mntpnt);
4545 }
4546
4547 void
4548 zpool_obj_to_path(zpool_handle_t *zhp, uint64_t dsobj, uint64_t obj,
4549 char *pathname, size_t len)
4550 {
4551 zpool_obj_to_path_impl(zhp, dsobj, obj, pathname, len, B_FALSE);
4552 }
4553
4554 void
4555 zpool_obj_to_path_ds(zpool_handle_t *zhp, uint64_t dsobj, uint64_t obj,
4556 char *pathname, size_t len)
4557 {
4558 zpool_obj_to_path_impl(zhp, dsobj, obj, pathname, len, B_TRUE);
4559 }
4560 /*
4561 * Wait while the specified activity is in progress in the pool.
4562 */
4563 int
4564 zpool_wait(zpool_handle_t *zhp, zpool_wait_activity_t activity)
4565 {
4566 boolean_t missing;
4567
4568 int error = zpool_wait_status(zhp, activity, &missing, NULL);
4569
4570 if (missing) {
4571 (void) zpool_standard_error_fmt(zhp->zpool_hdl, ENOENT,
4572 dgettext(TEXT_DOMAIN, "error waiting in pool '%s'"),
4573 zhp->zpool_name);
4574 return (ENOENT);
4575 } else {
4576 return (error);
4577 }
4578 }
4579
4580 /*
4581 * Wait for the given activity and return the status of the wait (whether or not
4582 * any waiting was done) in the 'waited' parameter. Non-existent pools are
4583 * reported via the 'missing' parameter, rather than by printing an error
4584 * message. This is convenient when this function is called in a loop over a
4585 * long period of time (as it is, for example, by zpool's wait cmd). In that
4586 * scenario, a pool being exported or destroyed should be considered a normal
4587 * event, so we don't want to print an error when we find that the pool doesn't
4588 * exist.
4589 */
4590 int
4591 zpool_wait_status(zpool_handle_t *zhp, zpool_wait_activity_t activity,
4592 boolean_t *missing, boolean_t *waited)
4593 {
4594 int error = lzc_wait(zhp->zpool_name, activity, waited);
4595 *missing = (error == ENOENT);
4596 if (*missing)
4597 return (0);
4598
4599 if (error != 0) {
4600 (void) zpool_standard_error_fmt(zhp->zpool_hdl, error,
4601 dgettext(TEXT_DOMAIN, "error waiting in pool '%s'"),
4602 zhp->zpool_name);
4603 }
4604
4605 return (error);
4606 }
4607
4608 int
4609 zpool_set_bootenv(zpool_handle_t *zhp, const nvlist_t *envmap)
4610 {
4611 int error = lzc_set_bootenv(zhp->zpool_name, envmap);
4612 if (error != 0) {
4613 (void) zpool_standard_error_fmt(zhp->zpool_hdl, error,
4614 dgettext(TEXT_DOMAIN,
4615 "error setting bootenv in pool '%s'"), zhp->zpool_name);
4616 }
4617
4618 return (error);
4619 }
4620
4621 int
4622 zpool_get_bootenv(zpool_handle_t *zhp, nvlist_t **nvlp)
4623 {
4624 nvlist_t *nvl;
4625 int error;
4626
4627 nvl = NULL;
4628 error = lzc_get_bootenv(zhp->zpool_name, &nvl);
4629 if (error != 0) {
4630 (void) zpool_standard_error_fmt(zhp->zpool_hdl, error,
4631 dgettext(TEXT_DOMAIN,
4632 "error getting bootenv in pool '%s'"), zhp->zpool_name);
4633 } else {
4634 *nvlp = nvl;
4635 }
4636
4637 return (error);
4638 }
4639
4640 /*
4641 * Attempt to read and parse feature file(s) (from "compatibility" property).
4642 * Files contain zpool feature names, comma or whitespace-separated.
4643 * Comments (# character to next newline) are discarded.
4644 *
4645 * Arguments:
4646 * compatibility : string containing feature filenames
4647 * features : either NULL or pointer to array of boolean
4648 * report : either NULL or pointer to string buffer
4649 * rlen : length of "report" buffer
4650 *
4651 * compatibility is NULL (unset), "", "off", "legacy", or list of
4652 * comma-separated filenames. filenames should either be absolute,
4653 * or relative to:
4654 * 1) ZPOOL_SYSCONF_COMPAT_D (eg: /etc/zfs/compatibility.d) or
4655 * 2) ZPOOL_DATA_COMPAT_D (eg: /usr/share/zfs/compatibility.d).
4656 * (Unset), "" or "off" => enable all features
4657 * "legacy" => disable all features
4658 *
4659 * Any feature names read from files which match unames in spa_feature_table
4660 * will have the corresponding boolean set in the features array (if non-NULL).
4661 * If more than one feature set specified, only features present in *all* of
4662 * them will be set.
4663 *
4664 * "report" if not NULL will be populated with a suitable status message.
4665 *
4666 * Return values:
4667 * ZPOOL_COMPATIBILITY_OK : files read and parsed ok
4668 * ZPOOL_COMPATIBILITY_BADFILE : file too big or not a text file
4669 * ZPOOL_COMPATIBILITY_BADTOKEN : SYSCONF file contains invalid feature name
4670 * ZPOOL_COMPATIBILITY_WARNTOKEN : DATA file contains invalid feature name
4671 * ZPOOL_COMPATIBILITY_NOFILES : no feature files found
4672 */
4673 zpool_compat_status_t
4674 zpool_load_compat(const char *compat, boolean_t *features, char *report,
4675 size_t rlen)
4676 {
4677 int sdirfd, ddirfd, featfd;
4678 struct stat fs;
4679 char *fc;
4680 char *ps, *ls, *ws;
4681 char *file, *line, *word;
4682
4683 char l_compat[ZFS_MAXPROPLEN];
4684
4685 boolean_t ret_nofiles = B_TRUE;
4686 boolean_t ret_badfile = B_FALSE;
4687 boolean_t ret_badtoken = B_FALSE;
4688 boolean_t ret_warntoken = B_FALSE;
4689
4690 /* special cases (unset), "" and "off" => enable all features */
4691 if (compat == NULL || compat[0] == '\0' ||
4692 strcmp(compat, ZPOOL_COMPAT_OFF) == 0) {
4693 if (features != NULL)
4694 for (uint_t i = 0; i < SPA_FEATURES; i++)
4695 features[i] = B_TRUE;
4696 if (report != NULL)
4697 strlcpy(report, gettext("all features enabled"), rlen);
4698 return (ZPOOL_COMPATIBILITY_OK);
4699 }
4700
4701 /* Final special case "legacy" => disable all features */
4702 if (strcmp(compat, ZPOOL_COMPAT_LEGACY) == 0) {
4703 if (features != NULL)
4704 for (uint_t i = 0; i < SPA_FEATURES; i++)
4705 features[i] = B_FALSE;
4706 if (report != NULL)
4707 strlcpy(report, gettext("all features disabled"), rlen);
4708 return (ZPOOL_COMPATIBILITY_OK);
4709 }
4710
4711 /*
4712 * Start with all true; will be ANDed with results from each file
4713 */
4714 if (features != NULL)
4715 for (uint_t i = 0; i < SPA_FEATURES; i++)
4716 features[i] = B_TRUE;
4717
4718 char err_badfile[ZFS_MAXPROPLEN] = "";
4719 char err_badtoken[ZFS_MAXPROPLEN] = "";
4720
4721 /*
4722 * We ignore errors from the directory open()
4723 * as they're only needed if the filename is relative
4724 * which will be checked during the openat().
4725 */
4726
4727 /* O_PATH safer than O_RDONLY if system allows it */
4728 #if defined(O_PATH)
4729 #define ZC_DIR_FLAGS (O_DIRECTORY | O_CLOEXEC | O_PATH)
4730 #else
4731 #define ZC_DIR_FLAGS (O_DIRECTORY | O_CLOEXEC | O_RDONLY)
4732 #endif
4733
4734 sdirfd = open(ZPOOL_SYSCONF_COMPAT_D, ZC_DIR_FLAGS);
4735 ddirfd = open(ZPOOL_DATA_COMPAT_D, ZC_DIR_FLAGS);
4736
4737 (void) strlcpy(l_compat, compat, ZFS_MAXPROPLEN);
4738
4739 for (file = strtok_r(l_compat, ",", &ps);
4740 file != NULL;
4741 file = strtok_r(NULL, ",", &ps)) {
4742
4743 boolean_t l_features[SPA_FEATURES];
4744
4745 enum { Z_SYSCONF, Z_DATA } source;
4746
4747 /* try sysconfdir first, then datadir */
4748 source = Z_SYSCONF;
4749 if ((featfd = openat(sdirfd, file, O_RDONLY | O_CLOEXEC)) < 0) {
4750 featfd = openat(ddirfd, file, O_RDONLY | O_CLOEXEC);
4751 source = Z_DATA;
4752 }
4753
4754 /* File readable and correct size? */
4755 if (featfd < 0 ||
4756 fstat(featfd, &fs) < 0 ||
4757 fs.st_size < 1 ||
4758 fs.st_size > ZPOOL_COMPAT_MAXSIZE) {
4759 (void) close(featfd);
4760 strlcat(err_badfile, file, ZFS_MAXPROPLEN);
4761 strlcat(err_badfile, " ", ZFS_MAXPROPLEN);
4762 ret_badfile = B_TRUE;
4763 continue;
4764 }
4765
4766 /* Prefault the file if system allows */
4767 #if defined(MAP_POPULATE)
4768 #define ZC_MMAP_FLAGS (MAP_PRIVATE | MAP_POPULATE)
4769 #elif defined(MAP_PREFAULT_READ)
4770 #define ZC_MMAP_FLAGS (MAP_PRIVATE | MAP_PREFAULT_READ)
4771 #else
4772 #define ZC_MMAP_FLAGS (MAP_PRIVATE)
4773 #endif
4774
4775 /* private mmap() so we can strtok safely */
4776 fc = (char *)mmap(NULL, fs.st_size, PROT_READ | PROT_WRITE,
4777 ZC_MMAP_FLAGS, featfd, 0);
4778 (void) close(featfd);
4779
4780 /* map ok, and last character == newline? */
4781 if (fc == MAP_FAILED || fc[fs.st_size - 1] != '\n') {
4782 (void) munmap((void *) fc, fs.st_size);
4783 strlcat(err_badfile, file, ZFS_MAXPROPLEN);
4784 strlcat(err_badfile, " ", ZFS_MAXPROPLEN);
4785 ret_badfile = B_TRUE;
4786 continue;
4787 }
4788
4789 ret_nofiles = B_FALSE;
4790
4791 for (uint_t i = 0; i < SPA_FEATURES; i++)
4792 l_features[i] = B_FALSE;
4793
4794 /* replace final newline with NULL to ensure string ends */
4795 fc[fs.st_size - 1] = '\0';
4796
4797 for (line = strtok_r(fc, "\n", &ls);
4798 line != NULL;
4799 line = strtok_r(NULL, "\n", &ls)) {
4800 /* discard comments */
4801 char *r = strchr(line, '#');
4802 if (r != NULL)
4803 *r = '\0';
4804
4805 for (word = strtok_r(line, ", \t", &ws);
4806 word != NULL;
4807 word = strtok_r(NULL, ", \t", &ws)) {
4808 /* Find matching feature name */
4809 uint_t f;
4810 for (f = 0; f < SPA_FEATURES; f++) {
4811 zfeature_info_t *fi =
4812 &spa_feature_table[f];
4813 if (strcmp(word, fi->fi_uname) == 0) {
4814 l_features[f] = B_TRUE;
4815 break;
4816 }
4817 }
4818 if (f < SPA_FEATURES)
4819 continue;
4820
4821 /* found an unrecognized word */
4822 /* lightly sanitize it */
4823 if (strlen(word) > 32)
4824 word[32] = '\0';
4825 for (char *c = word; *c != '\0'; c++)
4826 if (!isprint(*c))
4827 *c = '?';
4828
4829 strlcat(err_badtoken, word, ZFS_MAXPROPLEN);
4830 strlcat(err_badtoken, " ", ZFS_MAXPROPLEN);
4831 if (source == Z_SYSCONF)
4832 ret_badtoken = B_TRUE;
4833 else
4834 ret_warntoken = B_TRUE;
4835 }
4836 }
4837 (void) munmap((void *) fc, fs.st_size);
4838
4839 if (features != NULL)
4840 for (uint_t i = 0; i < SPA_FEATURES; i++)
4841 features[i] &= l_features[i];
4842 }
4843 (void) close(sdirfd);
4844 (void) close(ddirfd);
4845
4846 /* Return the most serious error */
4847 if (ret_badfile) {
4848 if (report != NULL)
4849 snprintf(report, rlen, gettext("could not read/"
4850 "parse feature file(s): %s"), err_badfile);
4851 return (ZPOOL_COMPATIBILITY_BADFILE);
4852 }
4853 if (ret_nofiles) {
4854 if (report != NULL)
4855 strlcpy(report,
4856 gettext("no valid compatibility files specified"),
4857 rlen);
4858 return (ZPOOL_COMPATIBILITY_NOFILES);
4859 }
4860 if (ret_badtoken) {
4861 if (report != NULL)
4862 snprintf(report, rlen, gettext("invalid feature "
4863 "name(s) in local compatibility files: %s"),
4864 err_badtoken);
4865 return (ZPOOL_COMPATIBILITY_BADTOKEN);
4866 }
4867 if (ret_warntoken) {
4868 if (report != NULL)
4869 snprintf(report, rlen, gettext("unrecognized feature "
4870 "name(s) in distribution compatibility files: %s"),
4871 err_badtoken);
4872 return (ZPOOL_COMPATIBILITY_WARNTOKEN);
4873 }
4874 if (report != NULL)
4875 strlcpy(report, gettext("compatibility set ok"), rlen);
4876 return (ZPOOL_COMPATIBILITY_OK);
4877 }
4878
4879 static int
4880 zpool_vdev_guid(zpool_handle_t *zhp, const char *vdevname, uint64_t *vdev_guid)
4881 {
4882 nvlist_t *tgt;
4883 boolean_t avail_spare, l2cache;
4884
4885 verify(zhp != NULL);
4886 if (zpool_get_state(zhp) == POOL_STATE_UNAVAIL) {
4887 char errbuf[ERRBUFLEN];
4888 (void) snprintf(errbuf, sizeof (errbuf),
4889 dgettext(TEXT_DOMAIN, "pool is in an unavailable state"));
4890 return (zfs_error(zhp->zpool_hdl, EZFS_POOLUNAVAIL, errbuf));
4891 }
4892
4893 if ((tgt = zpool_find_vdev(zhp, vdevname, &avail_spare, &l2cache,
4894 NULL)) == NULL) {
4895 char errbuf[ERRBUFLEN];
4896 (void) snprintf(errbuf, sizeof (errbuf),
4897 dgettext(TEXT_DOMAIN, "can not find %s in %s"),
4898 vdevname, zhp->zpool_name);
4899 return (zfs_error(zhp->zpool_hdl, EZFS_NODEVICE, errbuf));
4900 }
4901
4902 *vdev_guid = fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID);
4903 return (0);
4904 }
4905
4906 /*
4907 * Get a vdev property value for 'prop' and return the value in
4908 * a pre-allocated buffer.
4909 */
4910 int
4911 zpool_get_vdev_prop_value(nvlist_t *nvprop, vdev_prop_t prop, char *prop_name,
4912 char *buf, size_t len, zprop_source_t *srctype, boolean_t literal)
4913 {
4914 nvlist_t *nv;
4915 const char *strval;
4916 uint64_t intval;
4917 zprop_source_t src = ZPROP_SRC_NONE;
4918
4919 if (prop == VDEV_PROP_USERPROP) {
4920 /* user property, prop_name must contain the property name */
4921 assert(prop_name != NULL);
4922 if (nvlist_lookup_nvlist(nvprop, prop_name, &nv) == 0) {
4923 src = fnvlist_lookup_uint64(nv, ZPROP_SOURCE);
4924 strval = fnvlist_lookup_string(nv, ZPROP_VALUE);
4925 } else {
4926 /* user prop not found */
4927 return (-1);
4928 }
4929 (void) strlcpy(buf, strval, len);
4930 if (srctype)
4931 *srctype = src;
4932 return (0);
4933 }
4934
4935 if (prop_name == NULL)
4936 prop_name = (char *)vdev_prop_to_name(prop);
4937
4938 switch (vdev_prop_get_type(prop)) {
4939 case PROP_TYPE_STRING:
4940 if (nvlist_lookup_nvlist(nvprop, prop_name, &nv) == 0) {
4941 src = fnvlist_lookup_uint64(nv, ZPROP_SOURCE);
4942 strval = fnvlist_lookup_string(nv, ZPROP_VALUE);
4943 } else {
4944 src = ZPROP_SRC_DEFAULT;
4945 if ((strval = vdev_prop_default_string(prop)) == NULL)
4946 strval = "-";
4947 }
4948 (void) strlcpy(buf, strval, len);
4949 break;
4950
4951 case PROP_TYPE_NUMBER:
4952 if (nvlist_lookup_nvlist(nvprop, prop_name, &nv) == 0) {
4953 src = fnvlist_lookup_uint64(nv, ZPROP_SOURCE);
4954 intval = fnvlist_lookup_uint64(nv, ZPROP_VALUE);
4955 } else {
4956 src = ZPROP_SRC_DEFAULT;
4957 intval = vdev_prop_default_numeric(prop);
4958 }
4959
4960 switch (prop) {
4961 case VDEV_PROP_ASIZE:
4962 case VDEV_PROP_PSIZE:
4963 case VDEV_PROP_SIZE:
4964 case VDEV_PROP_BOOTSIZE:
4965 case VDEV_PROP_ALLOCATED:
4966 case VDEV_PROP_FREE:
4967 case VDEV_PROP_READ_ERRORS:
4968 case VDEV_PROP_WRITE_ERRORS:
4969 case VDEV_PROP_CHECKSUM_ERRORS:
4970 case VDEV_PROP_INITIALIZE_ERRORS:
4971 case VDEV_PROP_OPS_NULL:
4972 case VDEV_PROP_OPS_READ:
4973 case VDEV_PROP_OPS_WRITE:
4974 case VDEV_PROP_OPS_FREE:
4975 case VDEV_PROP_OPS_CLAIM:
4976 case VDEV_PROP_OPS_TRIM:
4977 case VDEV_PROP_BYTES_NULL:
4978 case VDEV_PROP_BYTES_READ:
4979 case VDEV_PROP_BYTES_WRITE:
4980 case VDEV_PROP_BYTES_FREE:
4981 case VDEV_PROP_BYTES_CLAIM:
4982 case VDEV_PROP_BYTES_TRIM:
4983 if (literal) {
4984 (void) snprintf(buf, len, "%llu",
4985 (u_longlong_t)intval);
4986 } else {
4987 (void) zfs_nicenum(intval, buf, len);
4988 }
4989 break;
4990 case VDEV_PROP_EXPANDSZ:
4991 if (intval == 0) {
4992 (void) strlcpy(buf, "-", len);
4993 } else if (literal) {
4994 (void) snprintf(buf, len, "%llu",
4995 (u_longlong_t)intval);
4996 } else {
4997 (void) zfs_nicenum(intval, buf, len);
4998 }
4999 break;
5000 case VDEV_PROP_CAPACITY:
5001 if (literal) {
5002 (void) snprintf(buf, len, "%llu",
5003 (u_longlong_t)intval);
5004 } else {
5005 (void) snprintf(buf, len, "%llu%%",
5006 (u_longlong_t)intval);
5007 }
5008 break;
5009 case VDEV_PROP_CHECKSUM_N:
5010 case VDEV_PROP_CHECKSUM_T:
5011 case VDEV_PROP_IO_N:
5012 case VDEV_PROP_IO_T:
5013 if (intval == UINT64_MAX) {
5014 (void) strlcpy(buf, "-", len);
5015 } else {
5016 (void) snprintf(buf, len, "%llu",
5017 (u_longlong_t)intval);
5018 }
5019 break;
5020 case VDEV_PROP_FRAGMENTATION:
5021 if (intval == UINT64_MAX) {
5022 (void) strlcpy(buf, "-", len);
5023 } else {
5024 (void) snprintf(buf, len, "%llu%%",
5025 (u_longlong_t)intval);
5026 }
5027 break;
5028 case VDEV_PROP_STATE:
5029 if (literal) {
5030 (void) snprintf(buf, len, "%llu",
5031 (u_longlong_t)intval);
5032 } else {
5033 (void) strlcpy(buf, zpool_state_to_name(intval,
5034 VDEV_AUX_NONE), len);
5035 }
5036 break;
5037 default:
5038 (void) snprintf(buf, len, "%llu",
5039 (u_longlong_t)intval);
5040 }
5041 break;
5042
5043 case PROP_TYPE_INDEX:
5044 if (nvlist_lookup_nvlist(nvprop, prop_name, &nv) == 0) {
5045 src = fnvlist_lookup_uint64(nv, ZPROP_SOURCE);
5046 intval = fnvlist_lookup_uint64(nv, ZPROP_VALUE);
5047 } else {
5048 src = ZPROP_SRC_DEFAULT;
5049 intval = vdev_prop_default_numeric(prop);
5050 }
5051 if (vdev_prop_index_to_string(prop, intval,
5052 (const char **)&strval) != 0)
5053 return (-1);
5054 (void) strlcpy(buf, strval, len);
5055 break;
5056
5057 default:
5058 abort();
5059 }
5060
5061 if (srctype)
5062 *srctype = src;
5063
5064 return (0);
5065 }
5066
5067 /*
5068 * Get a vdev property value for 'prop_name' and return the value in
5069 * a pre-allocated buffer.
5070 */
5071 int
5072 zpool_get_vdev_prop(zpool_handle_t *zhp, const char *vdevname, vdev_prop_t prop,
5073 char *prop_name, char *buf, size_t len, zprop_source_t *srctype,
5074 boolean_t literal)
5075 {
5076 nvlist_t *reqnvl, *reqprops;
5077 nvlist_t *retprops = NULL;
5078 uint64_t vdev_guid = 0;
5079 int ret;
5080
5081 if ((ret = zpool_vdev_guid(zhp, vdevname, &vdev_guid)) != 0)
5082 return (ret);
5083
5084 if (nvlist_alloc(&reqnvl, NV_UNIQUE_NAME, 0) != 0)
5085 return (no_memory(zhp->zpool_hdl));
5086 if (nvlist_alloc(&reqprops, NV_UNIQUE_NAME, 0) != 0)
5087 return (no_memory(zhp->zpool_hdl));
5088
5089 fnvlist_add_uint64(reqnvl, ZPOOL_VDEV_PROPS_GET_VDEV, vdev_guid);
5090
5091 if (prop != VDEV_PROP_USERPROP) {
5092 /* prop_name overrides prop value */
5093 if (prop_name != NULL)
5094 prop = vdev_name_to_prop(prop_name);
5095 else
5096 prop_name = (char *)vdev_prop_to_name(prop);
5097 assert(prop < VDEV_NUM_PROPS);
5098 }
5099
5100 assert(prop_name != NULL);
5101 if (nvlist_add_uint64(reqprops, prop_name, prop) != 0) {
5102 nvlist_free(reqnvl);
5103 nvlist_free(reqprops);
5104 return (no_memory(zhp->zpool_hdl));
5105 }
5106
5107 fnvlist_add_nvlist(reqnvl, ZPOOL_VDEV_PROPS_GET_PROPS, reqprops);
5108
5109 ret = lzc_get_vdev_prop(zhp->zpool_name, reqnvl, &retprops);
5110
5111 if (ret == 0) {
5112 ret = zpool_get_vdev_prop_value(retprops, prop, prop_name, buf,
5113 len, srctype, literal);
5114 } else {
5115 char errbuf[ERRBUFLEN];
5116 (void) snprintf(errbuf, sizeof (errbuf),
5117 dgettext(TEXT_DOMAIN, "cannot get vdev property %s from"
5118 " %s in %s"), prop_name, vdevname, zhp->zpool_name);
5119 (void) zpool_standard_error(zhp->zpool_hdl, ret, errbuf);
5120 }
5121
5122 nvlist_free(reqnvl);
5123 nvlist_free(reqprops);
5124 nvlist_free(retprops);
5125
5126 return (ret);
5127 }
5128
5129 /*
5130 * Get all vdev properties
5131 */
5132 int
5133 zpool_get_all_vdev_props(zpool_handle_t *zhp, const char *vdevname,
5134 nvlist_t **outnvl)
5135 {
5136 nvlist_t *nvl = NULL;
5137 uint64_t vdev_guid = 0;
5138 int ret;
5139
5140 if ((ret = zpool_vdev_guid(zhp, vdevname, &vdev_guid)) != 0)
5141 return (ret);
5142
5143 if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0)
5144 return (no_memory(zhp->zpool_hdl));
5145
5146 fnvlist_add_uint64(nvl, ZPOOL_VDEV_PROPS_GET_VDEV, vdev_guid);
5147
5148 ret = lzc_get_vdev_prop(zhp->zpool_name, nvl, outnvl);
5149
5150 nvlist_free(nvl);
5151
5152 if (ret) {
5153 char errbuf[ERRBUFLEN];
5154 (void) snprintf(errbuf, sizeof (errbuf),
5155 dgettext(TEXT_DOMAIN, "cannot get vdev properties for"
5156 " %s in %s"), vdevname, zhp->zpool_name);
5157 (void) zpool_standard_error(zhp->zpool_hdl, errno, errbuf);
5158 }
5159
5160 return (ret);
5161 }
5162
5163 /*
5164 * Set vdev property
5165 */
5166 int
5167 zpool_set_vdev_prop(zpool_handle_t *zhp, const char *vdevname,
5168 const char *propname, const char *propval)
5169 {
5170 int ret;
5171 nvlist_t *nvl = NULL;
5172 nvlist_t *outnvl = NULL;
5173 nvlist_t *props;
5174 nvlist_t *realprops;
5175 prop_flags_t flags = { 0 };
5176 uint64_t version;
5177 uint64_t vdev_guid;
5178
5179 if ((ret = zpool_vdev_guid(zhp, vdevname, &vdev_guid)) != 0)
5180 return (ret);
5181
5182 if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0)
5183 return (no_memory(zhp->zpool_hdl));
5184 if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0)
5185 return (no_memory(zhp->zpool_hdl));
5186
5187 fnvlist_add_uint64(nvl, ZPOOL_VDEV_PROPS_SET_VDEV, vdev_guid);
5188
5189 if (nvlist_add_string(props, propname, propval) != 0) {
5190 nvlist_free(props);
5191 return (no_memory(zhp->zpool_hdl));
5192 }
5193
5194 char errbuf[ERRBUFLEN];
5195 (void) snprintf(errbuf, sizeof (errbuf),
5196 dgettext(TEXT_DOMAIN, "cannot set property %s for %s on %s"),
5197 propname, vdevname, zhp->zpool_name);
5198
5199 flags.vdevprop = 1;
5200 version = zpool_get_prop_int(zhp, ZPOOL_PROP_VERSION, NULL);
5201 if ((realprops = zpool_valid_proplist(zhp->zpool_hdl,
5202 zhp->zpool_name, props, version, flags, errbuf)) == NULL) {
5203 nvlist_free(props);
5204 nvlist_free(nvl);
5205 return (-1);
5206 }
5207
5208 nvlist_free(props);
5209 props = realprops;
5210
5211 fnvlist_add_nvlist(nvl, ZPOOL_VDEV_PROPS_SET_PROPS, props);
5212
5213 ret = lzc_set_vdev_prop(zhp->zpool_name, nvl, &outnvl);
5214
5215 nvlist_free(props);
5216 nvlist_free(nvl);
5217 nvlist_free(outnvl);
5218
5219 if (ret)
5220 (void) zpool_standard_error(zhp->zpool_hdl, errno, errbuf);
5221
5222 return (ret);
5223 }
ZFS On Linux mirror for PVE