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 http://www.opensolaris.org/os/licensing.
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 (c) 2012 by Delphix. All rights reserved.
28 * Internal utility routines for the ZFS library.
42 #include <sys/mnttab.h>
43 #include <sys/mntent.h>
44 #include <sys/types.h>
48 #include <libzfs_core.h>
50 #include "libzfs_impl.h"
52 #include "zfeature_common.h"
55 libzfs_errno(libzfs_handle_t
*hdl
)
57 return (hdl
->libzfs_error
);
61 libzfs_error_action(libzfs_handle_t
*hdl
)
63 return (hdl
->libzfs_action
);
67 libzfs_error_description(libzfs_handle_t
*hdl
)
69 if (hdl
->libzfs_desc
[0] != '\0')
70 return (hdl
->libzfs_desc
);
72 switch (hdl
->libzfs_error
) {
74 return (dgettext(TEXT_DOMAIN
, "out of memory"));
76 return (dgettext(TEXT_DOMAIN
, "invalid property value"));
77 case EZFS_PROPREADONLY
:
78 return (dgettext(TEXT_DOMAIN
, "read-only property"));
80 return (dgettext(TEXT_DOMAIN
, "property doesn't apply to "
81 "datasets of this type"));
82 case EZFS_PROPNONINHERIT
:
83 return (dgettext(TEXT_DOMAIN
, "property cannot be inherited"));
85 return (dgettext(TEXT_DOMAIN
, "invalid quota or reservation"));
87 return (dgettext(TEXT_DOMAIN
, "operation not applicable to "
88 "datasets of this type"));
90 return (dgettext(TEXT_DOMAIN
, "pool or dataset is busy"));
92 return (dgettext(TEXT_DOMAIN
, "pool or dataset exists"));
94 return (dgettext(TEXT_DOMAIN
, "no such pool or dataset"));
96 return (dgettext(TEXT_DOMAIN
, "invalid backup stream"));
98 return (dgettext(TEXT_DOMAIN
, "dataset is read-only"));
100 return (dgettext(TEXT_DOMAIN
, "volume size exceeds limit for "
102 case EZFS_INVALIDNAME
:
103 return (dgettext(TEXT_DOMAIN
, "invalid name"));
104 case EZFS_BADRESTORE
:
105 return (dgettext(TEXT_DOMAIN
, "unable to restore to "
108 return (dgettext(TEXT_DOMAIN
, "backup failed"));
110 return (dgettext(TEXT_DOMAIN
, "invalid target vdev"));
112 return (dgettext(TEXT_DOMAIN
, "no such device in pool"));
114 return (dgettext(TEXT_DOMAIN
, "invalid device"));
115 case EZFS_NOREPLICAS
:
116 return (dgettext(TEXT_DOMAIN
, "no valid replicas"));
117 case EZFS_RESILVERING
:
118 return (dgettext(TEXT_DOMAIN
, "currently resilvering"));
119 case EZFS_BADVERSION
:
120 return (dgettext(TEXT_DOMAIN
, "unsupported version or "
122 case EZFS_POOLUNAVAIL
:
123 return (dgettext(TEXT_DOMAIN
, "pool is unavailable"));
124 case EZFS_DEVOVERFLOW
:
125 return (dgettext(TEXT_DOMAIN
, "too many devices in one vdev"));
127 return (dgettext(TEXT_DOMAIN
, "must be an absolute path"));
128 case EZFS_CROSSTARGET
:
129 return (dgettext(TEXT_DOMAIN
, "operation crosses datasets or "
132 return (dgettext(TEXT_DOMAIN
, "dataset in use by local zone"));
133 case EZFS_MOUNTFAILED
:
134 return (dgettext(TEXT_DOMAIN
, "mount failed"));
135 case EZFS_UMOUNTFAILED
:
136 return (dgettext(TEXT_DOMAIN
, "umount failed"));
137 case EZFS_UNSHARENFSFAILED
:
138 return (dgettext(TEXT_DOMAIN
, "unshare(1M) failed"));
139 case EZFS_SHARENFSFAILED
:
140 return (dgettext(TEXT_DOMAIN
, "share(1M) failed"));
141 case EZFS_UNSHARESMBFAILED
:
142 return (dgettext(TEXT_DOMAIN
, "smb remove share failed"));
143 case EZFS_SHARESMBFAILED
:
144 return (dgettext(TEXT_DOMAIN
, "smb add share failed"));
146 return (dgettext(TEXT_DOMAIN
, "permission denied"));
148 return (dgettext(TEXT_DOMAIN
, "out of space"));
150 return (dgettext(TEXT_DOMAIN
, "bad address"));
152 return (dgettext(TEXT_DOMAIN
, "I/O error"));
154 return (dgettext(TEXT_DOMAIN
, "signal received"));
156 return (dgettext(TEXT_DOMAIN
, "device is reserved as a hot "
158 case EZFS_INVALCONFIG
:
159 return (dgettext(TEXT_DOMAIN
, "invalid vdev configuration"));
161 return (dgettext(TEXT_DOMAIN
, "recursive dataset dependency"));
163 return (dgettext(TEXT_DOMAIN
, "no history available"));
165 return (dgettext(TEXT_DOMAIN
, "failed to retrieve "
167 case EZFS_POOL_NOTSUP
:
168 return (dgettext(TEXT_DOMAIN
, "operation not supported "
169 "on this type of pool"));
170 case EZFS_POOL_INVALARG
:
171 return (dgettext(TEXT_DOMAIN
, "invalid argument for "
172 "this pool operation"));
173 case EZFS_NAMETOOLONG
:
174 return (dgettext(TEXT_DOMAIN
, "dataset name is too long"));
175 case EZFS_OPENFAILED
:
176 return (dgettext(TEXT_DOMAIN
, "open failed"));
178 return (dgettext(TEXT_DOMAIN
,
179 "disk capacity information could not be retrieved"));
180 case EZFS_LABELFAILED
:
181 return (dgettext(TEXT_DOMAIN
, "write of label failed"));
183 return (dgettext(TEXT_DOMAIN
, "invalid user/group"));
185 return (dgettext(TEXT_DOMAIN
, "invalid permission"));
186 case EZFS_BADPERMSET
:
187 return (dgettext(TEXT_DOMAIN
, "invalid permission set name"));
188 case EZFS_NODELEGATION
:
189 return (dgettext(TEXT_DOMAIN
, "delegated administration is "
190 "disabled on pool"));
192 return (dgettext(TEXT_DOMAIN
, "invalid or missing cache file"));
194 return (dgettext(TEXT_DOMAIN
, "device is in use as a cache"));
195 case EZFS_VDEVNOTSUP
:
196 return (dgettext(TEXT_DOMAIN
, "vdev specification is not "
199 return (dgettext(TEXT_DOMAIN
, "operation not supported "
201 case EZFS_ACTIVE_SPARE
:
202 return (dgettext(TEXT_DOMAIN
, "pool has active shared spare "
204 case EZFS_UNPLAYED_LOGS
:
205 return (dgettext(TEXT_DOMAIN
, "log device has unplayed intent "
207 case EZFS_REFTAG_RELE
:
208 return (dgettext(TEXT_DOMAIN
, "no such tag on this dataset"));
209 case EZFS_REFTAG_HOLD
:
210 return (dgettext(TEXT_DOMAIN
, "tag already exists on this "
212 case EZFS_TAGTOOLONG
:
213 return (dgettext(TEXT_DOMAIN
, "tag too long"));
214 case EZFS_PIPEFAILED
:
215 return (dgettext(TEXT_DOMAIN
, "pipe create failed"));
216 case EZFS_THREADCREATEFAILED
:
217 return (dgettext(TEXT_DOMAIN
, "thread create failed"));
218 case EZFS_POSTSPLIT_ONLINE
:
219 return (dgettext(TEXT_DOMAIN
, "disk was split from this pool "
222 return (dgettext(TEXT_DOMAIN
, "currently scrubbing; "
223 "use 'zpool scrub -s' to cancel current scrub"));
225 return (dgettext(TEXT_DOMAIN
, "there is no active scrub"));
227 return (dgettext(TEXT_DOMAIN
, "unable to generate diffs"));
229 return (dgettext(TEXT_DOMAIN
, "invalid diff data"));
230 case EZFS_POOLREADONLY
:
231 return (dgettext(TEXT_DOMAIN
, "pool is read-only"));
233 return (dgettext(TEXT_DOMAIN
, "unknown error"));
235 assert(hdl
->libzfs_error
== 0);
236 return (dgettext(TEXT_DOMAIN
, "no error"));
242 zfs_error_aux(libzfs_handle_t
*hdl
, const char *fmt
, ...)
248 (void) vsnprintf(hdl
->libzfs_desc
, sizeof (hdl
->libzfs_desc
),
250 hdl
->libzfs_desc_active
= 1;
256 zfs_verror(libzfs_handle_t
*hdl
, int error
, const char *fmt
, va_list ap
)
258 (void) vsnprintf(hdl
->libzfs_action
, sizeof (hdl
->libzfs_action
),
260 hdl
->libzfs_error
= error
;
262 if (hdl
->libzfs_desc_active
)
263 hdl
->libzfs_desc_active
= 0;
265 hdl
->libzfs_desc
[0] = '\0';
267 if (hdl
->libzfs_printerr
) {
268 if (error
== EZFS_UNKNOWN
) {
269 (void) fprintf(stderr
, dgettext(TEXT_DOMAIN
, "internal "
270 "error: %s\n"), libzfs_error_description(hdl
));
274 (void) fprintf(stderr
, "%s: %s\n", hdl
->libzfs_action
,
275 libzfs_error_description(hdl
));
276 if (error
== EZFS_NOMEM
)
282 zfs_error(libzfs_handle_t
*hdl
, int error
, const char *msg
)
284 return (zfs_error_fmt(hdl
, error
, "%s", msg
));
289 zfs_error_fmt(libzfs_handle_t
*hdl
, int error
, const char *fmt
, ...)
295 zfs_verror(hdl
, error
, fmt
, ap
);
303 zfs_common_error(libzfs_handle_t
*hdl
, int error
, const char *fmt
,
309 zfs_verror(hdl
, EZFS_PERM
, fmt
, ap
);
313 zfs_verror(hdl
, EZFS_NODELEGATION
, fmt
, ap
);
317 zfs_verror(hdl
, EZFS_IO
, fmt
, ap
);
321 zfs_verror(hdl
, EZFS_FAULT
, fmt
, ap
);
325 zfs_verror(hdl
, EZFS_INTR
, fmt
, ap
);
333 zfs_standard_error(libzfs_handle_t
*hdl
, int error
, const char *msg
)
335 return (zfs_standard_error_fmt(hdl
, error
, "%s", msg
));
340 zfs_standard_error_fmt(libzfs_handle_t
*hdl
, int error
, const char *fmt
, ...)
346 if (zfs_common_error(hdl
, error
, fmt
, ap
) != 0) {
355 zfs_verror(hdl
, EZFS_IO
, fmt
, ap
);
359 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
360 "dataset does not exist"));
361 zfs_verror(hdl
, EZFS_NOENT
, fmt
, ap
);
366 zfs_verror(hdl
, EZFS_NOSPC
, fmt
, ap
);
370 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
371 "dataset already exists"));
372 zfs_verror(hdl
, EZFS_EXISTS
, fmt
, ap
);
376 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
378 zfs_verror(hdl
, EZFS_BUSY
, fmt
, ap
);
381 zfs_verror(hdl
, EZFS_POOLREADONLY
, fmt
, ap
);
384 zfs_verror(hdl
, EZFS_NAMETOOLONG
, fmt
, ap
);
387 zfs_verror(hdl
, EZFS_BADVERSION
, fmt
, ap
);
390 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
391 "pool I/O is currently suspended"));
392 zfs_verror(hdl
, EZFS_POOLUNAVAIL
, fmt
, ap
);
395 zfs_error_aux(hdl
, strerror(error
));
396 zfs_verror(hdl
, EZFS_UNKNOWN
, fmt
, ap
);
405 zpool_standard_error(libzfs_handle_t
*hdl
, int error
, const char *msg
)
407 return (zpool_standard_error_fmt(hdl
, error
, "%s", msg
));
412 zpool_standard_error_fmt(libzfs_handle_t
*hdl
, int error
, const char *fmt
, ...)
418 if (zfs_common_error(hdl
, error
, fmt
, ap
) != 0) {
425 zfs_verror(hdl
, EZFS_NODEVICE
, fmt
, ap
);
430 dgettext(TEXT_DOMAIN
, "no such pool or dataset"));
431 zfs_verror(hdl
, EZFS_NOENT
, fmt
, ap
);
435 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
436 "pool already exists"));
437 zfs_verror(hdl
, EZFS_EXISTS
, fmt
, ap
);
441 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
, "pool is busy"));
442 zfs_verror(hdl
, EZFS_BUSY
, fmt
, ap
);
446 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
447 "one or more devices is currently unavailable"));
448 zfs_verror(hdl
, EZFS_BADDEV
, fmt
, ap
);
452 zfs_verror(hdl
, EZFS_DEVOVERFLOW
, fmt
, ap
);
456 zfs_verror(hdl
, EZFS_POOL_NOTSUP
, fmt
, ap
);
460 zfs_verror(hdl
, EZFS_POOL_INVALARG
, fmt
, ap
);
465 zfs_verror(hdl
, EZFS_NOSPC
, fmt
, ap
);
469 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
470 "pool I/O is currently suspended"));
471 zfs_verror(hdl
, EZFS_POOLUNAVAIL
, fmt
, ap
);
475 zfs_verror(hdl
, EZFS_POOLREADONLY
, fmt
, ap
);
479 zfs_error_aux(hdl
, strerror(error
));
480 zfs_verror(hdl
, EZFS_UNKNOWN
, fmt
, ap
);
488 * Display an out of memory error message and abort the current program.
491 no_memory(libzfs_handle_t
*hdl
)
493 return (zfs_error(hdl
, EZFS_NOMEM
, "internal error"));
497 * A safe form of malloc() which will die if the allocation fails.
500 zfs_alloc(libzfs_handle_t
*hdl
, size_t size
)
504 if ((data
= calloc(1, size
)) == NULL
)
505 (void) no_memory(hdl
);
511 * A safe form of asprintf() which will die if the allocation fails.
515 zfs_asprintf(libzfs_handle_t
*hdl
, const char *fmt
, ...)
523 err
= vasprintf(&ret
, fmt
, ap
);
528 (void) no_memory(hdl
);
534 * A safe form of realloc(), which also zeroes newly allocated space.
537 zfs_realloc(libzfs_handle_t
*hdl
, void *ptr
, size_t oldsize
, size_t newsize
)
541 if ((ret
= realloc(ptr
, newsize
)) == NULL
) {
542 (void) no_memory(hdl
);
546 bzero((char *)ret
+ oldsize
, (newsize
- oldsize
));
551 * A safe form of strdup() which will die if the allocation fails.
554 zfs_strdup(libzfs_handle_t
*hdl
, const char *str
)
558 if ((ret
= strdup(str
)) == NULL
)
559 (void) no_memory(hdl
);
565 * Convert a number to an appropriately human-readable output.
568 zfs_nicenum(uint64_t num
, char *buf
, size_t buflen
)
579 u
= " KMGTPE"[index
];
582 (void) snprintf(buf
, buflen
, "%llu", (u_longlong_t
) n
);
583 } else if ((num
& ((1ULL << 10 * index
) - 1)) == 0) {
585 * If this is an even multiple of the base, always display
586 * without any decimal precision.
588 (void) snprintf(buf
, buflen
, "%llu%c", (u_longlong_t
) n
, u
);
591 * We want to choose a precision that reflects the best choice
592 * for fitting in 5 characters. This can get rather tricky when
593 * we have numbers that are very close to an order of magnitude.
594 * For example, when displaying 10239 (which is really 9.999K),
595 * we want only a single place of precision for 10.0K. We could
596 * develop some complex heuristics for this, but it's much
597 * easier just to try each combination in turn.
600 for (i
= 2; i
>= 0; i
--) {
601 if (snprintf(buf
, buflen
, "%.*f%c", i
,
602 (double)num
/ (1ULL << 10 * index
), u
) <= 5)
609 libzfs_print_on_error(libzfs_handle_t
*hdl
, boolean_t printerr
)
611 hdl
->libzfs_printerr
= printerr
;
615 libzfs_module_loaded(const char *module
)
617 const char path_prefix
[] = "/sys/module/";
620 memcpy(path
, path_prefix
, sizeof(path_prefix
) - 1);
621 strcpy(path
+ sizeof(path_prefix
) - 1, module
);
623 return (access(path
, F_OK
) == 0);
627 libzfs_run_process(const char *path
, char *argv
[], int flags
)
634 devnull_fd
= open("/dev/null", O_WRONLY
);
639 if (!(flags
& STDOUT_VERBOSE
))
640 (void) dup2(devnull_fd
, STDOUT_FILENO
);
642 if (!(flags
& STDERR_VERBOSE
))
643 (void) dup2(devnull_fd
, STDERR_FILENO
);
647 (void) execvp(path
, argv
);
649 } else if (pid
> 0) {
652 while ((rc
= waitpid(pid
, &status
, 0)) == -1 &&
654 if (rc
< 0 || !WIFEXITED(status
))
657 return WEXITSTATUS(status
);
664 libzfs_load_module(const char *module
)
666 char *argv
[4] = {"/sbin/modprobe", "-q", (char *)module
, (char *)0};
668 if (libzfs_module_loaded(module
))
671 return libzfs_run_process("/sbin/modprobe", argv
, 0);
677 libzfs_handle_t
*hdl
;
679 if (libzfs_load_module("zfs") != 0) {
680 (void) fprintf(stderr
, gettext("Failed to load ZFS module "
681 "stack.\nLoad the module manually by running "
682 "'insmod <location>/zfs.ko' as root.\n"));
686 if ((hdl
= calloc(1, sizeof (libzfs_handle_t
))) == NULL
) {
690 if ((hdl
->libzfs_fd
= open(ZFS_DEV
, O_RDWR
)) < 0) {
691 (void) fprintf(stderr
, gettext("Unable to open %s: %s.\n"),
692 ZFS_DEV
, strerror(errno
));
694 (void) fprintf(stderr
,
695 gettext("Verify the ZFS module stack is "
696 "loaded by running '/sbin/modprobe zfs'.\n"));
702 #ifdef HAVE_SETMNTENT
703 if ((hdl
->libzfs_mnttab
= setmntent(MNTTAB
, "r")) == NULL
) {
705 if ((hdl
->libzfs_mnttab
= fopen(MNTTAB
, "r")) == NULL
) {
707 (void) close(hdl
->libzfs_fd
);
708 (void) fprintf(stderr
,
709 gettext("mtab is not present at %s.\n"), MNTTAB
);
714 hdl
->libzfs_sharetab
= fopen("/etc/dfs/sharetab", "r");
716 if (libzfs_core_init() != 0) {
717 (void) close(hdl
->libzfs_fd
);
718 (void) fclose(hdl
->libzfs_mnttab
);
719 (void) fclose(hdl
->libzfs_sharetab
);
726 zpool_feature_init();
727 libzfs_mnttab_init(hdl
);
733 libzfs_fini(libzfs_handle_t
*hdl
)
735 (void) close(hdl
->libzfs_fd
);
736 if (hdl
->libzfs_mnttab
)
737 #ifdef HAVE_SETMNTENT
738 (void) endmntent(hdl
->libzfs_mnttab
);
740 (void) fclose(hdl
->libzfs_mnttab
);
742 if (hdl
->libzfs_sharetab
)
743 (void) fclose(hdl
->libzfs_sharetab
);
744 zfs_uninit_libshare(hdl
);
745 zpool_free_handles(hdl
);
746 libzfs_fru_clear(hdl
, B_TRUE
);
747 namespace_clear(hdl
);
748 libzfs_mnttab_fini(hdl
);
754 zpool_get_handle(zpool_handle_t
*zhp
)
756 return (zhp
->zpool_hdl
);
760 zfs_get_handle(zfs_handle_t
*zhp
)
762 return (zhp
->zfs_hdl
);
766 zfs_get_pool_handle(const zfs_handle_t
*zhp
)
768 return (zhp
->zpool_hdl
);
772 * Given a name, determine whether or not it's a valid path
773 * (starts with '/' or "./"). If so, walk the mnttab trying
774 * to match the device number. If not, treat the path as an
778 zfs_path_to_zhandle(libzfs_handle_t
*hdl
, char *path
, zfs_type_t argtype
)
780 struct stat64 statbuf
;
781 struct extmnttab entry
;
784 if (path
[0] != '/' && strncmp(path
, "./", strlen("./")) != 0) {
786 * It's not a valid path, assume it's a name of type 'argtype'.
788 return (zfs_open(hdl
, path
, argtype
));
791 if (stat64(path
, &statbuf
) != 0) {
792 (void) fprintf(stderr
, "%s: %s\n", path
, strerror(errno
));
796 rewind(hdl
->libzfs_mnttab
);
797 while ((ret
= getextmntent(hdl
->libzfs_mnttab
, &entry
, 0)) == 0) {
798 if (makedevice(entry
.mnt_major
, entry
.mnt_minor
) ==
807 if (strcmp(entry
.mnt_fstype
, MNTTYPE_ZFS
) != 0) {
808 (void) fprintf(stderr
, gettext("'%s': not a ZFS filesystem\n"),
813 return (zfs_open(hdl
, entry
.mnt_special
, ZFS_TYPE_FILESYSTEM
));
817 * Append partition suffix to an otherwise fully qualified device path.
818 * This is used to generate the name the full path as its stored in
819 * ZPOOL_CONFIG_PATH for whole disk devices. On success the new length
820 * of 'path' will be returned on error a negative value is returned.
823 zfs_append_partition(char *path
, size_t max_len
)
825 int len
= strlen(path
);
827 if (strncmp(path
, UDISK_ROOT
, strlen(UDISK_ROOT
)) == 0) {
828 if (len
+ 6 >= max_len
)
831 (void) strcat(path
, "-part1");
834 if (len
+ 2 >= max_len
)
837 if (isdigit(path
[len
-1])) {
838 (void) strcat(path
, "p1");
841 (void) strcat(path
, "1");
850 * Given a shorthand device name check if a file by that name exists in any
851 * of the 'zpool_default_import_path' or ZPOOL_IMPORT_PATH directories. If
852 * one is found, store its fully qualified path in the 'path' buffer passed
853 * by the caller and return 0, otherwise return an error.
856 zfs_resolve_shortname(const char *name
, char *path
, size_t len
)
859 char *dir
, *env
, *envdup
;
861 env
= getenv("ZPOOL_IMPORT_PATH");
865 envdup
= strdup(env
);
866 dir
= strtok(envdup
, ":");
867 while (dir
&& error
) {
868 (void) snprintf(path
, len
, "%s/%s", dir
, name
);
869 error
= access(path
, F_OK
);
870 dir
= strtok(NULL
, ":");
874 for (i
= 0; i
< DEFAULT_IMPORT_PATH_SIZE
&& error
< 0; i
++) {
875 (void) snprintf(path
, len
, "%s/%s",
876 zpool_default_import_path
[i
], name
);
877 error
= access(path
, F_OK
);
881 return (error
? ENOENT
: 0);
885 * Given a shorthand device name look for a match against 'cmp_name'. This
886 * is done by checking all prefix expansions using either the default
887 * 'zpool_default_import_paths' or the ZPOOL_IMPORT_PATH environment
888 * variable. Proper partition suffixes will be appended if this is a
889 * whole disk. When a match is found 0 is returned otherwise ENOENT.
892 zfs_strcmp_shortname(char *name
, char *cmp_name
, int wholedisk
)
894 int path_len
, cmp_len
, i
= 0, error
= ENOENT
;
895 char *dir
, *env
, *envdup
= NULL
;
896 char path_name
[MAXPATHLEN
];
898 cmp_len
= strlen(cmp_name
);
899 env
= getenv("ZPOOL_IMPORT_PATH");
902 envdup
= strdup(env
);
903 dir
= strtok(envdup
, ":");
905 dir
= zpool_default_import_path
[i
];
909 /* Trim trailing directory slashes from ZPOOL_IMPORT_PATH */
910 while (dir
[strlen(dir
)-1] == '/')
911 dir
[strlen(dir
)-1] = '\0';
913 path_len
= snprintf(path_name
, MAXPATHLEN
, "%s/%s", dir
, name
);
915 path_len
= zfs_append_partition(path_name
, MAXPATHLEN
);
917 if ((path_len
== cmp_len
) && !strcmp(path_name
, cmp_name
)) {
923 dir
= strtok(NULL
, ":");
924 } else if (++i
< DEFAULT_IMPORT_PATH_SIZE
) {
925 dir
= zpool_default_import_path
[i
];
938 * Given either a shorthand or fully qualified path name look for a match
939 * against 'cmp'. The passed name will be expanded as needed for comparison
940 * purposes and redundant slashes stripped to ensure an accurate match.
943 zfs_strcmp_pathname(char *name
, char *cmp
, int wholedisk
)
945 int path_len
, cmp_len
;
946 char path_name
[MAXPATHLEN
];
947 char cmp_name
[MAXPATHLEN
];
950 /* Strip redundant slashes if one exists due to ZPOOL_IMPORT_PATH */
951 memset(cmp_name
, 0, MAXPATHLEN
);
952 dir
= strtok(cmp
, "/");
954 strcat(cmp_name
, "/");
955 strcat(cmp_name
, dir
);
956 dir
= strtok(NULL
, "/");
960 return zfs_strcmp_shortname(name
, cmp_name
, wholedisk
);
962 strncpy(path_name
, name
, MAXPATHLEN
);
963 path_len
= strlen(path_name
);
964 cmp_len
= strlen(cmp_name
);
967 path_len
= zfs_append_partition(path_name
, MAXPATHLEN
);
972 if ((path_len
!= cmp_len
) || strcmp(path_name
, cmp_name
))
979 * Initialize the zc_nvlist_dst member to prepare for receiving an nvlist from
983 zcmd_alloc_dst_nvlist(libzfs_handle_t
*hdl
, zfs_cmd_t
*zc
, size_t len
)
987 zc
->zc_nvlist_dst_size
= len
;
988 if ((zc
->zc_nvlist_dst
= (uint64_t)(uintptr_t)
989 zfs_alloc(hdl
, zc
->zc_nvlist_dst_size
)) == 0)
996 * Called when an ioctl() which returns an nvlist fails with ENOMEM. This will
997 * expand the nvlist to the size specified in 'zc_nvlist_dst_size', which was
998 * filled in by the kernel to indicate the actual required size.
1001 zcmd_expand_dst_nvlist(libzfs_handle_t
*hdl
, zfs_cmd_t
*zc
)
1003 free((void *)(uintptr_t)zc
->zc_nvlist_dst
);
1004 if ((zc
->zc_nvlist_dst
= (uint64_t)(uintptr_t)
1005 zfs_alloc(hdl
, zc
->zc_nvlist_dst_size
)) == 0)
1012 * Called to free the src and dst nvlists stored in the command structure.
1015 zcmd_free_nvlists(zfs_cmd_t
*zc
)
1017 free((void *)(uintptr_t)zc
->zc_nvlist_conf
);
1018 free((void *)(uintptr_t)zc
->zc_nvlist_src
);
1019 free((void *)(uintptr_t)zc
->zc_nvlist_dst
);
1023 zcmd_write_nvlist_com(libzfs_handle_t
*hdl
, uint64_t *outnv
, uint64_t *outlen
,
1029 verify(nvlist_size(nvl
, &len
, NV_ENCODE_NATIVE
) == 0);
1031 if ((packed
= zfs_alloc(hdl
, len
)) == NULL
)
1034 verify(nvlist_pack(nvl
, &packed
, &len
, NV_ENCODE_NATIVE
, 0) == 0);
1036 *outnv
= (uint64_t)(uintptr_t)packed
;
1043 zcmd_write_conf_nvlist(libzfs_handle_t
*hdl
, zfs_cmd_t
*zc
, nvlist_t
*nvl
)
1045 return (zcmd_write_nvlist_com(hdl
, &zc
->zc_nvlist_conf
,
1046 &zc
->zc_nvlist_conf_size
, nvl
));
1050 zcmd_write_src_nvlist(libzfs_handle_t
*hdl
, zfs_cmd_t
*zc
, nvlist_t
*nvl
)
1052 return (zcmd_write_nvlist_com(hdl
, &zc
->zc_nvlist_src
,
1053 &zc
->zc_nvlist_src_size
, nvl
));
1057 * Unpacks an nvlist from the ZFS ioctl command structure.
1060 zcmd_read_dst_nvlist(libzfs_handle_t
*hdl
, zfs_cmd_t
*zc
, nvlist_t
**nvlp
)
1062 if (nvlist_unpack((void *)(uintptr_t)zc
->zc_nvlist_dst
,
1063 zc
->zc_nvlist_dst_size
, nvlp
, 0) != 0)
1064 return (no_memory(hdl
));
1070 zfs_ioctl(libzfs_handle_t
*hdl
, int request
, zfs_cmd_t
*zc
)
1072 return (ioctl(hdl
->libzfs_fd
, request
, zc
));
1076 * ================================================================
1077 * API shared by zfs and zpool property management
1078 * ================================================================
1082 zprop_print_headers(zprop_get_cbdata_t
*cbp
, zfs_type_t type
)
1084 zprop_list_t
*pl
= cbp
->cb_proplist
;
1089 cbp
->cb_first
= B_FALSE
;
1090 if (cbp
->cb_scripted
)
1094 * Start with the length of the column headers.
1096 cbp
->cb_colwidths
[GET_COL_NAME
] = strlen(dgettext(TEXT_DOMAIN
, "NAME"));
1097 cbp
->cb_colwidths
[GET_COL_PROPERTY
] = strlen(dgettext(TEXT_DOMAIN
,
1099 cbp
->cb_colwidths
[GET_COL_VALUE
] = strlen(dgettext(TEXT_DOMAIN
,
1101 cbp
->cb_colwidths
[GET_COL_RECVD
] = strlen(dgettext(TEXT_DOMAIN
,
1103 cbp
->cb_colwidths
[GET_COL_SOURCE
] = strlen(dgettext(TEXT_DOMAIN
,
1106 /* first property is always NAME */
1107 assert(cbp
->cb_proplist
->pl_prop
==
1108 ((type
== ZFS_TYPE_POOL
) ? ZPOOL_PROP_NAME
: ZFS_PROP_NAME
));
1111 * Go through and calculate the widths for each column. For the
1112 * 'source' column, we kludge it up by taking the worst-case scenario of
1113 * inheriting from the longest name. This is acceptable because in the
1114 * majority of cases 'SOURCE' is the last column displayed, and we don't
1115 * use the width anyway. Note that the 'VALUE' column can be oversized,
1116 * if the name of the property is much longer than any values we find.
1118 for (pl
= cbp
->cb_proplist
; pl
!= NULL
; pl
= pl
->pl_next
) {
1122 if (pl
->pl_prop
!= ZPROP_INVAL
) {
1123 const char *propname
= (type
== ZFS_TYPE_POOL
) ?
1124 zpool_prop_to_name(pl
->pl_prop
) :
1125 zfs_prop_to_name(pl
->pl_prop
);
1127 len
= strlen(propname
);
1128 if (len
> cbp
->cb_colwidths
[GET_COL_PROPERTY
])
1129 cbp
->cb_colwidths
[GET_COL_PROPERTY
] = len
;
1131 len
= strlen(pl
->pl_user_prop
);
1132 if (len
> cbp
->cb_colwidths
[GET_COL_PROPERTY
])
1133 cbp
->cb_colwidths
[GET_COL_PROPERTY
] = len
;
1137 * 'VALUE' column. The first property is always the 'name'
1138 * property that was tacked on either by /sbin/zfs's
1139 * zfs_do_get() or when calling zprop_expand_list(), so we
1140 * ignore its width. If the user specified the name property
1141 * to display, then it will be later in the list in any case.
1143 if (pl
!= cbp
->cb_proplist
&&
1144 pl
->pl_width
> cbp
->cb_colwidths
[GET_COL_VALUE
])
1145 cbp
->cb_colwidths
[GET_COL_VALUE
] = pl
->pl_width
;
1147 /* 'RECEIVED' column. */
1148 if (pl
!= cbp
->cb_proplist
&&
1149 pl
->pl_recvd_width
> cbp
->cb_colwidths
[GET_COL_RECVD
])
1150 cbp
->cb_colwidths
[GET_COL_RECVD
] = pl
->pl_recvd_width
;
1153 * 'NAME' and 'SOURCE' columns
1155 if (pl
->pl_prop
== (type
== ZFS_TYPE_POOL
? ZPOOL_PROP_NAME
:
1157 pl
->pl_width
> cbp
->cb_colwidths
[GET_COL_NAME
]) {
1158 cbp
->cb_colwidths
[GET_COL_NAME
] = pl
->pl_width
;
1159 cbp
->cb_colwidths
[GET_COL_SOURCE
] = pl
->pl_width
+
1160 strlen(dgettext(TEXT_DOMAIN
, "inherited from"));
1165 * Now go through and print the headers.
1167 for (i
= 0; i
< ZFS_GET_NCOLS
; i
++) {
1168 switch (cbp
->cb_columns
[i
]) {
1170 title
= dgettext(TEXT_DOMAIN
, "NAME");
1172 case GET_COL_PROPERTY
:
1173 title
= dgettext(TEXT_DOMAIN
, "PROPERTY");
1176 title
= dgettext(TEXT_DOMAIN
, "VALUE");
1179 title
= dgettext(TEXT_DOMAIN
, "RECEIVED");
1181 case GET_COL_SOURCE
:
1182 title
= dgettext(TEXT_DOMAIN
, "SOURCE");
1188 if (title
!= NULL
) {
1189 if (i
== (ZFS_GET_NCOLS
- 1) ||
1190 cbp
->cb_columns
[i
+ 1] == GET_COL_NONE
)
1191 (void) printf("%s", title
);
1193 (void) printf("%-*s ",
1194 cbp
->cb_colwidths
[cbp
->cb_columns
[i
]],
1198 (void) printf("\n");
1202 * Display a single line of output, according to the settings in the callback
1206 zprop_print_one_property(const char *name
, zprop_get_cbdata_t
*cbp
,
1207 const char *propname
, const char *value
, zprop_source_t sourcetype
,
1208 const char *source
, const char *recvd_value
)
1211 const char *str
= NULL
;
1215 * Ignore those source types that the user has chosen to ignore.
1217 if ((sourcetype
& cbp
->cb_sources
) == 0)
1221 zprop_print_headers(cbp
, cbp
->cb_type
);
1223 for (i
= 0; i
< ZFS_GET_NCOLS
; i
++) {
1224 switch (cbp
->cb_columns
[i
]) {
1229 case GET_COL_PROPERTY
:
1237 case GET_COL_SOURCE
:
1238 switch (sourcetype
) {
1239 case ZPROP_SRC_NONE
:
1243 case ZPROP_SRC_DEFAULT
:
1247 case ZPROP_SRC_LOCAL
:
1251 case ZPROP_SRC_TEMPORARY
:
1255 case ZPROP_SRC_INHERITED
:
1256 (void) snprintf(buf
, sizeof (buf
),
1257 "inherited from %s", source
);
1260 case ZPROP_SRC_RECEIVED
:
1267 str
= (recvd_value
== NULL
? "-" : recvd_value
);
1274 if (cbp
->cb_columns
[i
+ 1] == GET_COL_NONE
)
1275 (void) printf("%s", str
);
1276 else if (cbp
->cb_scripted
)
1277 (void) printf("%s\t", str
);
1279 (void) printf("%-*s ",
1280 cbp
->cb_colwidths
[cbp
->cb_columns
[i
]],
1284 (void) printf("\n");
1288 * Given a numeric suffix, convert the value into a number of bits that the
1289 * resulting value must be shifted.
1292 str2shift(libzfs_handle_t
*hdl
, const char *buf
)
1294 const char *ends
= "BKMGTPEZ";
1299 for (i
= 0; i
< strlen(ends
); i
++) {
1300 if (toupper(buf
[0]) == ends
[i
])
1303 if (i
== strlen(ends
)) {
1305 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
1306 "invalid numeric suffix '%s'"), buf
);
1311 * Allow 'G' = 'GB' = 'GiB', case-insensitively.
1312 * However, 'BB' and 'BiB' are disallowed.
1314 if (buf
[1] == '\0' ||
1315 (toupper(buf
[0]) != 'B' &&
1316 ((toupper(buf
[1]) == 'B' && buf
[2] == '\0') ||
1317 (toupper(buf
[1]) == 'I' && toupper(buf
[2]) == 'B' &&
1322 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
1323 "invalid numeric suffix '%s'"), buf
);
1328 * Convert a string of the form '100G' into a real number. Used when setting
1329 * properties or creating a volume. 'buf' is used to place an extended error
1330 * message for the caller to use.
1333 zfs_nicestrtonum(libzfs_handle_t
*hdl
, const char *value
, uint64_t *num
)
1340 /* Check to see if this looks like a number. */
1341 if ((value
[0] < '0' || value
[0] > '9') && value
[0] != '.') {
1343 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
1344 "bad numeric value '%s'"), value
);
1348 /* Rely on strtoull() to process the numeric portion. */
1350 *num
= strtoull(value
, &end
, 10);
1353 * Check for ERANGE, which indicates that the value is too large to fit
1354 * in a 64-bit value.
1356 if (errno
== ERANGE
) {
1358 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
1359 "numeric value is too large"));
1364 * If we have a decimal value, then do the computation with floating
1365 * point arithmetic. Otherwise, use standard arithmetic.
1368 double fval
= strtod(value
, &end
);
1370 if ((shift
= str2shift(hdl
, end
)) == -1)
1373 fval
*= pow(2, shift
);
1375 if (fval
> UINT64_MAX
) {
1377 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
1378 "numeric value is too large"));
1382 *num
= (uint64_t)fval
;
1384 if ((shift
= str2shift(hdl
, end
)) == -1)
1387 /* Check for overflow */
1388 if (shift
>= 64 || (*num
<< shift
) >> shift
!= *num
) {
1390 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
1391 "numeric value is too large"));
1402 * Given a propname=value nvpair to set, parse any numeric properties
1403 * (index, boolean, etc) if they are specified as strings and add the
1404 * resulting nvpair to the returned nvlist.
1406 * At the DSL layer, all properties are either 64-bit numbers or strings.
1407 * We want the user to be able to ignore this fact and specify properties
1408 * as native values (numbers, for example) or as strings (to simplify
1409 * command line utilities). This also handles converting index types
1410 * (compression, checksum, etc) from strings to their on-disk index.
1413 zprop_parse_value(libzfs_handle_t
*hdl
, nvpair_t
*elem
, int prop
,
1414 zfs_type_t type
, nvlist_t
*ret
, char **svalp
, uint64_t *ivalp
,
1417 data_type_t datatype
= nvpair_type(elem
);
1418 zprop_type_t proptype
;
1419 const char *propname
;
1421 boolean_t isnone
= B_FALSE
;
1423 if (type
== ZFS_TYPE_POOL
) {
1424 proptype
= zpool_prop_get_type(prop
);
1425 propname
= zpool_prop_to_name(prop
);
1427 proptype
= zfs_prop_get_type(prop
);
1428 propname
= zfs_prop_to_name(prop
);
1432 * Convert any properties to the internal DSL value types.
1438 case PROP_TYPE_STRING
:
1439 if (datatype
!= DATA_TYPE_STRING
) {
1440 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
1441 "'%s' must be a string"), nvpair_name(elem
));
1444 (void) nvpair_value_string(elem
, svalp
);
1445 if (strlen(*svalp
) >= ZFS_MAXPROPLEN
) {
1446 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
1447 "'%s' is too long"), nvpair_name(elem
));
1452 case PROP_TYPE_NUMBER
:
1453 if (datatype
== DATA_TYPE_STRING
) {
1454 (void) nvpair_value_string(elem
, &value
);
1455 if (strcmp(value
, "none") == 0) {
1457 } else if (zfs_nicestrtonum(hdl
, value
, ivalp
)
1461 } else if (datatype
== DATA_TYPE_UINT64
) {
1462 (void) nvpair_value_uint64(elem
, ivalp
);
1464 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
1465 "'%s' must be a number"), nvpair_name(elem
));
1470 * Quota special: force 'none' and don't allow 0.
1472 if ((type
& ZFS_TYPE_DATASET
) && *ivalp
== 0 && !isnone
&&
1473 (prop
== ZFS_PROP_QUOTA
|| prop
== ZFS_PROP_REFQUOTA
)) {
1474 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
1475 "use 'none' to disable quota/refquota"));
1480 case PROP_TYPE_INDEX
:
1481 if (datatype
!= DATA_TYPE_STRING
) {
1482 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
1483 "'%s' must be a string"), nvpair_name(elem
));
1487 (void) nvpair_value_string(elem
, &value
);
1489 if (zprop_string_to_index(prop
, value
, ivalp
, type
) != 0) {
1490 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
1491 "'%s' must be one of '%s'"), propname
,
1492 zprop_values(prop
, type
));
1502 * Add the result to our return set of properties.
1504 if (*svalp
!= NULL
) {
1505 if (nvlist_add_string(ret
, propname
, *svalp
) != 0) {
1506 (void) no_memory(hdl
);
1510 if (nvlist_add_uint64(ret
, propname
, *ivalp
) != 0) {
1511 (void) no_memory(hdl
);
1518 (void) zfs_error(hdl
, EZFS_BADPROP
, errbuf
);
1523 addlist(libzfs_handle_t
*hdl
, char *propname
, zprop_list_t
**listp
,
1527 zprop_list_t
*entry
;
1529 prop
= zprop_name_to_prop(propname
, type
);
1531 if (prop
!= ZPROP_INVAL
&& !zprop_valid_for_type(prop
, type
))
1535 * When no property table entry can be found, return failure if
1536 * this is a pool property or if this isn't a user-defined
1539 if (prop
== ZPROP_INVAL
&& ((type
== ZFS_TYPE_POOL
&&
1540 !zpool_prop_feature(propname
) &&
1541 !zpool_prop_unsupported(propname
)) ||
1542 (type
== ZFS_TYPE_DATASET
&& !zfs_prop_user(propname
) &&
1543 !zfs_prop_userquota(propname
) && !zfs_prop_written(propname
)))) {
1544 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
1545 "invalid property '%s'"), propname
);
1546 return (zfs_error(hdl
, EZFS_BADPROP
,
1547 dgettext(TEXT_DOMAIN
, "bad property list")));
1550 if ((entry
= zfs_alloc(hdl
, sizeof (zprop_list_t
))) == NULL
)
1553 entry
->pl_prop
= prop
;
1554 if (prop
== ZPROP_INVAL
) {
1555 if ((entry
->pl_user_prop
= zfs_strdup(hdl
, propname
)) ==
1560 entry
->pl_width
= strlen(propname
);
1562 entry
->pl_width
= zprop_width(prop
, &entry
->pl_fixed
,
1572 * Given a comma-separated list of properties, construct a property list
1573 * containing both user-defined and native properties. This function will
1574 * return a NULL list if 'all' is specified, which can later be expanded
1575 * by zprop_expand_list().
1578 zprop_get_list(libzfs_handle_t
*hdl
, char *props
, zprop_list_t
**listp
,
1584 * If 'all' is specified, return a NULL list.
1586 if (strcmp(props
, "all") == 0)
1590 * If no props were specified, return an error.
1592 if (props
[0] == '\0') {
1593 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
1594 "no properties specified"));
1595 return (zfs_error(hdl
, EZFS_BADPROP
, dgettext(TEXT_DOMAIN
,
1596 "bad property list")));
1600 * It would be nice to use getsubopt() here, but the inclusion of column
1601 * aliases makes this more effort than it's worth.
1603 while (*props
!= '\0') {
1608 if ((p
= strchr(props
, ',')) == NULL
) {
1609 len
= strlen(props
);
1616 * Check for empty options.
1619 zfs_error_aux(hdl
, dgettext(TEXT_DOMAIN
,
1620 "empty property name"));
1621 return (zfs_error(hdl
, EZFS_BADPROP
,
1622 dgettext(TEXT_DOMAIN
, "bad property list")));
1626 * Check all regular property names.
1631 if (strcmp(props
, "space") == 0) {
1632 static char *spaceprops
[] = {
1633 "name", "avail", "used", "usedbysnapshots",
1634 "usedbydataset", "usedbyrefreservation",
1635 "usedbychildren", NULL
1639 for (i
= 0; spaceprops
[i
]; i
++) {
1640 if (addlist(hdl
, spaceprops
[i
], listp
, type
))
1642 listp
= &(*listp
)->pl_next
;
1645 if (addlist(hdl
, props
, listp
, type
))
1647 listp
= &(*listp
)->pl_next
;
1659 zprop_free_list(zprop_list_t
*pl
)
1663 while (pl
!= NULL
) {
1665 free(pl
->pl_user_prop
);
1671 typedef struct expand_data
{
1672 zprop_list_t
**last
;
1673 libzfs_handle_t
*hdl
;
1678 zprop_expand_list_cb(int prop
, void *cb
)
1680 zprop_list_t
*entry
;
1681 expand_data_t
*edp
= cb
;
1683 if ((entry
= zfs_alloc(edp
->hdl
, sizeof (zprop_list_t
))) == NULL
)
1684 return (ZPROP_INVAL
);
1686 entry
->pl_prop
= prop
;
1687 entry
->pl_width
= zprop_width(prop
, &entry
->pl_fixed
, edp
->type
);
1688 entry
->pl_all
= B_TRUE
;
1690 *(edp
->last
) = entry
;
1691 edp
->last
= &entry
->pl_next
;
1693 return (ZPROP_CONT
);
1697 zprop_expand_list(libzfs_handle_t
*hdl
, zprop_list_t
**plp
, zfs_type_t type
)
1699 zprop_list_t
*entry
;
1700 zprop_list_t
**last
;
1705 * If this is the very first time we've been called for an 'all'
1706 * specification, expand the list to include all native
1715 if (zprop_iter_common(zprop_expand_list_cb
, &exp
, B_FALSE
,
1716 B_FALSE
, type
) == ZPROP_INVAL
)
1720 * Add 'name' to the beginning of the list, which is handled
1723 if ((entry
= zfs_alloc(hdl
, sizeof (zprop_list_t
))) == NULL
)
1726 entry
->pl_prop
= (type
== ZFS_TYPE_POOL
) ? ZPOOL_PROP_NAME
:
1728 entry
->pl_width
= zprop_width(entry
->pl_prop
,
1729 &entry
->pl_fixed
, type
);
1730 entry
->pl_all
= B_TRUE
;
1731 entry
->pl_next
= *plp
;
1738 zprop_iter(zprop_func func
, void *cb
, boolean_t show_all
, boolean_t ordered
,
1741 return (zprop_iter_common(func
, cb
, show_all
, ordered
, type
));