]> git.proxmox.com Git - mirror_zfs.git/blob - lib/libzfs/libzfs_pool.c
projects / mirror_zfs.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Teach zpool scrub to scrub only blocks in error log
[mirror_zfs.git] / lib / libzfs / libzfs_pool.c
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or https://opensource.org/licenses/CDDL-1.0.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2015 Nexenta Systems, Inc. All rights reserved.
24 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
25 * Copyright (c) 2011, 2020 by Delphix. All rights reserved.
26 * Copyright 2016 Igor Kozhukhov <ikozhukhov@gmail.com>
27 * Copyright (c) 2018 Datto Inc.
28 * Copyright (c) 2017 Open-E, Inc. All Rights Reserved.
29 * Copyright (c) 2017, Intel Corporation.
30 * Copyright (c) 2018, loli10K <ezomori.nozomu@gmail.com>
31 * Copyright (c) 2021, Colm Buckley <colm@tuatha.org>
32 * Copyright (c) 2021, Klara Inc.
33 */
34
35 #include <errno.h>
36 #include <libintl.h>
37 #include <stdio.h>
38 #include <stdlib.h>
39 #include <strings.h>
40 #include <unistd.h>
41 #include <libgen.h>
42 #include <zone.h>
43 #include <sys/stat.h>
44 #include <sys/efi_partition.h>
45 #include <sys/systeminfo.h>
46 #include <sys/zfs_ioctl.h>
47 #include <sys/zfs_sysfs.h>
48 #include <sys/vdev_disk.h>
49 #include <sys/types.h>
50 #include <dlfcn.h>
51 #include <libzutil.h>
52 #include <fcntl.h>
53
54 #include "zfs_namecheck.h"
55 #include "zfs_prop.h"
56 #include "libzfs_impl.h"
57 #include "zfs_comutil.h"
58 #include "zfeature_common.h"
59
60 static boolean_t zpool_vdev_is_interior(const char *name);
61
62 typedef struct prop_flags {
63 unsigned int create:1; /* Validate property on creation */
64 unsigned int import:1; /* Validate property on import */
65 unsigned int vdevprop:1; /* Validate property as a VDEV property */
66 } prop_flags_t;
67
68 /*
69 * ====================================================================
70 * zpool property functions
71 * ====================================================================
72 */
73
74 static int
75 zpool_get_all_props(zpool_handle_t *zhp)
76 {
77 zfs_cmd_t zc = {"\0"};
78 libzfs_handle_t *hdl = zhp->zpool_hdl;
79
80 (void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
81
82 zcmd_alloc_dst_nvlist(hdl, &zc, 0);
83
84 while (zfs_ioctl(hdl, ZFS_IOC_POOL_GET_PROPS, &zc) != 0) {
85 if (errno == ENOMEM)
86 zcmd_expand_dst_nvlist(hdl, &zc);
87 else {
88 zcmd_free_nvlists(&zc);
89 return (-1);
90 }
91 }
92
93 if (zcmd_read_dst_nvlist(hdl, &zc, &zhp->zpool_props) != 0) {
94 zcmd_free_nvlists(&zc);
95 return (-1);
96 }
97
98 zcmd_free_nvlists(&zc);
99
100 return (0);
101 }
102
103 int
104 zpool_props_refresh(zpool_handle_t *zhp)
105 {
106 nvlist_t *old_props;
107
108 old_props = zhp->zpool_props;
109
110 if (zpool_get_all_props(zhp) != 0)
111 return (-1);
112
113 nvlist_free(old_props);
114 return (0);
115 }
116
117 static const char *
118 zpool_get_prop_string(zpool_handle_t *zhp, zpool_prop_t prop,
119 zprop_source_t *src)
120 {
121 nvlist_t *nv, *nvl;
122 const char *value;
123 zprop_source_t source;
124
125 nvl = zhp->zpool_props;
126 if (nvlist_lookup_nvlist(nvl, zpool_prop_to_name(prop), &nv) == 0) {
127 source = fnvlist_lookup_uint64(nv, ZPROP_SOURCE);
128 value = fnvlist_lookup_string(nv, ZPROP_VALUE);
129 } else {
130 source = ZPROP_SRC_DEFAULT;
131 if ((value = zpool_prop_default_string(prop)) == NULL)
132 value = "-";
133 }
134
135 if (src)
136 *src = source;
137
138 return (value);
139 }
140
141 uint64_t
142 zpool_get_prop_int(zpool_handle_t *zhp, zpool_prop_t prop, zprop_source_t *src)
143 {
144 nvlist_t *nv, *nvl;
145 uint64_t value;
146 zprop_source_t source;
147
148 if (zhp->zpool_props == NULL && zpool_get_all_props(zhp)) {
149 /*
150 * zpool_get_all_props() has most likely failed because
151 * the pool is faulted, but if all we need is the top level
152 * vdev's guid then get it from the zhp config nvlist.
153 */
154 if ((prop == ZPOOL_PROP_GUID) &&
155 (nvlist_lookup_nvlist(zhp->zpool_config,
156 ZPOOL_CONFIG_VDEV_TREE, &nv) == 0) &&
157 (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &value)
158 == 0)) {
159 return (value);
160 }
161 return (zpool_prop_default_numeric(prop));
162 }
163
164 nvl = zhp->zpool_props;
165 if (nvlist_lookup_nvlist(nvl, zpool_prop_to_name(prop), &nv) == 0) {
166 source = fnvlist_lookup_uint64(nv, ZPROP_SOURCE);
167 value = fnvlist_lookup_uint64(nv, ZPROP_VALUE);
168 } else {
169 source = ZPROP_SRC_DEFAULT;
170 value = zpool_prop_default_numeric(prop);
171 }
172
173 if (src)
174 *src = source;
175
176 return (value);
177 }
178
179 /*
180 * Map VDEV STATE to printed strings.
181 */
182 const char *
183 zpool_state_to_name(vdev_state_t state, vdev_aux_t aux)
184 {
185 switch (state) {
186 case VDEV_STATE_CLOSED:
187 case VDEV_STATE_OFFLINE:
188 return (gettext("OFFLINE"));
189 case VDEV_STATE_REMOVED:
190 return (gettext("REMOVED"));
191 case VDEV_STATE_CANT_OPEN:
192 if (aux == VDEV_AUX_CORRUPT_DATA || aux == VDEV_AUX_BAD_LOG)
193 return (gettext("FAULTED"));
194 else if (aux == VDEV_AUX_SPLIT_POOL)
195 return (gettext("SPLIT"));
196 else
197 return (gettext("UNAVAIL"));
198 case VDEV_STATE_FAULTED:
199 return (gettext("FAULTED"));
200 case VDEV_STATE_DEGRADED:
201 return (gettext("DEGRADED"));
202 case VDEV_STATE_HEALTHY:
203 return (gettext("ONLINE"));
204
205 default:
206 break;
207 }
208
209 return (gettext("UNKNOWN"));
210 }
211
212 /*
213 * Map POOL STATE to printed strings.
214 */
215 const char *
216 zpool_pool_state_to_name(pool_state_t state)
217 {
218 switch (state) {
219 default:
220 break;
221 case POOL_STATE_ACTIVE:
222 return (gettext("ACTIVE"));
223 case POOL_STATE_EXPORTED:
224 return (gettext("EXPORTED"));
225 case POOL_STATE_DESTROYED:
226 return (gettext("DESTROYED"));
227 case POOL_STATE_SPARE:
228 return (gettext("SPARE"));
229 case POOL_STATE_L2CACHE:
230 return (gettext("L2CACHE"));
231 case POOL_STATE_UNINITIALIZED:
232 return (gettext("UNINITIALIZED"));
233 case POOL_STATE_UNAVAIL:
234 return (gettext("UNAVAIL"));
235 case POOL_STATE_POTENTIALLY_ACTIVE:
236 return (gettext("POTENTIALLY_ACTIVE"));
237 }
238
239 return (gettext("UNKNOWN"));
240 }
241
242 /*
243 * Given a pool handle, return the pool health string ("ONLINE", "DEGRADED",
244 * "SUSPENDED", etc).
245 */
246 const char *
247 zpool_get_state_str(zpool_handle_t *zhp)
248 {
249 zpool_errata_t errata;
250 zpool_status_t status;
251 const char *str;
252
253 status = zpool_get_status(zhp, NULL, &errata);
254
255 if (zpool_get_state(zhp) == POOL_STATE_UNAVAIL) {
256 str = gettext("FAULTED");
257 } else if (status == ZPOOL_STATUS_IO_FAILURE_WAIT ||
258 status == ZPOOL_STATUS_IO_FAILURE_MMP) {
259 str = gettext("SUSPENDED");
260 } else {
261 nvlist_t *nvroot = fnvlist_lookup_nvlist(
262 zpool_get_config(zhp, NULL), ZPOOL_CONFIG_VDEV_TREE);
263 uint_t vsc;
264 vdev_stat_t *vs = (vdev_stat_t *)fnvlist_lookup_uint64_array(
265 nvroot, ZPOOL_CONFIG_VDEV_STATS, &vsc);
266 str = zpool_state_to_name(vs->vs_state, vs->vs_aux);
267 }
268 return (str);
269 }
270
271 /*
272 * Get a zpool property value for 'prop' and return the value in
273 * a pre-allocated buffer.
274 */
275 int
276 zpool_get_prop(zpool_handle_t *zhp, zpool_prop_t prop, char *buf,
277 size_t len, zprop_source_t *srctype, boolean_t literal)
278 {
279 uint64_t intval;
280 const char *strval;
281 zprop_source_t src = ZPROP_SRC_NONE;
282
283 if (zpool_get_state(zhp) == POOL_STATE_UNAVAIL) {
284 switch (prop) {
285 case ZPOOL_PROP_NAME:
286 (void) strlcpy(buf, zpool_get_name(zhp), len);
287 break;
288
289 case ZPOOL_PROP_HEALTH:
290 (void) strlcpy(buf, zpool_get_state_str(zhp), len);
291 break;
292
293 case ZPOOL_PROP_GUID:
294 intval = zpool_get_prop_int(zhp, prop, &src);
295 (void) snprintf(buf, len, "%llu", (u_longlong_t)intval);
296 break;
297
298 case ZPOOL_PROP_ALTROOT:
299 case ZPOOL_PROP_CACHEFILE:
300 case ZPOOL_PROP_COMMENT:
301 case ZPOOL_PROP_COMPATIBILITY:
302 if (zhp->zpool_props != NULL ||
303 zpool_get_all_props(zhp) == 0) {
304 (void) strlcpy(buf,
305 zpool_get_prop_string(zhp, prop, &src),
306 len);
307 break;
308 }
309 zfs_fallthrough;
310 default:
311 (void) strlcpy(buf, "-", len);
312 break;
313 }
314
315 if (srctype != NULL)
316 *srctype = src;
317 return (0);
318 }
319
320 if (zhp->zpool_props == NULL && zpool_get_all_props(zhp) &&
321 prop != ZPOOL_PROP_NAME)
322 return (-1);
323
324 switch (zpool_prop_get_type(prop)) {
325 case PROP_TYPE_STRING:
326 (void) strlcpy(buf, zpool_get_prop_string(zhp, prop, &src),
327 len);
328 break;
329
330 case PROP_TYPE_NUMBER:
331 intval = zpool_get_prop_int(zhp, prop, &src);
332
333 switch (prop) {
334 case ZPOOL_PROP_SIZE:
335 case ZPOOL_PROP_ALLOCATED:
336 case ZPOOL_PROP_FREE:
337 case ZPOOL_PROP_FREEING:
338 case ZPOOL_PROP_LEAKED:
339 case ZPOOL_PROP_ASHIFT:
340 case ZPOOL_PROP_MAXBLOCKSIZE:
341 case ZPOOL_PROP_MAXDNODESIZE:
342 case ZPOOL_PROP_BCLONESAVED:
343 case ZPOOL_PROP_BCLONEUSED:
344 if (literal)
345 (void) snprintf(buf, len, "%llu",
346 (u_longlong_t)intval);
347 else
348 (void) zfs_nicenum(intval, buf, len);
349 break;
350
351 case ZPOOL_PROP_EXPANDSZ:
352 case ZPOOL_PROP_CHECKPOINT:
353 if (intval == 0) {
354 (void) strlcpy(buf, "-", len);
355 } else if (literal) {
356 (void) snprintf(buf, len, "%llu",
357 (u_longlong_t)intval);
358 } else {
359 (void) zfs_nicebytes(intval, buf, len);
360 }
361 break;
362
363 case ZPOOL_PROP_CAPACITY:
364 if (literal) {
365 (void) snprintf(buf, len, "%llu",
366 (u_longlong_t)intval);
367 } else {
368 (void) snprintf(buf, len, "%llu%%",
369 (u_longlong_t)intval);
370 }
371 break;
372
373 case ZPOOL_PROP_FRAGMENTATION:
374 if (intval == UINT64_MAX) {
375 (void) strlcpy(buf, "-", len);
376 } else if (literal) {
377 (void) snprintf(buf, len, "%llu",
378 (u_longlong_t)intval);
379 } else {
380 (void) snprintf(buf, len, "%llu%%",
381 (u_longlong_t)intval);
382 }
383 break;
384
385 case ZPOOL_PROP_BCLONERATIO:
386 case ZPOOL_PROP_DEDUPRATIO:
387 if (literal)
388 (void) snprintf(buf, len, "%llu.%02llu",
389 (u_longlong_t)(intval / 100),
390 (u_longlong_t)(intval % 100));
391 else
392 (void) snprintf(buf, len, "%llu.%02llux",
393 (u_longlong_t)(intval / 100),
394 (u_longlong_t)(intval % 100));
395 break;
396
397 case ZPOOL_PROP_HEALTH:
398 (void) strlcpy(buf, zpool_get_state_str(zhp), len);
399 break;
400 case ZPOOL_PROP_VERSION:
401 if (intval >= SPA_VERSION_FEATURES) {
402 (void) snprintf(buf, len, "-");
403 break;
404 }
405 zfs_fallthrough;
406 default:
407 (void) snprintf(buf, len, "%llu", (u_longlong_t)intval);
408 }
409 break;
410
411 case PROP_TYPE_INDEX:
412 intval = zpool_get_prop_int(zhp, prop, &src);
413 if (zpool_prop_index_to_string(prop, intval, &strval)
414 != 0)
415 return (-1);
416 (void) strlcpy(buf, strval, len);
417 break;
418
419 default:
420 abort();
421 }
422
423 if (srctype)
424 *srctype = src;
425
426 return (0);
427 }
428
429 /*
430 * 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 }
ZFS On Linux mirror for PVE