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