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.
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.
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]
23 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright 2020 Joyent, Inc. All rights reserved.
25 * Copyright (c) 2011, 2020 by Delphix. All rights reserved.
26 * Copyright 2016 Igor Kozhukhov <ikozhukhov@gmail.com>
27 * Copyright (c) 2017 Datto Inc.
28 * Copyright (c) 2020 The FreeBSD Foundation
30 * Portions of this software were developed by Allan Jude
31 * under sponsorship from the FreeBSD Foundation.
35 * Internal utility routines for the ZFS library.
51 #include <sys/mnttab.h>
52 #include <sys/mntent.h>
53 #include <sys/types.h>
57 #include <libzfs_core.h>
59 #include "libzfs_impl.h"
61 #include "zfeature_common.h"
62 #include <zfs_fletcher.h>
66 * We only care about the scheme in order to match the scheme
67 * with the handler. Each handler should validate the full URI
70 #define URI_REGEX "^\\([A-Za-z][A-Za-z0-9+.\\-]*\\):"
73 libzfs_errno(libzfs_handle_t
*hdl
)
75 return (hdl
->libzfs_error
);
79 libzfs_error_action(libzfs_handle_t
*hdl
)
81 return (hdl
->libzfs_action
);
85 libzfs_error_description(libzfs_handle_t
*hdl
)
87 if (hdl
->libzfs_desc
[0] != '\0')
88 return (hdl
->libzfs_desc
);
90 switch (hdl
->libzfs_error
) {
92 return (dgettext(TEXT_DOMAIN
, "out of memory"));
94 return (dgettext(TEXT_DOMAIN
, "invalid property value"));
95 case EZFS_PROPREADONLY
:
96 return (dgettext(TEXT_DOMAIN
, "read-only property"));
98 return (dgettext(TEXT_DOMAIN
, "property doesn't apply to "
99 "datasets of this type"));
100 case EZFS_PROPNONINHERIT
:
101 return (dgettext(TEXT_DOMAIN
, "property cannot be inherited"));
103 return (dgettext(TEXT_DOMAIN
, "invalid quota or reservation"));
105 return (dgettext(TEXT_DOMAIN
, "operation not applicable to "
106 "datasets of this type"));
108 return (dgettext(TEXT_DOMAIN
, "pool or dataset is busy"));
110 return (dgettext(TEXT_DOMAIN
, "pool or dataset exists"));
112 return (dgettext(TEXT_DOMAIN
, "no such pool or dataset"));
114 return (dgettext(TEXT_DOMAIN
, "invalid backup stream"));
115 case EZFS_DSREADONLY
:
116 return (dgettext(TEXT_DOMAIN
, "dataset is read-only"));
118 return (dgettext(TEXT_DOMAIN
, "volume size exceeds limit for "
120 case EZFS_INVALIDNAME
:
121 return (dgettext(TEXT_DOMAIN
, "invalid name"));
122 case EZFS_BADRESTORE
:
123 return (dgettext(TEXT_DOMAIN
, "unable to restore to "
126 return (dgettext(TEXT_DOMAIN
, "backup failed"));
128 return (dgettext(TEXT_DOMAIN
, "invalid target vdev"));
130 return (dgettext(TEXT_DOMAIN
, "no such device in pool"));
132 return (dgettext(TEXT_DOMAIN
, "invalid device"));
133 case EZFS_NOREPLICAS
:
134 return (dgettext(TEXT_DOMAIN
, "no valid replicas"));
135 case EZFS_RESILVERING
:
136 return (dgettext(TEXT_DOMAIN
, "currently resilvering"));
137 case EZFS_BADVERSION
:
138 return (dgettext(TEXT_DOMAIN
, "unsupported version or "
140 case EZFS_POOLUNAVAIL
:
141 return (dgettext(TEXT_DOMAIN
, "pool is unavailable"));
142 case EZFS_DEVOVERFLOW
:
143 return (dgettext(TEXT_DOMAIN
, "too many devices in one vdev"));
145 return (dgettext(TEXT_DOMAIN
, "must be an absolute path"));
146 case EZFS_CROSSTARGET
:
147 return (dgettext(TEXT_DOMAIN
, "operation crosses datasets or "
150 return (dgettext(TEXT_DOMAIN
, "dataset in use by local zone"));
151 case EZFS_MOUNTFAILED
:
152 return (dgettext(TEXT_DOMAIN
, "mount failed"));
153 case EZFS_UMOUNTFAILED
:
154 return (dgettext(TEXT_DOMAIN
, "unmount failed"));
155 case EZFS_UNSHARENFSFAILED
:
156 return (dgettext(TEXT_DOMAIN
, "NFS share removal failed"));
157 case EZFS_SHARENFSFAILED
:
158 return (dgettext(TEXT_DOMAIN
, "NFS share creation failed"));
159 case EZFS_UNSHARESMBFAILED
:
160 return (dgettext(TEXT_DOMAIN
, "SMB share removal failed"));
161 case EZFS_SHARESMBFAILED
:
162 return (dgettext(TEXT_DOMAIN
, "SMB share creation failed"));
164 return (dgettext(TEXT_DOMAIN
, "permission denied"));
166 return (dgettext(TEXT_DOMAIN
, "out of space"));
168 return (dgettext(TEXT_DOMAIN
, "bad address"));
170 return (dgettext(TEXT_DOMAIN
, "I/O error"));
172 return (dgettext(TEXT_DOMAIN
, "signal received"));
174 return (dgettext(TEXT_DOMAIN
, "insufficient replicas"));
176 return (dgettext(TEXT_DOMAIN
, "device is reserved as a hot "
178 case EZFS_INVALCONFIG
:
179 return (dgettext(TEXT_DOMAIN
, "invalid vdev configuration"));
181 return (dgettext(TEXT_DOMAIN
, "recursive dataset dependency"));
183 return (dgettext(TEXT_DOMAIN
, "no history available"));
185 return (dgettext(TEXT_DOMAIN
, "failed to retrieve "
187 case EZFS_POOL_NOTSUP
:
188 return (dgettext(TEXT_DOMAIN
, "operation not supported "
189 "on this type of pool"));
190 case EZFS_POOL_INVALARG
:
191 return (dgettext(TEXT_DOMAIN
, "invalid argument for "
192 "this pool operation"));
193 case EZFS_NAMETOOLONG
:
194 return (dgettext(TEXT_DOMAIN
, "dataset name is too long"));
195 case EZFS_OPENFAILED
:
196 return (dgettext(TEXT_DOMAIN
, "open failed"));
198 return (dgettext(TEXT_DOMAIN
,
199 "disk capacity information could not be retrieved"));
200 case EZFS_LABELFAILED
:
201 return (dgettext(TEXT_DOMAIN
, "write of label failed"));
203 return (dgettext(TEXT_DOMAIN
, "invalid user/group"));
205 return (dgettext(TEXT_DOMAIN
, "invalid permission"));
206 case EZFS_BADPERMSET
:
207 return (dgettext(TEXT_DOMAIN
, "invalid permission set name"));
208 case EZFS_NODELEGATION
:
209 return (dgettext(TEXT_DOMAIN
, "delegated administration is "
210 "disabled on pool"));
212 return (dgettext(TEXT_DOMAIN
, "invalid or missing cache file"));
214 return (dgettext(TEXT_DOMAIN
, "device is in use as a cache"));
215 case EZFS_VDEVNOTSUP
:
216 return (dgettext(TEXT_DOMAIN
, "vdev specification is not "
219 return (dgettext(TEXT_DOMAIN
, "operation not supported "
221 case EZFS_IOC_NOTSUPPORTED
:
222 return (dgettext(TEXT_DOMAIN
, "operation not supported by "
223 "zfs kernel module"));
224 case EZFS_ACTIVE_SPARE
:
225 return (dgettext(TEXT_DOMAIN
, "pool has active shared spare "
227 case EZFS_UNPLAYED_LOGS
:
228 return (dgettext(TEXT_DOMAIN
, "log device has unplayed intent "
230 case EZFS_REFTAG_RELE
:
231 return (dgettext(TEXT_DOMAIN
, "no such tag on this dataset"));
232 case EZFS_REFTAG_HOLD
:
233 return (dgettext(TEXT_DOMAIN
, "tag already exists on this "
235 case EZFS_TAGTOOLONG
:
236 return (dgettext(TEXT_DOMAIN
, "tag too long"));
237 case EZFS_PIPEFAILED
:
238 return (dgettext(TEXT_DOMAIN
, "pipe create failed"));
239 case EZFS_THREADCREATEFAILED
:
240 return (dgettext(TEXT_DOMAIN
, "thread create failed"));
241 case EZFS_POSTSPLIT_ONLINE
:
242 return (dgettext(TEXT_DOMAIN
, "disk was split from this pool "
244 case EZFS_SCRUB_PAUSED
:
245 return (dgettext(TEXT_DOMAIN
, "scrub is paused; "
246 "use 'zpool scrub' to resume scrub"));
247 case EZFS_SCRUB_PAUSED_TO_CANCEL
:
248 return (dgettext(TEXT_DOMAIN
, "scrub is paused; "
249 "use 'zpool scrub' to resume or 'zpool scrub -s' to "
252 return (dgettext(TEXT_DOMAIN
, "currently scrubbing; "
253 "use 'zpool scrub -s' to cancel scrub"));
254 case EZFS_ERRORSCRUBBING
:
255 return (dgettext(TEXT_DOMAIN
, "currently error scrubbing; "
256 "use 'zpool scrub -s' to cancel error scrub"));
257 case EZFS_ERRORSCRUB_PAUSED
:
258 return (dgettext(TEXT_DOMAIN
, "error scrub is paused; "
259 "use 'zpool scrub -e' to resume error scrub"));
261 return (dgettext(TEXT_DOMAIN
, "there is no active scrub"));
263 return (dgettext(TEXT_DOMAIN
, "unable to generate diffs"));
265 return (dgettext(TEXT_DOMAIN
, "invalid diff data"));
266 case EZFS_POOLREADONLY
:
267 return (dgettext(TEXT_DOMAIN
, "pool is read-only"));
268 case EZFS_NO_PENDING
:
269 return (dgettext(TEXT_DOMAIN
, "operation is not "
271 case EZFS_CHECKPOINT_EXISTS
:
272 return (dgettext(TEXT_DOMAIN
, "checkpoint exists"));
273 case EZFS_DISCARDING_CHECKPOINT
:
274 return (dgettext(TEXT_DOMAIN
, "currently discarding "
276 case EZFS_NO_CHECKPOINT
:
277 return (dgettext(TEXT_DOMAIN
, "checkpoint does not exist"));
278 case EZFS_DEVRM_IN_PROGRESS
:
279 return (dgettext(TEXT_DOMAIN
, "device removal in progress"));
280 case EZFS_VDEV_TOO_BIG
:
281 return (dgettext(TEXT_DOMAIN
, "device exceeds supported size"));
282 case EZFS_ACTIVE_POOL
:
283 return (dgettext(TEXT_DOMAIN
, "pool is imported on a "
285 case EZFS_CRYPTOFAILED
:
286 return (dgettext(TEXT_DOMAIN
, "encryption failure"));
288 return (dgettext(TEXT_DOMAIN
, "argument list too long"));
289 case EZFS_INITIALIZING
:
290 return (dgettext(TEXT_DOMAIN
, "currently initializing"));
291 case EZFS_NO_INITIALIZE
:
292 return (dgettext(TEXT_DOMAIN
, "there is no active "
294 case EZFS_WRONG_PARENT
:
295 return (dgettext(TEXT_DOMAIN
, "invalid parent dataset"));
297 return (dgettext(TEXT_DOMAIN
, "currently trimming"));
299 return (dgettext(TEXT_DOMAIN
, "there is no active trim"));
300 case EZFS_TRIM_NOTSUP
:
301 return (dgettext(TEXT_DOMAIN
, "trim operations are not "
302 "supported by this device"));
303 case EZFS_NO_RESILVER_DEFER
:
304 return (dgettext(TEXT_DOMAIN
, "this action requires the "
305 "resilver_defer feature"));
306 case EZFS_EXPORT_IN_PROGRESS
:
307 return (dgettext(TEXT_DOMAIN
, "pool export in progress"));
308 case EZFS_REBUILDING
:
309 return (dgettext(TEXT_DOMAIN
, "currently sequentially "
311 case EZFS_VDEV_NOTSUP
:
312 return (dgettext(TEXT_DOMAIN
, "operation not supported "
313 "on this type of vdev"));
314 case EZFS_NOT_USER_NAMESPACE
:
315 return (dgettext(TEXT_DOMAIN
, "the provided file "
316 "was not a user namespace file"));
317 case EZFS_RESUME_EXISTS
:
318 return (dgettext(TEXT_DOMAIN
, "Resuming recv on existing "
319 "dataset without force"));
320 case EZFS_RAIDZ_EXPAND_IN_PROGRESS
:
321 return (dgettext(TEXT_DOMAIN
, "raidz expansion in progress"));
323 return (dgettext(TEXT_DOMAIN
, "unknown error"));
325 assert(hdl
->libzfs_error
== 0);
326 return (dgettext(TEXT_DOMAIN
, "no error"));
331 zfs_error_aux(libzfs_handle_t
*hdl
, const char *fmt
, ...)
337 (void) vsnprintf(hdl
->libzfs_desc
, sizeof (hdl
->libzfs_desc
),
339 hdl
->libzfs_desc_active
= 1;
345 zfs_verror(libzfs_handle_t
*hdl
, int error
, const char *fmt
, va_list ap
)
347 (void) vsnprintf(hdl
->libzfs_action
, sizeof (hdl
->libzfs_action
),
349 hdl
->libzfs_error
= error
;
351 if (hdl
->libzfs_desc_active
)
352 hdl
->libzfs_desc_active
= 0;
354 hdl
->libzfs_desc
[0] = '\0';
356 if (hdl
->libzfs_printerr
) {
357 if (error
== EZFS_UNKNOWN
) {
358 (void) fprintf(stderr
, dgettext(TEXT_DOMAIN
, "internal "
359 "error: %s: %s\n"), hdl
->libzfs_action
,
360 libzfs_error_description(hdl
));
364 (void) fprintf(stderr
, "%s: %s\n", hdl
->libzfs_action
,
365 libzfs_error_description(hdl
));
366 if (error
== EZFS_NOMEM
)
372 zfs_error(libzfs_handle_t
*hdl
, int error
, const char *msg
)
374 return (zfs_error_fmt(hdl
, error
, "%s", msg
));
378 zfs_error_fmt(libzfs_handle_t
*hdl
, int error
, const char *fmt
, ...)
384 zfs_verror(hdl
, error
, fmt
, ap
);
392 zfs_common_error(libzfs_handle_t
*hdl
, int error
, const char *fmt
,
398 zfs_verror(hdl
, EZFS_PERM
, fmt
, ap
);
402 zfs_verror(hdl
, EZFS_NODELEGATION
, fmt
, ap
);
406 zfs_verror(hdl
, EZFS_IO
, fmt
, ap
);
410 zfs_verror(hdl
, EZFS_FAULT
, fmt
, ap
);
414 zfs_verror(hdl
, EZFS_INTR
, fmt
, ap
);
418 zfs_verror(hdl
, EZFS_CKSUM
, fmt
, ap
);
426 zfs_standard_error(libzfs_handle_t
*hdl
, int error
, const char *msg
)
428 return (zfs_standard_error_fmt(hdl
, error
, "%s", msg
));
432 zfs_standard_error_fmt(libzfs_handle_t
*hdl
, int error
, const char *fmt
, ...)
438 if (zfs_common_error(hdl
, error
, fmt
, ap
) != 0) {
447 zfs_verror(hdl
, EZFS_IO
, fmt
, ap
);
451 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
452 "dataset does not exist"));
453 zfs_verror(hdl
, EZFS_NOENT
, fmt
, ap
);
458 zfs_verror(hdl
, EZFS_NOSPC
, fmt
, ap
);
462 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
463 "dataset already exists"));
464 zfs_verror(hdl
, EZFS_EXISTS
, fmt
, ap
);
468 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
470 zfs_verror(hdl
, EZFS_BUSY
, fmt
, ap
);
473 zfs_verror(hdl
, EZFS_POOLREADONLY
, fmt
, ap
);
476 zfs_verror(hdl
, EZFS_NAMETOOLONG
, fmt
, ap
);
479 zfs_verror(hdl
, EZFS_BADVERSION
, fmt
, ap
);
482 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
483 "pool I/O is currently suspended"));
484 zfs_verror(hdl
, EZFS_POOLUNAVAIL
, fmt
, ap
);
487 zfs_verror(hdl
, EZFS_ACTIVE_POOL
, fmt
, ap
);
489 case ZFS_ERR_UNKNOWN_SEND_STREAM_FEATURE
:
490 case ZFS_ERR_IOC_CMD_UNAVAIL
:
491 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
, "the loaded zfs "
492 "module does not support this operation. A reboot may "
493 "be required to enable this operation."));
494 zfs_verror(hdl
, EZFS_IOC_NOTSUPPORTED
, fmt
, ap
);
496 case ZFS_ERR_IOC_ARG_UNAVAIL
:
497 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
, "the loaded zfs "
498 "module does not support an option for this operation. "
499 "A reboot may be required to enable this option."));
500 zfs_verror(hdl
, EZFS_IOC_NOTSUPPORTED
, fmt
, ap
);
502 case ZFS_ERR_IOC_ARG_REQUIRED
:
503 case ZFS_ERR_IOC_ARG_BADTYPE
:
504 zfs_verror(hdl
, EZFS_IOC_NOTSUPPORTED
, fmt
, ap
);
506 case ZFS_ERR_WRONG_PARENT
:
507 zfs_verror(hdl
, EZFS_WRONG_PARENT
, fmt
, ap
);
509 case ZFS_ERR_BADPROP
:
510 zfs_verror(hdl
, EZFS_BADPROP
, fmt
, ap
);
512 case ZFS_ERR_NOT_USER_NAMESPACE
:
513 zfs_verror(hdl
, EZFS_NOT_USER_NAMESPACE
, fmt
, ap
);
516 zfs_error_aux(hdl
, "%s", strerror(error
));
517 zfs_verror(hdl
, EZFS_UNKNOWN
, fmt
, ap
);
526 zfs_setprop_error(libzfs_handle_t
*hdl
, zfs_prop_t prop
, int err
,
533 * For quotas and reservations, ENOSPC indicates
534 * something different; setting a quota or reservation
535 * doesn't use any disk space.
539 case ZFS_PROP_REFQUOTA
:
540 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
541 "size is less than current used or "
543 (void) zfs_error(hdl
, EZFS_PROPSPACE
, errbuf
);
546 case ZFS_PROP_RESERVATION
:
547 case ZFS_PROP_REFRESERVATION
:
548 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
549 "size is greater than available space"));
550 (void) zfs_error(hdl
, EZFS_PROPSPACE
, errbuf
);
554 (void) zfs_standard_error(hdl
, err
, errbuf
);
560 (void) zfs_standard_error(hdl
, EBUSY
, errbuf
);
564 (void) zfs_error(hdl
, EZFS_DSREADONLY
, errbuf
);
568 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
569 "property value too long"));
570 (void) zfs_error(hdl
, EZFS_BADPROP
, errbuf
);
574 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
575 "pool and or dataset must be upgraded to set this "
576 "property or value"));
577 (void) zfs_error(hdl
, EZFS_BADVERSION
, errbuf
);
581 if (prop
== ZFS_PROP_COMPRESSION
||
582 prop
== ZFS_PROP_DNODESIZE
||
583 prop
== ZFS_PROP_RECORDSIZE
) {
584 (void) zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
585 "property setting is not allowed on "
586 "bootable datasets"));
587 (void) zfs_error(hdl
, EZFS_NOTSUP
, errbuf
);
588 } else if (prop
== ZFS_PROP_CHECKSUM
||
589 prop
== ZFS_PROP_DEDUP
) {
590 (void) zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
591 "property setting is not allowed on "
593 (void) zfs_error(hdl
, EZFS_NOTSUP
, errbuf
);
595 (void) zfs_standard_error(hdl
, err
, errbuf
);
600 if (prop
== ZPROP_INVAL
) {
601 (void) zfs_error(hdl
, EZFS_BADPROP
, errbuf
);
603 (void) zfs_standard_error(hdl
, err
, errbuf
);
607 case ZFS_ERR_BADPROP
:
608 (void) zfs_error(hdl
, EZFS_BADPROP
, errbuf
);
612 if (prop
== ZFS_PROP_KEYLOCATION
) {
613 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
614 "keylocation may only be set on encryption roots"));
615 (void) zfs_error(hdl
, EZFS_BADPROP
, errbuf
);
617 (void) zfs_standard_error(hdl
, err
, errbuf
);
623 * This platform can't address a volume this big.
626 if (prop
== ZFS_PROP_VOLSIZE
) {
627 (void) zfs_error(hdl
, EZFS_VOLTOOBIG
, errbuf
);
633 (void) zfs_standard_error(hdl
, err
, errbuf
);
638 zpool_standard_error(libzfs_handle_t
*hdl
, int error
, const char *msg
)
640 return (zpool_standard_error_fmt(hdl
, error
, "%s", msg
));
644 zpool_standard_error_fmt(libzfs_handle_t
*hdl
, int error
, const char *fmt
, ...)
650 if (zfs_common_error(hdl
, error
, fmt
, ap
) != 0) {
657 zfs_verror(hdl
, EZFS_NODEVICE
, fmt
, ap
);
662 dgettext(TEXT_DOMAIN
, "no such pool or dataset"));
663 zfs_verror(hdl
, EZFS_NOENT
, fmt
, ap
);
667 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
668 "pool already exists"));
669 zfs_verror(hdl
, EZFS_EXISTS
, fmt
, ap
);
673 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
, "pool is busy"));
674 zfs_verror(hdl
, EZFS_BUSY
, fmt
, ap
);
677 /* There is no pending operation to cancel */
679 zfs_verror(hdl
, EZFS_NO_PENDING
, fmt
, ap
);
683 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
684 "one or more devices is currently unavailable"));
685 zfs_verror(hdl
, EZFS_BADDEV
, fmt
, ap
);
689 zfs_verror(hdl
, EZFS_DEVOVERFLOW
, fmt
, ap
);
693 zfs_verror(hdl
, EZFS_POOL_NOTSUP
, fmt
, ap
);
697 zfs_verror(hdl
, EZFS_POOL_INVALARG
, fmt
, ap
);
702 zfs_verror(hdl
, EZFS_NOSPC
, fmt
, ap
);
706 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
707 "pool I/O is currently suspended"));
708 zfs_verror(hdl
, EZFS_POOLUNAVAIL
, fmt
, ap
);
712 zfs_verror(hdl
, EZFS_POOLREADONLY
, fmt
, ap
);
715 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
716 "block size out of range or does not match"));
717 zfs_verror(hdl
, EZFS_BADPROP
, fmt
, ap
);
720 zfs_verror(hdl
, EZFS_ACTIVE_POOL
, fmt
, ap
);
722 case ZFS_ERR_CHECKPOINT_EXISTS
:
723 zfs_verror(hdl
, EZFS_CHECKPOINT_EXISTS
, fmt
, ap
);
725 case ZFS_ERR_DISCARDING_CHECKPOINT
:
726 zfs_verror(hdl
, EZFS_DISCARDING_CHECKPOINT
, fmt
, ap
);
728 case ZFS_ERR_NO_CHECKPOINT
:
729 zfs_verror(hdl
, EZFS_NO_CHECKPOINT
, fmt
, ap
);
731 case ZFS_ERR_DEVRM_IN_PROGRESS
:
732 zfs_verror(hdl
, EZFS_DEVRM_IN_PROGRESS
, fmt
, ap
);
734 case ZFS_ERR_VDEV_TOO_BIG
:
735 zfs_verror(hdl
, EZFS_VDEV_TOO_BIG
, fmt
, ap
);
737 case ZFS_ERR_EXPORT_IN_PROGRESS
:
738 zfs_verror(hdl
, EZFS_EXPORT_IN_PROGRESS
, fmt
, ap
);
740 case ZFS_ERR_RESILVER_IN_PROGRESS
:
741 zfs_verror(hdl
, EZFS_RESILVERING
, fmt
, ap
);
743 case ZFS_ERR_REBUILD_IN_PROGRESS
:
744 zfs_verror(hdl
, EZFS_REBUILDING
, fmt
, ap
);
746 case ZFS_ERR_BADPROP
:
747 zfs_verror(hdl
, EZFS_BADPROP
, fmt
, ap
);
749 case ZFS_ERR_VDEV_NOTSUP
:
750 zfs_verror(hdl
, EZFS_VDEV_NOTSUP
, fmt
, ap
);
752 case ZFS_ERR_IOC_CMD_UNAVAIL
:
753 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
, "the loaded zfs "
754 "module does not support this operation. A reboot may "
755 "be required to enable this operation."));
756 zfs_verror(hdl
, EZFS_IOC_NOTSUPPORTED
, fmt
, ap
);
758 case ZFS_ERR_IOC_ARG_UNAVAIL
:
759 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
, "the loaded zfs "
760 "module does not support an option for this operation. "
761 "A reboot may be required to enable this option."));
762 zfs_verror(hdl
, EZFS_IOC_NOTSUPPORTED
, fmt
, ap
);
764 case ZFS_ERR_IOC_ARG_REQUIRED
:
765 case ZFS_ERR_IOC_ARG_BADTYPE
:
766 zfs_verror(hdl
, EZFS_IOC_NOTSUPPORTED
, fmt
, ap
);
768 case ZFS_ERR_RAIDZ_EXPAND_IN_PROGRESS
:
769 zfs_verror(hdl
, EZFS_RAIDZ_EXPAND_IN_PROGRESS
, fmt
, ap
);
772 zfs_error_aux(hdl
, "%s", strerror(error
));
773 zfs_verror(hdl
, EZFS_UNKNOWN
, fmt
, ap
);
781 * Display an out of memory error message and abort the current program.
784 no_memory(libzfs_handle_t
*hdl
)
786 return (zfs_error(hdl
, EZFS_NOMEM
, "internal error"));
790 * A safe form of malloc() which will die if the allocation fails.
793 zfs_alloc(libzfs_handle_t
*hdl
, size_t size
)
797 if ((data
= calloc(1, size
)) == NULL
)
798 (void) no_memory(hdl
);
804 * A safe form of asprintf() which will die if the allocation fails.
807 zfs_asprintf(libzfs_handle_t
*hdl
, const char *fmt
, ...)
815 err
= vasprintf(&ret
, fmt
, ap
);
820 (void) no_memory(hdl
);
828 * A safe form of realloc(), which also zeroes newly allocated space.
831 zfs_realloc(libzfs_handle_t
*hdl
, void *ptr
, size_t oldsize
, size_t newsize
)
835 if ((ret
= realloc(ptr
, newsize
)) == NULL
) {
836 (void) no_memory(hdl
);
840 memset((char *)ret
+ oldsize
, 0, newsize
- oldsize
);
845 * A safe form of strdup() which will die if the allocation fails.
848 zfs_strdup(libzfs_handle_t
*hdl
, const char *str
)
852 if ((ret
= strdup(str
)) == NULL
)
853 (void) no_memory(hdl
);
859 libzfs_print_on_error(libzfs_handle_t
*hdl
, boolean_t printerr
)
861 hdl
->libzfs_printerr
= printerr
;
865 * Read lines from an open file descriptor and store them in an array of
866 * strings until EOF. lines[] will be allocated and populated with all the
867 * lines read. All newlines are replaced with NULL terminators for
868 * convenience. lines[] must be freed after use with libzfs_free_str_array().
870 * Returns the number of lines read.
873 libzfs_read_stdout_from_fd(int fd
, char **lines
[])
880 char **tmp_lines
= NULL
, **tmp
;
882 fp
= fdopen(fd
, "r");
887 while (getline(&line
, &len
, fp
) != -1) {
888 tmp
= realloc(tmp_lines
, sizeof (*tmp_lines
) * (lines_cnt
+ 1));
890 /* Return the lines we were able to process */
895 /* Remove newline if not EOF */
896 if (line
[strlen(line
) - 1] == '\n')
897 line
[strlen(line
) - 1] = '\0';
899 tmp_lines
[lines_cnt
] = strdup(line
);
900 if (tmp_lines
[lines_cnt
] == NULL
)
911 libzfs_run_process_impl(const char *path
, char *argv
[], char *env
[], int flags
,
912 char **lines
[], int *lines_cnt
)
915 int error
, devnull_fd
;
919 * Setup a pipe between our child and parent process if we're
922 if (lines
!= NULL
&& pipe2(link
, O_NONBLOCK
| O_CLOEXEC
) == -1)
928 devnull_fd
= open("/dev/null", O_WRONLY
| O_CLOEXEC
);
933 if (!(flags
& STDOUT_VERBOSE
) && (lines
== NULL
))
934 (void) dup2(devnull_fd
, STDOUT_FILENO
);
935 else if (lines
!= NULL
) {
936 /* Save the output to lines[] */
937 dup2(link
[1], STDOUT_FILENO
);
940 if (!(flags
& STDERR_VERBOSE
))
941 (void) dup2(devnull_fd
, STDERR_FILENO
);
943 if (flags
& NO_DEFAULT_PATH
) {
947 execve(path
, argv
, env
);
952 execvpe(path
, argv
, env
);
956 } else if (pid
> 0) {
960 while ((error
= waitpid(pid
, &status
, 0)) == -1 &&
963 if (error
< 0 || !WIFEXITED(status
))
968 *lines_cnt
= libzfs_read_stdout_from_fd(link
[0], lines
);
970 return (WEXITSTATUS(status
));
977 libzfs_run_process(const char *path
, char *argv
[], int flags
)
979 return (libzfs_run_process_impl(path
, argv
, NULL
, flags
, NULL
, NULL
));
983 * Run a command and store its stdout lines in an array of strings (lines[]).
984 * lines[] is allocated and populated for you, and the number of lines is set in
985 * lines_cnt. lines[] must be freed after use with libzfs_free_str_array().
986 * All newlines (\n) in lines[] are terminated for convenience.
989 libzfs_run_process_get_stdout(const char *path
, char *argv
[], char *env
[],
990 char **lines
[], int *lines_cnt
)
992 return (libzfs_run_process_impl(path
, argv
, env
, 0, lines
, lines_cnt
));
996 * Same as libzfs_run_process_get_stdout(), but run without $PATH set. This
997 * means that *path needs to be the full path to the executable.
1000 libzfs_run_process_get_stdout_nopath(const char *path
, char *argv
[],
1001 char *env
[], char **lines
[], int *lines_cnt
)
1003 return (libzfs_run_process_impl(path
, argv
, env
, NO_DEFAULT_PATH
,
1008 * Free an array of strings. Free both the strings contained in the array and
1012 libzfs_free_str_array(char **strs
, int count
)
1014 while (--count
>= 0)
1021 * Returns 1 if environment variable is set to "YES", "yes", "ON", "on", or
1022 * a non-zero number.
1024 * Returns 0 otherwise.
1027 libzfs_envvar_is_set(const char *envvar
)
1029 char *env
= getenv(envvar
);
1030 return (env
&& (strtoul(env
, NULL
, 0) > 0 ||
1031 (!strncasecmp(env
, "YES", 3) && strnlen(env
, 4) == 3) ||
1032 (!strncasecmp(env
, "ON", 2) && strnlen(env
, 3) == 2)));
1038 libzfs_handle_t
*hdl
;
1042 if ((error
= libzfs_load_module()) != 0) {
1047 if ((hdl
= calloc(1, sizeof (libzfs_handle_t
))) == NULL
) {
1051 if (regcomp(&hdl
->libzfs_urire
, URI_REGEX
, 0) != 0) {
1056 if ((hdl
->libzfs_fd
= open(ZFS_DEV
, O_RDWR
|O_EXCL
|O_CLOEXEC
)) < 0) {
1061 if (libzfs_core_init() != 0) {
1062 (void) close(hdl
->libzfs_fd
);
1069 zpool_feature_init();
1071 libzfs_mnttab_init(hdl
);
1074 if (getenv("ZFS_PROP_DEBUG") != NULL
) {
1075 hdl
->libzfs_prop_debug
= B_TRUE
;
1077 if ((env
= getenv("ZFS_SENDRECV_MAX_NVLIST")) != NULL
) {
1078 if ((error
= zfs_nicestrtonum(hdl
, env
,
1079 &hdl
->libzfs_max_nvlist
))) {
1081 (void) close(hdl
->libzfs_fd
);
1086 hdl
->libzfs_max_nvlist
= (SPA_MAXBLOCKSIZE
* 4);
1090 * For testing, remove some settable properties and features
1092 if (libzfs_envvar_is_set("ZFS_SYSFS_PROP_SUPPORT_TEST")) {
1093 zprop_desc_t
*proptbl
;
1095 proptbl
= zpool_prop_get_table();
1096 proptbl
[ZPOOL_PROP_COMMENT
].pd_zfs_mod_supported
= B_FALSE
;
1098 proptbl
= zfs_prop_get_table();
1099 proptbl
[ZFS_PROP_DNODESIZE
].pd_zfs_mod_supported
= B_FALSE
;
1101 zfeature_info_t
*ftbl
= spa_feature_table
;
1102 ftbl
[SPA_FEATURE_LARGE_BLOCKS
].fi_zfs_mod_supported
= B_FALSE
;
1109 libzfs_fini(libzfs_handle_t
*hdl
)
1111 (void) close(hdl
->libzfs_fd
);
1112 zpool_free_handles(hdl
);
1113 namespace_clear(hdl
);
1114 libzfs_mnttab_fini(hdl
);
1116 regfree(&hdl
->libzfs_urire
);
1118 #if LIBFETCH_DYNAMIC
1119 if (hdl
->libfetch
!= (void *)-1 && hdl
->libfetch
!= NULL
)
1120 (void) dlclose(hdl
->libfetch
);
1121 free(hdl
->libfetch_load_error
);
1127 zpool_get_handle(zpool_handle_t
*zhp
)
1129 return (zhp
->zpool_hdl
);
1133 zfs_get_handle(zfs_handle_t
*zhp
)
1135 return (zhp
->zfs_hdl
);
1139 zfs_get_pool_handle(const zfs_handle_t
*zhp
)
1141 return (zhp
->zpool_hdl
);
1145 * Given a name, determine whether or not it's a valid path
1146 * (starts with '/' or "./"). If so, walk the mnttab trying
1147 * to match the device number. If not, treat the path as an
1148 * fs/vol/snap/bkmark name.
1151 zfs_path_to_zhandle(libzfs_handle_t
*hdl
, const char *path
, zfs_type_t argtype
)
1153 struct stat64 statbuf
;
1154 struct extmnttab entry
;
1156 if (path
[0] != '/' && strncmp(path
, "./", strlen("./")) != 0) {
1158 * It's not a valid path, assume it's a name of type 'argtype'.
1160 return (zfs_open(hdl
, path
, argtype
));
1163 if (getextmntent(path
, &entry
, &statbuf
) != 0)
1166 if (strcmp(entry
.mnt_fstype
, MNTTYPE_ZFS
) != 0) {
1167 (void) fprintf(stderr
, gettext("'%s': not a ZFS filesystem\n"),
1172 return (zfs_open(hdl
, entry
.mnt_special
, ZFS_TYPE_FILESYSTEM
));
1176 * Initialize the zc_nvlist_dst member to prepare for receiving an nvlist from
1180 zcmd_alloc_dst_nvlist(libzfs_handle_t
*hdl
, zfs_cmd_t
*zc
, size_t len
)
1184 zc
->zc_nvlist_dst_size
= len
;
1186 (uint64_t)(uintptr_t)zfs_alloc(hdl
, zc
->zc_nvlist_dst_size
);
1190 * Called when an ioctl() which returns an nvlist fails with ENOMEM. This will
1191 * expand the nvlist to the size specified in 'zc_nvlist_dst_size', which was
1192 * filled in by the kernel to indicate the actual required size.
1195 zcmd_expand_dst_nvlist(libzfs_handle_t
*hdl
, zfs_cmd_t
*zc
)
1197 free((void *)(uintptr_t)zc
->zc_nvlist_dst
);
1199 (uint64_t)(uintptr_t)zfs_alloc(hdl
, zc
->zc_nvlist_dst_size
);
1203 * Called to free the src and dst nvlists stored in the command structure.
1206 zcmd_free_nvlists(zfs_cmd_t
*zc
)
1208 free((void *)(uintptr_t)zc
->zc_nvlist_conf
);
1209 free((void *)(uintptr_t)zc
->zc_nvlist_src
);
1210 free((void *)(uintptr_t)zc
->zc_nvlist_dst
);
1211 zc
->zc_nvlist_conf
= 0;
1212 zc
->zc_nvlist_src
= 0;
1213 zc
->zc_nvlist_dst
= 0;
1217 zcmd_write_nvlist_com(libzfs_handle_t
*hdl
, uint64_t *outnv
, uint64_t *outlen
,
1222 size_t len
= fnvlist_size(nvl
);
1223 packed
= zfs_alloc(hdl
, len
);
1225 verify(nvlist_pack(nvl
, &packed
, &len
, NV_ENCODE_NATIVE
, 0) == 0);
1227 *outnv
= (uint64_t)(uintptr_t)packed
;
1232 zcmd_write_conf_nvlist(libzfs_handle_t
*hdl
, zfs_cmd_t
*zc
, nvlist_t
*nvl
)
1234 zcmd_write_nvlist_com(hdl
, &zc
->zc_nvlist_conf
,
1235 &zc
->zc_nvlist_conf_size
, nvl
);
1239 zcmd_write_src_nvlist(libzfs_handle_t
*hdl
, zfs_cmd_t
*zc
, nvlist_t
*nvl
)
1241 zcmd_write_nvlist_com(hdl
, &zc
->zc_nvlist_src
,
1242 &zc
->zc_nvlist_src_size
, nvl
);
1246 * Unpacks an nvlist from the ZFS ioctl command structure.
1249 zcmd_read_dst_nvlist(libzfs_handle_t
*hdl
, zfs_cmd_t
*zc
, nvlist_t
**nvlp
)
1251 if (nvlist_unpack((void *)(uintptr_t)zc
->zc_nvlist_dst
,
1252 zc
->zc_nvlist_dst_size
, nvlp
, 0) != 0)
1253 return (no_memory(hdl
));
1259 * ================================================================
1260 * API shared by zfs and zpool property management
1261 * ================================================================
1265 zprop_print_headers(zprop_get_cbdata_t
*cbp
, zfs_type_t type
)
1272 cbp
->cb_first
= B_FALSE
;
1273 if (cbp
->cb_scripted
)
1277 * Start with the length of the column headers.
1279 cbp
->cb_colwidths
[GET_COL_NAME
] = strlen(dgettext(TEXT_DOMAIN
, "NAME"));
1280 cbp
->cb_colwidths
[GET_COL_PROPERTY
] = strlen(dgettext(TEXT_DOMAIN
,
1282 cbp
->cb_colwidths
[GET_COL_VALUE
] = strlen(dgettext(TEXT_DOMAIN
,
1284 cbp
->cb_colwidths
[GET_COL_RECVD
] = strlen(dgettext(TEXT_DOMAIN
,
1286 cbp
->cb_colwidths
[GET_COL_SOURCE
] = strlen(dgettext(TEXT_DOMAIN
,
1289 /* first property is always NAME */
1290 assert(cbp
->cb_proplist
->pl_prop
==
1291 ((type
== ZFS_TYPE_POOL
) ? ZPOOL_PROP_NAME
:
1292 ((type
== ZFS_TYPE_VDEV
) ? VDEV_PROP_NAME
: ZFS_PROP_NAME
)));
1295 * Go through and calculate the widths for each column. For the
1296 * 'source' column, we kludge it up by taking the worst-case scenario of
1297 * inheriting from the longest name. This is acceptable because in the
1298 * majority of cases 'SOURCE' is the last column displayed, and we don't
1299 * use the width anyway. Note that the 'VALUE' column can be oversized,
1300 * if the name of the property is much longer than any values we find.
1302 for (pl
= cbp
->cb_proplist
; pl
!= NULL
; pl
= pl
->pl_next
) {
1306 if (pl
->pl_prop
!= ZPROP_USERPROP
) {
1307 const char *propname
= (type
== ZFS_TYPE_POOL
) ?
1308 zpool_prop_to_name(pl
->pl_prop
) :
1309 ((type
== ZFS_TYPE_VDEV
) ?
1310 vdev_prop_to_name(pl
->pl_prop
) :
1311 zfs_prop_to_name(pl
->pl_prop
));
1313 assert(propname
!= NULL
);
1314 len
= strlen(propname
);
1315 if (len
> cbp
->cb_colwidths
[GET_COL_PROPERTY
])
1316 cbp
->cb_colwidths
[GET_COL_PROPERTY
] = len
;
1318 assert(pl
->pl_user_prop
!= NULL
);
1319 len
= strlen(pl
->pl_user_prop
);
1320 if (len
> cbp
->cb_colwidths
[GET_COL_PROPERTY
])
1321 cbp
->cb_colwidths
[GET_COL_PROPERTY
] = len
;
1325 * 'VALUE' column. The first property is always the 'name'
1326 * property that was tacked on either by /sbin/zfs's
1327 * zfs_do_get() or when calling zprop_expand_list(), so we
1328 * ignore its width. If the user specified the name property
1329 * to display, then it will be later in the list in any case.
1331 if (pl
!= cbp
->cb_proplist
&&
1332 pl
->pl_width
> cbp
->cb_colwidths
[GET_COL_VALUE
])
1333 cbp
->cb_colwidths
[GET_COL_VALUE
] = pl
->pl_width
;
1335 /* 'RECEIVED' column. */
1336 if (pl
!= cbp
->cb_proplist
&&
1337 pl
->pl_recvd_width
> cbp
->cb_colwidths
[GET_COL_RECVD
])
1338 cbp
->cb_colwidths
[GET_COL_RECVD
] = pl
->pl_recvd_width
;
1341 * 'NAME' and 'SOURCE' columns
1343 if (pl
->pl_prop
== ((type
== ZFS_TYPE_POOL
) ? ZPOOL_PROP_NAME
:
1344 ((type
== ZFS_TYPE_VDEV
) ? VDEV_PROP_NAME
:
1345 ZFS_PROP_NAME
)) && pl
->pl_width
>
1346 cbp
->cb_colwidths
[GET_COL_NAME
]) {
1347 cbp
->cb_colwidths
[GET_COL_NAME
] = pl
->pl_width
;
1348 cbp
->cb_colwidths
[GET_COL_SOURCE
] = pl
->pl_width
+
1349 strlen(dgettext(TEXT_DOMAIN
, "inherited from"));
1354 * Now go through and print the headers.
1356 for (i
= 0; i
< ZFS_GET_NCOLS
; i
++) {
1357 switch (cbp
->cb_columns
[i
]) {
1359 title
= dgettext(TEXT_DOMAIN
, "NAME");
1361 case GET_COL_PROPERTY
:
1362 title
= dgettext(TEXT_DOMAIN
, "PROPERTY");
1365 title
= dgettext(TEXT_DOMAIN
, "VALUE");
1368 title
= dgettext(TEXT_DOMAIN
, "RECEIVED");
1370 case GET_COL_SOURCE
:
1371 title
= dgettext(TEXT_DOMAIN
, "SOURCE");
1377 if (title
!= NULL
) {
1378 if (i
== (ZFS_GET_NCOLS
- 1) ||
1379 cbp
->cb_columns
[i
+ 1] == GET_COL_NONE
)
1380 (void) printf("%s", title
);
1382 (void) printf("%-*s ",
1383 cbp
->cb_colwidths
[cbp
->cb_columns
[i
]],
1387 (void) printf("\n");
1391 * Display a single line of output, according to the settings in the callback
1395 zprop_print_one_property(const char *name
, zprop_get_cbdata_t
*cbp
,
1396 const char *propname
, const char *value
, zprop_source_t sourcetype
,
1397 const char *source
, const char *recvd_value
)
1400 const char *str
= NULL
;
1404 * Ignore those source types that the user has chosen to ignore.
1406 if ((sourcetype
& cbp
->cb_sources
) == 0)
1410 zprop_print_headers(cbp
, cbp
->cb_type
);
1412 for (i
= 0; i
< ZFS_GET_NCOLS
; i
++) {
1413 switch (cbp
->cb_columns
[i
]) {
1418 case GET_COL_PROPERTY
:
1426 case GET_COL_SOURCE
:
1427 switch (sourcetype
) {
1428 case ZPROP_SRC_NONE
:
1432 case ZPROP_SRC_DEFAULT
:
1436 case ZPROP_SRC_LOCAL
:
1440 case ZPROP_SRC_TEMPORARY
:
1444 case ZPROP_SRC_INHERITED
:
1445 (void) snprintf(buf
, sizeof (buf
),
1446 "inherited from %s", source
);
1449 case ZPROP_SRC_RECEIVED
:
1455 assert(!"unhandled zprop_source_t");
1460 str
= (recvd_value
== NULL
? "-" : recvd_value
);
1467 if (i
== (ZFS_GET_NCOLS
- 1) ||
1468 cbp
->cb_columns
[i
+ 1] == GET_COL_NONE
)
1469 (void) printf("%s", str
);
1470 else if (cbp
->cb_scripted
)
1471 (void) printf("%s\t", str
);
1473 (void) printf("%-*s ",
1474 cbp
->cb_colwidths
[cbp
->cb_columns
[i
]],
1478 (void) printf("\n");
1482 * Given a numeric suffix, convert the value into a number of bits that the
1483 * resulting value must be shifted.
1486 str2shift(libzfs_handle_t
*hdl
, const char *buf
)
1488 const char *ends
= "BKMGTPEZ";
1493 for (i
= 0; i
< strlen(ends
); i
++) {
1494 if (toupper(buf
[0]) == ends
[i
])
1497 if (i
== strlen(ends
)) {
1499 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
1500 "invalid numeric suffix '%s'"), buf
);
1505 * Allow 'G' = 'GB' = 'GiB', case-insensitively.
1506 * However, 'BB' and 'BiB' are disallowed.
1508 if (buf
[1] == '\0' ||
1509 (toupper(buf
[0]) != 'B' &&
1510 ((toupper(buf
[1]) == 'B' && buf
[2] == '\0') ||
1511 (toupper(buf
[1]) == 'I' && toupper(buf
[2]) == 'B' &&
1516 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
1517 "invalid numeric suffix '%s'"), buf
);
1522 * Convert a string of the form '100G' into a real number. Used when setting
1523 * properties or creating a volume. 'buf' is used to place an extended error
1524 * message for the caller to use.
1527 zfs_nicestrtonum(libzfs_handle_t
*hdl
, const char *value
, uint64_t *num
)
1534 /* Check to see if this looks like a number. */
1535 if ((value
[0] < '0' || value
[0] > '9') && value
[0] != '.') {
1537 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
1538 "bad numeric value '%s'"), value
);
1542 /* Rely on strtoull() to process the numeric portion. */
1544 *num
= strtoull(value
, &end
, 10);
1547 * Check for ERANGE, which indicates that the value is too large to fit
1548 * in a 64-bit value.
1550 if (errno
== ERANGE
) {
1552 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
1553 "numeric value is too large"));
1558 * If we have a decimal value, then do the computation with floating
1559 * point arithmetic. Otherwise, use standard arithmetic.
1562 double fval
= strtod(value
, &end
);
1564 if ((shift
= str2shift(hdl
, end
)) == -1)
1567 fval
*= pow(2, shift
);
1570 * UINT64_MAX is not exactly representable as a double.
1571 * The closest representation is UINT64_MAX + 1, so we
1572 * use a >= comparison instead of > for the bounds check.
1574 if (fval
>= (double)UINT64_MAX
) {
1576 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
1577 "numeric value is too large"));
1581 *num
= (uint64_t)fval
;
1583 if ((shift
= str2shift(hdl
, end
)) == -1)
1586 /* Check for overflow */
1587 if (shift
>= 64 || (*num
<< shift
) >> shift
!= *num
) {
1589 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
1590 "numeric value is too large"));
1601 * Given a propname=value nvpair to set, parse any numeric properties
1602 * (index, boolean, etc) if they are specified as strings and add the
1603 * resulting nvpair to the returned nvlist.
1605 * At the DSL layer, all properties are either 64-bit numbers or strings.
1606 * We want the user to be able to ignore this fact and specify properties
1607 * as native values (numbers, for example) or as strings (to simplify
1608 * command line utilities). This also handles converting index types
1609 * (compression, checksum, etc) from strings to their on-disk index.
1612 zprop_parse_value(libzfs_handle_t
*hdl
, nvpair_t
*elem
, int prop
,
1613 zfs_type_t type
, nvlist_t
*ret
, const char **svalp
, uint64_t *ivalp
,
1616 data_type_t datatype
= nvpair_type(elem
);
1617 zprop_type_t proptype
;
1618 const char *propname
;
1620 boolean_t isnone
= B_FALSE
;
1621 boolean_t isauto
= B_FALSE
;
1624 if (type
== ZFS_TYPE_POOL
) {
1625 proptype
= zpool_prop_get_type(prop
);
1626 propname
= zpool_prop_to_name(prop
);
1627 } else if (type
== ZFS_TYPE_VDEV
) {
1628 proptype
= vdev_prop_get_type(prop
);
1629 propname
= vdev_prop_to_name(prop
);
1631 proptype
= zfs_prop_get_type(prop
);
1632 propname
= zfs_prop_to_name(prop
);
1636 * Convert any properties to the internal DSL value types.
1642 case PROP_TYPE_STRING
:
1643 if (datatype
!= DATA_TYPE_STRING
) {
1644 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
1645 "'%s' must be a string"), nvpair_name(elem
));
1648 err
= nvpair_value_string(elem
, svalp
);
1650 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
1651 "'%s' is invalid"), nvpair_name(elem
));
1654 if (strlen(*svalp
) >= ZFS_MAXPROPLEN
) {
1655 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
1656 "'%s' is too long"), nvpair_name(elem
));
1661 case PROP_TYPE_NUMBER
:
1662 if (datatype
== DATA_TYPE_STRING
) {
1663 (void) nvpair_value_string(elem
, &value
);
1664 if (strcmp(value
, "none") == 0) {
1666 } else if (strcmp(value
, "auto") == 0) {
1668 } else if (zfs_nicestrtonum(hdl
, value
, ivalp
) != 0) {
1671 } else if (datatype
== DATA_TYPE_UINT64
) {
1672 (void) nvpair_value_uint64(elem
, ivalp
);
1674 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
1675 "'%s' must be a number"), nvpair_name(elem
));
1680 * Quota special: force 'none' and don't allow 0.
1682 if ((type
& ZFS_TYPE_DATASET
) && *ivalp
== 0 && !isnone
&&
1683 (prop
== ZFS_PROP_QUOTA
|| prop
== ZFS_PROP_REFQUOTA
)) {
1684 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
1685 "use 'none' to disable quota/refquota"));
1690 * Special handling for "*_limit=none". In this case it's not
1693 if ((type
& ZFS_TYPE_DATASET
) && isnone
&&
1694 (prop
== ZFS_PROP_FILESYSTEM_LIMIT
||
1695 prop
== ZFS_PROP_SNAPSHOT_LIMIT
)) {
1696 *ivalp
= UINT64_MAX
;
1700 * Special handling for "checksum_*=none". In this case it's not
1703 if ((type
& ZFS_TYPE_VDEV
) && isnone
&&
1704 (prop
== VDEV_PROP_CHECKSUM_N
||
1705 prop
== VDEV_PROP_CHECKSUM_T
||
1706 prop
== VDEV_PROP_IO_N
||
1707 prop
== VDEV_PROP_IO_T
)) {
1708 *ivalp
= UINT64_MAX
;
1712 * Special handling for setting 'refreservation' to 'auto'. Use
1713 * UINT64_MAX to tell the caller to use zfs_fix_auto_resv().
1714 * 'auto' is only allowed on volumes.
1718 case ZFS_PROP_REFRESERVATION
:
1719 if ((type
& ZFS_TYPE_VOLUME
) == 0) {
1720 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
1721 "'%s=auto' only allowed on "
1722 "volumes"), nvpair_name(elem
));
1725 *ivalp
= UINT64_MAX
;
1728 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
1729 "'auto' is invalid value for '%s'"),
1737 case PROP_TYPE_INDEX
:
1738 if (datatype
!= DATA_TYPE_STRING
) {
1739 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
1740 "'%s' must be a string"), nvpair_name(elem
));
1744 (void) nvpair_value_string(elem
, &value
);
1746 if (zprop_string_to_index(prop
, value
, ivalp
, type
) != 0) {
1747 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
1748 "'%s' must be one of '%s'"), propname
,
1749 zprop_values(prop
, type
));
1759 * Add the result to our return set of properties.
1761 if (*svalp
!= NULL
) {
1762 if (nvlist_add_string(ret
, propname
, *svalp
) != 0) {
1763 (void) no_memory(hdl
);
1767 if (nvlist_add_uint64(ret
, propname
, *ivalp
) != 0) {
1768 (void) no_memory(hdl
);
1775 (void) zfs_error(hdl
, EZFS_BADPROP
, errbuf
);
1780 addlist(libzfs_handle_t
*hdl
, const char *propname
, zprop_list_t
**listp
,
1783 int prop
= zprop_name_to_prop(propname
, type
);
1784 if (prop
!= ZPROP_INVAL
&& !zprop_valid_for_type(prop
, type
, B_FALSE
))
1788 * Return failure if no property table entry was found and this isn't
1789 * a user-defined property.
1791 if (prop
== ZPROP_USERPROP
&& ((type
== ZFS_TYPE_POOL
&&
1792 !zfs_prop_user(propname
) &&
1793 !zpool_prop_feature(propname
) &&
1794 !zpool_prop_unsupported(propname
)) ||
1795 ((type
== ZFS_TYPE_DATASET
) && !zfs_prop_user(propname
) &&
1796 !zfs_prop_userquota(propname
) && !zfs_prop_written(propname
)) ||
1797 ((type
== ZFS_TYPE_VDEV
) && !vdev_prop_user(propname
)))) {
1798 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
1799 "invalid property '%s'"), propname
);
1800 return (zfs_error(hdl
, EZFS_BADPROP
,
1801 dgettext(TEXT_DOMAIN
, "bad property list")));
1804 zprop_list_t
*entry
= zfs_alloc(hdl
, sizeof (*entry
));
1806 entry
->pl_prop
= prop
;
1807 if (prop
== ZPROP_USERPROP
) {
1808 entry
->pl_user_prop
= zfs_strdup(hdl
, propname
);
1809 entry
->pl_width
= strlen(propname
);
1811 entry
->pl_width
= zprop_width(prop
, &entry
->pl_fixed
,
1821 * Given a comma-separated list of properties, construct a property list
1822 * containing both user-defined and native properties. This function will
1823 * return a NULL list if 'all' is specified, which can later be expanded
1824 * by zprop_expand_list().
1827 zprop_get_list(libzfs_handle_t
*hdl
, char *props
, zprop_list_t
**listp
,
1833 * If 'all' is specified, return a NULL list.
1835 if (strcmp(props
, "all") == 0)
1839 * If no props were specified, return an error.
1841 if (props
[0] == '\0') {
1842 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
1843 "no properties specified"));
1844 return (zfs_error(hdl
, EZFS_BADPROP
, dgettext(TEXT_DOMAIN
,
1845 "bad property list")));
1848 for (char *p
; (p
= strsep(&props
, ",")); )
1849 if (strcmp(p
, "space") == 0) {
1850 static const char *const spaceprops
[] = {
1851 "name", "avail", "used", "usedbysnapshots",
1852 "usedbydataset", "usedbyrefreservation",
1856 for (int i
= 0; i
< ARRAY_SIZE(spaceprops
); i
++) {
1857 if (addlist(hdl
, spaceprops
[i
], listp
, type
))
1859 listp
= &(*listp
)->pl_next
;
1862 if (addlist(hdl
, p
, listp
, type
))
1864 listp
= &(*listp
)->pl_next
;
1871 zprop_free_list(zprop_list_t
*pl
)
1875 while (pl
!= NULL
) {
1877 free(pl
->pl_user_prop
);
1883 typedef struct expand_data
{
1884 zprop_list_t
**last
;
1885 libzfs_handle_t
*hdl
;
1890 zprop_expand_list_cb(int prop
, void *cb
)
1892 zprop_list_t
*entry
;
1893 expand_data_t
*edp
= cb
;
1895 entry
= zfs_alloc(edp
->hdl
, sizeof (zprop_list_t
));
1897 entry
->pl_prop
= prop
;
1898 entry
->pl_width
= zprop_width(prop
, &entry
->pl_fixed
, edp
->type
);
1899 entry
->pl_all
= B_TRUE
;
1901 *(edp
->last
) = entry
;
1902 edp
->last
= &entry
->pl_next
;
1904 return (ZPROP_CONT
);
1908 zprop_expand_list(libzfs_handle_t
*hdl
, zprop_list_t
**plp
, zfs_type_t type
)
1910 zprop_list_t
*entry
;
1911 zprop_list_t
**last
;
1916 * If this is the very first time we've been called for an 'all'
1917 * specification, expand the list to include all native
1926 if (zprop_iter_common(zprop_expand_list_cb
, &exp
, B_FALSE
,
1927 B_FALSE
, type
) == ZPROP_INVAL
)
1931 * Add 'name' to the beginning of the list, which is handled
1934 entry
= zfs_alloc(hdl
, sizeof (zprop_list_t
));
1935 entry
->pl_prop
= ((type
== ZFS_TYPE_POOL
) ? ZPOOL_PROP_NAME
:
1936 ((type
== ZFS_TYPE_VDEV
) ? VDEV_PROP_NAME
: ZFS_PROP_NAME
));
1937 entry
->pl_width
= zprop_width(entry
->pl_prop
,
1938 &entry
->pl_fixed
, type
);
1939 entry
->pl_all
= B_TRUE
;
1940 entry
->pl_next
= *plp
;
1947 zprop_iter(zprop_func func
, void *cb
, boolean_t show_all
, boolean_t ordered
,
1950 return (zprop_iter_common(func
, cb
, show_all
, ordered
, type
));
1954 zfs_version_userland(void)
1956 return (ZFS_META_ALIAS
);
1960 * Prints both zfs userland and kernel versions
1961 * Returns 0 on success, and -1 on error
1964 zfs_version_print(void)
1966 (void) puts(ZFS_META_ALIAS
);
1968 char *kver
= zfs_version_kernel();
1970 fprintf(stderr
, "zfs_version_kernel() failed: %s\n",
1975 (void) printf("zfs-kmod-%s\n", kver
);
1981 * Return 1 if the user requested ANSI color output, and our terminal supports
1982 * it. Return 0 for no color.
1987 static int use_color
= -1;
1993 * For each zpool invocation, we do a single check to see if we should
1994 * be using color or not, and cache that value for the lifetime of the
1995 * the zpool command. That makes it cheap to call use_color() when
1996 * we're printing with color. We assume that the settings are not going
1997 * to change during the invocation of a zpool command (the user isn't
1998 * going to change the ZFS_COLOR value while zpool is running, for
2001 if (use_color
!= -1) {
2003 * We've already figured out if we should be using color or
2004 * not. Return the cached value.
2009 term
= getenv("TERM");
2011 * The user sets the ZFS_COLOR env var set to enable zpool ANSI color
2012 * output. However if NO_COLOR is set (https://no-color.org/) then
2013 * don't use it. Also, don't use color if terminal doesn't support
2016 if (libzfs_envvar_is_set("ZFS_COLOR") &&
2017 !libzfs_envvar_is_set("NO_COLOR") &&
2018 isatty(STDOUT_FILENO
) && term
&& strcmp("dumb", term
) != 0 &&
2019 strcmp("unknown", term
) != 0) {
2020 /* Color supported */
2030 * The functions color_start() and color_end() are used for when you want
2031 * to colorize a block of text.
2034 * color_start(ANSI_RED)
2040 color_start(const char *color
)
2042 if (color
&& use_color()) {
2043 fputs(color
, stdout
);
2052 fputs(ANSI_RESET
, stdout
);
2059 * printf() with a color. If color is NULL, then do a normal printf.
2062 printf_color(const char *color
, const char *format
, ...)
2070 va_start(aptr
, format
);
2071 rc
= vprintf(format
, aptr
);
2080 /* PATH + 5 env vars + a NULL entry = 7 */
2081 #define ZPOOL_VDEV_SCRIPT_ENV_COUNT 7
2084 * There's a few places where ZFS will call external scripts (like the script
2085 * in zpool.d/ and `zfs_prepare_disk`). These scripts are called with a
2086 * reduced $PATH, and some vdev specific environment vars set. This function
2087 * will allocate an populate the environment variable array that is passed to
2088 * these scripts. The user must free the arrays with zpool_vdev_free_env() when
2091 * The following env vars will be set (but value could be blank):
2096 * VDEV_ENC_SYSFS_PATH
2098 * In addition, you can set an optional environment variable named 'opt_key'
2099 * to 'opt_val' if you want.
2101 * Returns allocated env[] array on success, NULL otherwise.
2104 zpool_vdev_script_alloc_env(const char *pool_name
,
2105 const char *vdev_path
, const char *vdev_upath
,
2106 const char *vdev_enc_sysfs_path
, const char *opt_key
, const char *opt_val
)
2111 env
= calloc(ZPOOL_VDEV_SCRIPT_ENV_COUNT
, sizeof (*env
));
2115 env
[0] = strdup("PATH=/bin:/sbin:/usr/bin:/usr/sbin");
2119 /* Setup our custom environment variables */
2120 rc
= asprintf(&env
[1], "POOL_NAME=%s", pool_name
? pool_name
: "");
2126 rc
= asprintf(&env
[2], "VDEV_PATH=%s", vdev_path
? vdev_path
: "");
2132 rc
= asprintf(&env
[3], "VDEV_UPATH=%s", vdev_upath
? vdev_upath
: "");
2138 rc
= asprintf(&env
[4], "VDEV_ENC_SYSFS_PATH=%s",
2139 vdev_enc_sysfs_path
? vdev_enc_sysfs_path
: "");
2145 if (opt_key
!= NULL
) {
2146 rc
= asprintf(&env
[5], "%s=%s", opt_key
,
2147 opt_val
? opt_val
: "");
2157 for (int i
= 0; i
< ZPOOL_VDEV_SCRIPT_ENV_COUNT
; i
++)
2166 * Free the env[] array that was allocated by zpool_vdev_script_alloc_env().
2169 zpool_vdev_script_free_env(char **env
)
2171 for (int i
= 0; i
< ZPOOL_VDEV_SCRIPT_ENV_COUNT
; i
++)
2178 * Prepare a disk by (optionally) running a program before labeling the disk.
2179 * This can be useful for installing disk firmware or doing some pre-flight
2180 * checks on the disk before it becomes part of the pool. The program run is
2181 * located at ZFSEXECDIR/zfs_prepare_disk
2182 * (E.x: /usr/local/libexec/zfs/zfs_prepare_disk).
2184 * Return 0 on success, non-zero on failure.
2187 zpool_prepare_disk(zpool_handle_t
*zhp
, nvlist_t
*vdev_nv
,
2188 const char *prepare_str
, char **lines
[], int *lines_cnt
)
2190 const char *script_path
= ZFSEXECDIR
"/zfs_prepare_disk";
2191 const char *pool_name
;
2194 /* Path to script and a NULL entry */
2195 char *argv
[2] = {(char *)script_path
};
2197 const char *path
= NULL
, *enc_sysfs_path
= NULL
;
2201 if (access(script_path
, X_OK
) != 0) {
2202 /* No script, nothing to do */
2206 (void) nvlist_lookup_string(vdev_nv
, ZPOOL_CONFIG_PATH
, &path
);
2207 (void) nvlist_lookup_string(vdev_nv
, ZPOOL_CONFIG_VDEV_ENC_SYSFS_PATH
,
2210 upath
= zfs_get_underlying_path(path
);
2211 pool_name
= zhp
? zpool_get_name(zhp
) : NULL
;
2213 env
= zpool_vdev_script_alloc_env(pool_name
, path
, upath
,
2214 enc_sysfs_path
, "VDEV_PREPARE", prepare_str
);
2222 rc
= libzfs_run_process_get_stdout(script_path
, argv
, env
, lines
,
2225 zpool_vdev_script_free_env(env
);
2231 * Optionally run a script and then label a disk. The script can be used to
2232 * prepare a disk for inclusion into the pool. For example, it might update
2233 * the disk's firmware or check its health.
2235 * The 'name' provided is the short name, stripped of any leading
2236 * /dev path, and is passed to zpool_label_disk. vdev_nv is the nvlist for
2237 * the vdev. prepare_str is a string that gets passed as the VDEV_PREPARE
2238 * env variable to the script.
2240 * The following env vars are passed to the script:
2242 * POOL_NAME: The pool name (blank during zpool create)
2243 * VDEV_PREPARE: Reason why the disk is being prepared for inclusion:
2244 * "create", "add", "replace", or "autoreplace"
2245 * VDEV_PATH: Path to the disk
2246 * VDEV_UPATH: One of the 'underlying paths' to the disk. This is
2247 * useful for DM devices.
2248 * VDEV_ENC_SYSFS_PATH: Path to the disk's enclosure sysfs path, if available.
2250 * Note, some of these values can be blank.
2252 * Return 0 on success, non-zero otherwise.
2255 zpool_prepare_and_label_disk(libzfs_handle_t
*hdl
, zpool_handle_t
*zhp
,
2256 const char *name
, nvlist_t
*vdev_nv
, const char *prepare_str
,
2257 char **lines
[], int *lines_cnt
)
2260 char vdev_path
[MAXPATHLEN
];
2261 (void) snprintf(vdev_path
, sizeof (vdev_path
), "%s/%s", DISK_ROOT
,
2264 /* zhp will be NULL when creating a pool */
2265 rc
= zpool_prepare_disk(zhp
, vdev_nv
, prepare_str
, lines
, lines_cnt
);
2269 rc
= zpool_label_disk(hdl
, zhp
, name
);