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