1fa9e4066Sahrens /*
2fa9e4066Sahrens  * CDDL HEADER START
3fa9e4066Sahrens  *
4fa9e4066Sahrens  * The contents of this file are subject to the terms of the
5ea8dc4b6Seschrock  * Common Development and Distribution License (the "License").
6ea8dc4b6Seschrock  * You may not use this file except in compliance with the License.
7fa9e4066Sahrens  *
8fa9e4066Sahrens  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9fa9e4066Sahrens  * or http://www.opensolaris.org/os/licensing.
10fa9e4066Sahrens  * See the License for the specific language governing permissions
11fa9e4066Sahrens  * and limitations under the License.
12fa9e4066Sahrens  *
13fa9e4066Sahrens  * When distributing Covered Code, include this CDDL HEADER in each
14fa9e4066Sahrens  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15fa9e4066Sahrens  * If applicable, add the following below this CDDL HEADER, with the
16fa9e4066Sahrens  * fields enclosed by brackets "[]" replaced with your own identifying
17fa9e4066Sahrens  * information: Portions Copyright [yyyy] [name of copyright owner]
18fa9e4066Sahrens  *
19fa9e4066Sahrens  * CDDL HEADER END
20fa9e4066Sahrens  */
21fa9e4066Sahrens /*
22b12a1c38Slling  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
23fa9e4066Sahrens  * Use is subject to license terms.
24fa9e4066Sahrens  */
25fa9e4066Sahrens 
26fa9e4066Sahrens #pragma ident	"%Z%%M%	%I%	%E% SMI"
27fa9e4066Sahrens 
28fa9e4066Sahrens #include <assert.h>
29fa9e4066Sahrens #include <ctype.h>
30fa9e4066Sahrens #include <errno.h>
31fa9e4066Sahrens #include <libdevinfo.h>
32fa9e4066Sahrens #include <libintl.h>
33fa9e4066Sahrens #include <math.h>
34fa9e4066Sahrens #include <stdio.h>
35fa9e4066Sahrens #include <stdlib.h>
36fa9e4066Sahrens #include <strings.h>
37fa9e4066Sahrens #include <unistd.h>
38fa9e4066Sahrens #include <zone.h>
3999653d4eSeschrock #include <fcntl.h>
40fa9e4066Sahrens #include <sys/mntent.h>
41fa9e4066Sahrens #include <sys/mnttab.h>
42b12a1c38Slling #include <sys/mount.h>
43fa9e4066Sahrens 
44fa9e4066Sahrens #include <sys/spa.h>
45fa9e4066Sahrens #include <sys/zio.h>
46fa9e4066Sahrens #include <libzfs.h>
47fa9e4066Sahrens 
48fa9e4066Sahrens #include "zfs_namecheck.h"
49fa9e4066Sahrens #include "zfs_prop.h"
50fa9e4066Sahrens #include "libzfs_impl.h"
51fa9e4066Sahrens 
52fa9e4066Sahrens /*
53fa9e4066Sahrens  * Given a single type (not a mask of types), return the type in a human
54fa9e4066Sahrens  * readable form.
55fa9e4066Sahrens  */
56fa9e4066Sahrens const char *
57fa9e4066Sahrens zfs_type_to_name(zfs_type_t type)
58fa9e4066Sahrens {
59fa9e4066Sahrens 	switch (type) {
60fa9e4066Sahrens 	case ZFS_TYPE_FILESYSTEM:
61fa9e4066Sahrens 		return (dgettext(TEXT_DOMAIN, "filesystem"));
62fa9e4066Sahrens 	case ZFS_TYPE_SNAPSHOT:
63fa9e4066Sahrens 		return (dgettext(TEXT_DOMAIN, "snapshot"));
64fa9e4066Sahrens 	case ZFS_TYPE_VOLUME:
65fa9e4066Sahrens 		return (dgettext(TEXT_DOMAIN, "volume"));
66fa9e4066Sahrens 	}
67fa9e4066Sahrens 
68fa9e4066Sahrens 	return (NULL);
69fa9e4066Sahrens }
70fa9e4066Sahrens 
71fa9e4066Sahrens /*
72fa9e4066Sahrens  * Given a path and mask of ZFS types, return a string describing this dataset.
73fa9e4066Sahrens  * This is used when we fail to open a dataset and we cannot get an exact type.
74fa9e4066Sahrens  * We guess what the type would have been based on the path and the mask of
75fa9e4066Sahrens  * acceptable types.
76fa9e4066Sahrens  */
77fa9e4066Sahrens static const char *
78fa9e4066Sahrens path_to_str(const char *path, int types)
79fa9e4066Sahrens {
80fa9e4066Sahrens 	/*
81fa9e4066Sahrens 	 * When given a single type, always report the exact type.
82fa9e4066Sahrens 	 */
83fa9e4066Sahrens 	if (types == ZFS_TYPE_SNAPSHOT)
84fa9e4066Sahrens 		return (dgettext(TEXT_DOMAIN, "snapshot"));
85fa9e4066Sahrens 	if (types == ZFS_TYPE_FILESYSTEM)
86fa9e4066Sahrens 		return (dgettext(TEXT_DOMAIN, "filesystem"));
87fa9e4066Sahrens 	if (types == ZFS_TYPE_VOLUME)
88fa9e4066Sahrens 		return (dgettext(TEXT_DOMAIN, "volume"));
89fa9e4066Sahrens 
90fa9e4066Sahrens 	/*
91fa9e4066Sahrens 	 * The user is requesting more than one type of dataset.  If this is the
92fa9e4066Sahrens 	 * case, consult the path itself.  If we're looking for a snapshot, and
93fa9e4066Sahrens 	 * a '@' is found, then report it as "snapshot".  Otherwise, remove the
94fa9e4066Sahrens 	 * snapshot attribute and try again.
95fa9e4066Sahrens 	 */
96fa9e4066Sahrens 	if (types & ZFS_TYPE_SNAPSHOT) {
97fa9e4066Sahrens 		if (strchr(path, '@') != NULL)
98fa9e4066Sahrens 			return (dgettext(TEXT_DOMAIN, "snapshot"));
99fa9e4066Sahrens 		return (path_to_str(path, types & ~ZFS_TYPE_SNAPSHOT));
100fa9e4066Sahrens 	}
101fa9e4066Sahrens 
102fa9e4066Sahrens 
103fa9e4066Sahrens 	/*
104fa9e4066Sahrens 	 * The user has requested either filesystems or volumes.
105fa9e4066Sahrens 	 * We have no way of knowing a priori what type this would be, so always
106fa9e4066Sahrens 	 * report it as "filesystem" or "volume", our two primitive types.
107fa9e4066Sahrens 	 */
108fa9e4066Sahrens 	if (types & ZFS_TYPE_FILESYSTEM)
109fa9e4066Sahrens 		return (dgettext(TEXT_DOMAIN, "filesystem"));
110fa9e4066Sahrens 
111fa9e4066Sahrens 	assert(types & ZFS_TYPE_VOLUME);
112fa9e4066Sahrens 	return (dgettext(TEXT_DOMAIN, "volume"));
113fa9e4066Sahrens }
114fa9e4066Sahrens 
115fa9e4066Sahrens /*
116fa9e4066Sahrens  * Validate a ZFS path.  This is used even before trying to open the dataset, to
117fa9e4066Sahrens  * provide a more meaningful error message.  We place a more useful message in
118fa9e4066Sahrens  * 'buf' detailing exactly why the name was not valid.
119fa9e4066Sahrens  */
120fa9e4066Sahrens static int
12199653d4eSeschrock zfs_validate_name(libzfs_handle_t *hdl, const char *path, int type)
122fa9e4066Sahrens {
123fa9e4066Sahrens 	namecheck_err_t why;
124fa9e4066Sahrens 	char what;
125fa9e4066Sahrens 
126fa9e4066Sahrens 	if (dataset_namecheck(path, &why, &what) != 0) {
12799653d4eSeschrock 		if (hdl != NULL) {
128fa9e4066Sahrens 			switch (why) {
129b81d61a6Slling 			case NAME_ERR_TOOLONG:
13099653d4eSeschrock 				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
13199653d4eSeschrock 				    "name is too long"));
132b81d61a6Slling 				break;
133b81d61a6Slling 
134fa9e4066Sahrens 			case NAME_ERR_LEADING_SLASH:
13599653d4eSeschrock 				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
13699653d4eSeschrock 				    "leading slash in name"));
137fa9e4066Sahrens 				break;
138fa9e4066Sahrens 
139fa9e4066Sahrens 			case NAME_ERR_EMPTY_COMPONENT:
14099653d4eSeschrock 				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
14199653d4eSeschrock 				    "empty component in name"));
142fa9e4066Sahrens 				break;
143fa9e4066Sahrens 
144fa9e4066Sahrens 			case NAME_ERR_TRAILING_SLASH:
14599653d4eSeschrock 				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
14699653d4eSeschrock 				    "trailing slash in name"));
147fa9e4066Sahrens 				break;
148fa9e4066Sahrens 
149fa9e4066Sahrens 			case NAME_ERR_INVALCHAR:
15099653d4eSeschrock 				zfs_error_aux(hdl,
151fa9e4066Sahrens 				    dgettext(TEXT_DOMAIN, "invalid character "
15299653d4eSeschrock 				    "'%c' in name"), what);
153fa9e4066Sahrens 				break;
154fa9e4066Sahrens 
155fa9e4066Sahrens 			case NAME_ERR_MULTIPLE_AT:
15699653d4eSeschrock 				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
15799653d4eSeschrock 				    "multiple '@' delimiters in name"));
158fa9e4066Sahrens 				break;
159fa9e4066Sahrens 			}
160fa9e4066Sahrens 		}
161fa9e4066Sahrens 
162fa9e4066Sahrens 		return (0);
163fa9e4066Sahrens 	}
164fa9e4066Sahrens 
165fa9e4066Sahrens 	if (!(type & ZFS_TYPE_SNAPSHOT) && strchr(path, '@') != NULL) {
16699653d4eSeschrock 		if (hdl != NULL)
16799653d4eSeschrock 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
16899653d4eSeschrock 			    "snapshot delimiter '@' in filesystem name"));
169fa9e4066Sahrens 		return (0);
170fa9e4066Sahrens 	}
171fa9e4066Sahrens 
172*1d452cf5Sahrens 	if (type == ZFS_TYPE_SNAPSHOT && strchr(path, '@') == NULL) {
173*1d452cf5Sahrens 		if (hdl != NULL)
174*1d452cf5Sahrens 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
175*1d452cf5Sahrens 			    "missing '@' delimeter in snapshot name"));
176*1d452cf5Sahrens 		return (0);
177*1d452cf5Sahrens 	}
178*1d452cf5Sahrens 
17999653d4eSeschrock 	return (-1);
180fa9e4066Sahrens }
181fa9e4066Sahrens 
182fa9e4066Sahrens int
183fa9e4066Sahrens zfs_name_valid(const char *name, zfs_type_t type)
184fa9e4066Sahrens {
18599653d4eSeschrock 	return (zfs_validate_name(NULL, name, type));
186fa9e4066Sahrens }
187fa9e4066Sahrens 
188fa9e4066Sahrens /*
189fa9e4066Sahrens  * Utility function to gather stats (objset and zpl) for the given object.
190fa9e4066Sahrens  */
191fa9e4066Sahrens static int
192fa9e4066Sahrens get_stats(zfs_handle_t *zhp)
193fa9e4066Sahrens {
194fa9e4066Sahrens 	zfs_cmd_t zc = { 0 };
195fa9e4066Sahrens 
196fa9e4066Sahrens 	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
197fa9e4066Sahrens 
19899653d4eSeschrock 	if ((zc.zc_config_src = (uint64_t)(uintptr_t)malloc(1024)) == NULL)
19999653d4eSeschrock 		return (-1);
2007f7322feSeschrock 	zc.zc_config_src_size = 1024;
2017f7322feSeschrock 
20299653d4eSeschrock 	while (ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_OBJSET_STATS, &zc) != 0) {
2037f7322feSeschrock 		if (errno == ENOMEM) {
20499653d4eSeschrock 			free((void *)(uintptr_t)zc.zc_config_src);
20599653d4eSeschrock 			if ((zc.zc_config_src = (uint64_t)(uintptr_t)
20699653d4eSeschrock 			    malloc(zc.zc_config_src_size)) == NULL)
20799653d4eSeschrock 				return (-1);
2087f7322feSeschrock 		} else {
2097f7322feSeschrock 			free((void *)(uintptr_t)zc.zc_config_src);
2107f7322feSeschrock 			return (-1);
2117f7322feSeschrock 		}
2127f7322feSeschrock 	}
213fa9e4066Sahrens 
214fa9e4066Sahrens 	bcopy(&zc.zc_objset_stats, &zhp->zfs_dmustats,
215fa9e4066Sahrens 	    sizeof (zc.zc_objset_stats));
216fa9e4066Sahrens 
217ea8dc4b6Seschrock 	(void) strcpy(zhp->zfs_root, zc.zc_root);
218ea8dc4b6Seschrock 
21999653d4eSeschrock 	if (zhp->zfs_props) {
22099653d4eSeschrock 		nvlist_free(zhp->zfs_props);
22199653d4eSeschrock 		zhp->zfs_props = NULL;
22299653d4eSeschrock 	}
22399653d4eSeschrock 
22499653d4eSeschrock 	if (nvlist_unpack((void *)(uintptr_t)zc.zc_config_src,
22599653d4eSeschrock 	    zc.zc_config_src_size, &zhp->zfs_props, 0) != 0) {
22699653d4eSeschrock 		free((void *)(uintptr_t)zc.zc_config_src);
22799653d4eSeschrock 		return (-1);
22899653d4eSeschrock 	}
229fa9e4066Sahrens 
230fa9e4066Sahrens 	zhp->zfs_volsize = zc.zc_volsize;
231fa9e4066Sahrens 	zhp->zfs_volblocksize = zc.zc_volblocksize;
232fa9e4066Sahrens 
23399653d4eSeschrock 	free((void *)(uintptr_t)zc.zc_config_src);
23499653d4eSeschrock 
235fa9e4066Sahrens 	return (0);
236fa9e4066Sahrens }
237fa9e4066Sahrens 
238fa9e4066Sahrens /*
239fa9e4066Sahrens  * Refresh the properties currently stored in the handle.
240fa9e4066Sahrens  */
241fa9e4066Sahrens void
242fa9e4066Sahrens zfs_refresh_properties(zfs_handle_t *zhp)
243fa9e4066Sahrens {
244fa9e4066Sahrens 	(void) get_stats(zhp);
245fa9e4066Sahrens }
246fa9e4066Sahrens 
247fa9e4066Sahrens /*
248fa9e4066Sahrens  * Makes a handle from the given dataset name.  Used by zfs_open() and
249fa9e4066Sahrens  * zfs_iter_* to create child handles on the fly.
250fa9e4066Sahrens  */
251fa9e4066Sahrens zfs_handle_t *
25299653d4eSeschrock make_dataset_handle(libzfs_handle_t *hdl, const char *path)
253fa9e4066Sahrens {
25499653d4eSeschrock 	zfs_handle_t *zhp = calloc(sizeof (zfs_handle_t), 1);
25599653d4eSeschrock 
25699653d4eSeschrock 	if (zhp == NULL)
25799653d4eSeschrock 		return (NULL);
25899653d4eSeschrock 
25999653d4eSeschrock 	zhp->zfs_hdl = hdl;
260fa9e4066Sahrens 
26131fd60d3Sahrens top:
262fa9e4066Sahrens 	(void) strlcpy(zhp->zfs_name, path, sizeof (zhp->zfs_name));
263fa9e4066Sahrens 
264fa9e4066Sahrens 	if (get_stats(zhp) != 0) {
265fa9e4066Sahrens 		free(zhp);
266fa9e4066Sahrens 		return (NULL);
267fa9e4066Sahrens 	}
268fa9e4066Sahrens 
26931fd60d3Sahrens 	if (zhp->zfs_dmustats.dds_inconsistent) {
27031fd60d3Sahrens 		zfs_cmd_t zc = { 0 };
27131fd60d3Sahrens 
27231fd60d3Sahrens 		/*
27331fd60d3Sahrens 		 * If it is dds_inconsistent, then we've caught it in
27431fd60d3Sahrens 		 * the middle of a 'zfs receive' or 'zfs destroy', and
27531fd60d3Sahrens 		 * it is inconsistent from the ZPL's point of view, so
27631fd60d3Sahrens 		 * can't be mounted.  However, it could also be that we
27731fd60d3Sahrens 		 * have crashed in the middle of one of those
27831fd60d3Sahrens 		 * operations, in which case we need to get rid of the
27931fd60d3Sahrens 		 * inconsistent state.  We do that by either rolling
28031fd60d3Sahrens 		 * back to the previous snapshot (which will fail if
28131fd60d3Sahrens 		 * there is none), or destroying the filesystem.  Note
28231fd60d3Sahrens 		 * that if we are still in the middle of an active
28331fd60d3Sahrens 		 * 'receive' or 'destroy', then the rollback and destroy
28431fd60d3Sahrens 		 * will fail with EBUSY and we will drive on as usual.
28531fd60d3Sahrens 		 */
28631fd60d3Sahrens 
28731fd60d3Sahrens 		(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
28831fd60d3Sahrens 
28931fd60d3Sahrens 		if (zhp->zfs_type == ZFS_TYPE_VOLUME) {
29099653d4eSeschrock 			(void) zvol_remove_link(hdl, zhp->zfs_name);
29131fd60d3Sahrens 			zc.zc_objset_type = DMU_OST_ZVOL;
29231fd60d3Sahrens 		} else {
29331fd60d3Sahrens 			zc.zc_objset_type = DMU_OST_ZFS;
29431fd60d3Sahrens 		}
29531fd60d3Sahrens 
29631fd60d3Sahrens 		/* If we can successfully roll it back, reget the stats */
29799653d4eSeschrock 		if (ioctl(hdl->libzfs_fd, ZFS_IOC_ROLLBACK, &zc) == 0)
29831fd60d3Sahrens 			goto top;
29931fd60d3Sahrens 		/*
30031fd60d3Sahrens 		 * If we can sucessfully destroy it, pretend that it
30131fd60d3Sahrens 		 * never existed.
30231fd60d3Sahrens 		 */
30399653d4eSeschrock 		if (ioctl(hdl->libzfs_fd, ZFS_IOC_DESTROY, &zc) == 0) {
30431fd60d3Sahrens 			free(zhp);
30531fd60d3Sahrens 			errno = ENOENT;
30631fd60d3Sahrens 			return (NULL);
30731fd60d3Sahrens 		}
30831fd60d3Sahrens 	}
30931fd60d3Sahrens 
310fa9e4066Sahrens 	/*
311fa9e4066Sahrens 	 * We've managed to open the dataset and gather statistics.  Determine
312fa9e4066Sahrens 	 * the high-level type.
313fa9e4066Sahrens 	 */
314fa9e4066Sahrens 	if (zhp->zfs_dmustats.dds_is_snapshot)
315fa9e4066Sahrens 		zhp->zfs_type = ZFS_TYPE_SNAPSHOT;
316fa9e4066Sahrens 	else if (zhp->zfs_dmustats.dds_type == DMU_OST_ZVOL)
317fa9e4066Sahrens 		zhp->zfs_type = ZFS_TYPE_VOLUME;
318fa9e4066Sahrens 	else if (zhp->zfs_dmustats.dds_type == DMU_OST_ZFS)
319fa9e4066Sahrens 		zhp->zfs_type = ZFS_TYPE_FILESYSTEM;
320fa9e4066Sahrens 	else
32199653d4eSeschrock 		abort();	/* we should never see any other types */
322fa9e4066Sahrens 
323fa9e4066Sahrens 	return (zhp);
324fa9e4066Sahrens }
325fa9e4066Sahrens 
326fa9e4066Sahrens /*
327fa9e4066Sahrens  * Opens the given snapshot, filesystem, or volume.   The 'types'
328fa9e4066Sahrens  * argument is a mask of acceptable types.  The function will print an
329fa9e4066Sahrens  * appropriate error message and return NULL if it can't be opened.
330fa9e4066Sahrens  */
331fa9e4066Sahrens zfs_handle_t *
33299653d4eSeschrock zfs_open(libzfs_handle_t *hdl, const char *path, int types)
333fa9e4066Sahrens {
334fa9e4066Sahrens 	zfs_handle_t *zhp;
33599653d4eSeschrock 	char errbuf[1024];
33699653d4eSeschrock 
33799653d4eSeschrock 	(void) snprintf(errbuf, sizeof (errbuf),
33899653d4eSeschrock 	    dgettext(TEXT_DOMAIN, "cannot open '%s'"), path);
339fa9e4066Sahrens 
340fa9e4066Sahrens 	/*
34199653d4eSeschrock 	 * Validate the name before we even try to open it.
342fa9e4066Sahrens 	 */
34399653d4eSeschrock 	if (!zfs_validate_name(hdl, path, ZFS_TYPE_ANY)) {
34499653d4eSeschrock 		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
34599653d4eSeschrock 		    "invalid dataset name"));
34699653d4eSeschrock 		(void) zfs_error(hdl, EZFS_INVALIDNAME, errbuf);
347fa9e4066Sahrens 		return (NULL);
348fa9e4066Sahrens 	}
349fa9e4066Sahrens 
350fa9e4066Sahrens 	/*
351fa9e4066Sahrens 	 * Try to get stats for the dataset, which will tell us if it exists.
352fa9e4066Sahrens 	 */
353fa9e4066Sahrens 	errno = 0;
35499653d4eSeschrock 	if ((zhp = make_dataset_handle(hdl, path)) == NULL) {
35599653d4eSeschrock 		(void) zfs_standard_error(hdl, errno, errbuf, path);
356fa9e4066Sahrens 		return (NULL);
357fa9e4066Sahrens 	}
358fa9e4066Sahrens 
359fa9e4066Sahrens 	if (!(types & zhp->zfs_type)) {
36099653d4eSeschrock 		(void) zfs_error(hdl, EZFS_BADTYPE, errbuf);
36194de1d4cSeschrock 		zfs_close(zhp);
362fa9e4066Sahrens 		return (NULL);
363fa9e4066Sahrens 	}
364fa9e4066Sahrens 
365fa9e4066Sahrens 	return (zhp);
366fa9e4066Sahrens }
367fa9e4066Sahrens 
368fa9e4066Sahrens /*
369fa9e4066Sahrens  * Release a ZFS handle.  Nothing to do but free the associated memory.
370fa9e4066Sahrens  */
371fa9e4066Sahrens void
372fa9e4066Sahrens zfs_close(zfs_handle_t *zhp)
373fa9e4066Sahrens {
374fa9e4066Sahrens 	if (zhp->zfs_mntopts)
375fa9e4066Sahrens 		free(zhp->zfs_mntopts);
37699653d4eSeschrock 	if (zhp->zfs_props)
37799653d4eSeschrock 		nvlist_free(zhp->zfs_props);
378fa9e4066Sahrens 	free(zhp);
379fa9e4066Sahrens }
380fa9e4066Sahrens 
381fa9e4066Sahrens struct {
382fa9e4066Sahrens 	const char *name;
383fa9e4066Sahrens 	uint64_t value;
384fa9e4066Sahrens } checksum_table[] = {
385fa9e4066Sahrens 	{ "on",		ZIO_CHECKSUM_ON },
386fa9e4066Sahrens 	{ "off",	ZIO_CHECKSUM_OFF },
387fa9e4066Sahrens 	{ "fletcher2",	ZIO_CHECKSUM_FLETCHER_2 },
388fa9e4066Sahrens 	{ "fletcher4",	ZIO_CHECKSUM_FLETCHER_4 },
389fa9e4066Sahrens 	{ "sha256",	ZIO_CHECKSUM_SHA256 },
390fa9e4066Sahrens 	{ NULL }
391fa9e4066Sahrens };
392fa9e4066Sahrens 
393fa9e4066Sahrens struct {
394fa9e4066Sahrens 	const char *name;
395fa9e4066Sahrens 	uint64_t value;
396fa9e4066Sahrens } compress_table[] = {
397fa9e4066Sahrens 	{ "on",		ZIO_COMPRESS_ON },
398fa9e4066Sahrens 	{ "off",	ZIO_COMPRESS_OFF },
399fa9e4066Sahrens 	{ "lzjb",	ZIO_COMPRESS_LZJB },
400fa9e4066Sahrens 	{ NULL }
401fa9e4066Sahrens };
402fa9e4066Sahrens 
403fa9e4066Sahrens struct {
404fa9e4066Sahrens 	const char *name;
405fa9e4066Sahrens 	uint64_t value;
406fa9e4066Sahrens } snapdir_table[] = {
407a0965f35Sbonwick 	{ "hidden",	ZFS_SNAPDIR_HIDDEN },
408a0965f35Sbonwick 	{ "visible",	ZFS_SNAPDIR_VISIBLE },
409fa9e4066Sahrens 	{ NULL }
410fa9e4066Sahrens };
411fa9e4066Sahrens 
412fa9e4066Sahrens struct {
413fa9e4066Sahrens 	const char *name;
414fa9e4066Sahrens 	uint64_t value;
415fa9e4066Sahrens } acl_mode_table[] = {
416fa9e4066Sahrens 	{ "discard",	DISCARD },
417fa9e4066Sahrens 	{ "groupmask",	GROUPMASK },
418fa9e4066Sahrens 	{ "passthrough", PASSTHROUGH },
419fa9e4066Sahrens 	{ NULL }
420fa9e4066Sahrens };
421fa9e4066Sahrens 
422fa9e4066Sahrens struct {
423fa9e4066Sahrens 	const char *name;
424fa9e4066Sahrens 	uint64_t value;
425fa9e4066Sahrens } acl_inherit_table[] = {
426fa9e4066Sahrens 	{ "discard",	DISCARD },
427fa9e4066Sahrens 	{ "noallow",	NOALLOW },
428fa9e4066Sahrens 	{ "secure",	SECURE },
429fa9e4066Sahrens 	{ "passthrough", PASSTHROUGH },
430fa9e4066Sahrens 	{ NULL }
431fa9e4066Sahrens };
432fa9e4066Sahrens 
433fa9e4066Sahrens 
434fa9e4066Sahrens /*
435fa9e4066Sahrens  * Given a numeric suffix, convert the value into a number of bits that the
436fa9e4066Sahrens  * resulting value must be shifted.
437fa9e4066Sahrens  */
438fa9e4066Sahrens static int
43999653d4eSeschrock str2shift(libzfs_handle_t *hdl, const char *buf)
440fa9e4066Sahrens {
441fa9e4066Sahrens 	const char *ends = "BKMGTPEZ";
442fa9e4066Sahrens 	int i;
443fa9e4066Sahrens 
444fa9e4066Sahrens 	if (buf[0] == '\0')
445fa9e4066Sahrens 		return (0);
446fa9e4066Sahrens 	for (i = 0; i < strlen(ends); i++) {
447fa9e4066Sahrens 		if (toupper(buf[0]) == ends[i])
448fa9e4066Sahrens 			break;
449fa9e4066Sahrens 	}
450fa9e4066Sahrens 	if (i == strlen(ends)) {
45199653d4eSeschrock 		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
45299653d4eSeschrock 		    "invalid numeric suffix '%s'"), buf);
453fa9e4066Sahrens 		return (-1);
454fa9e4066Sahrens 	}
455fa9e4066Sahrens 
456fa9e4066Sahrens 	/*
457fa9e4066Sahrens 	 * We want to allow trailing 'b' characters for 'GB' or 'Mb'.  But don't
458fa9e4066Sahrens 	 * allow 'BB' - that's just weird.
459fa9e4066Sahrens 	 */
460fa9e4066Sahrens 	if (buf[1] == '\0' || (toupper(buf[1]) == 'B' && buf[2] == '\0' &&
46199653d4eSeschrock 	    toupper(buf[0]) != 'B'))
462fa9e4066Sahrens 		return (10*i);
463fa9e4066Sahrens 
46499653d4eSeschrock 	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
46599653d4eSeschrock 	    "invalid numeric suffix '%s'"), buf);
466fa9e4066Sahrens 	return (-1);
467fa9e4066Sahrens }
468fa9e4066Sahrens 
469fa9e4066Sahrens /*
470fa9e4066Sahrens  * Convert a string of the form '100G' into a real number.  Used when setting
471fa9e4066Sahrens  * properties or creating a volume.  'buf' is used to place an extended error
472fa9e4066Sahrens  * message for the caller to use.
473fa9e4066Sahrens  */
474fa9e4066Sahrens static int
47599653d4eSeschrock nicestrtonum(libzfs_handle_t *hdl, const char *value, uint64_t *num)
476fa9e4066Sahrens {
477fa9e4066Sahrens 	char *end;
478fa9e4066Sahrens 	int shift;
479fa9e4066Sahrens 
480fa9e4066Sahrens 	*num = 0;
481fa9e4066Sahrens 
482fa9e4066Sahrens 	/* Check to see if this looks like a number.  */
483fa9e4066Sahrens 	if ((value[0] < '0' || value[0] > '9') && value[0] != '.') {
48499653d4eSeschrock 		if (hdl)
48599653d4eSeschrock 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
48699653d4eSeschrock 			    "bad numeric value '%s'"), value);
487fa9e4066Sahrens 		return (-1);
488fa9e4066Sahrens 	}
489fa9e4066Sahrens 
490fa9e4066Sahrens 	/* Rely on stroll() to process the numeric portion.  */
491fa9e4066Sahrens 	errno = 0;
492fa9e4066Sahrens 	*num = strtoll(value, &end, 10);
493fa9e4066Sahrens 
494fa9e4066Sahrens 	/*
495fa9e4066Sahrens 	 * Check for ERANGE, which indicates that the value is too large to fit
496fa9e4066Sahrens 	 * in a 64-bit value.
497fa9e4066Sahrens 	 */
498fa9e4066Sahrens 	if (errno == ERANGE) {
49999653d4eSeschrock 		if (hdl)
50099653d4eSeschrock 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
50199653d4eSeschrock 			    "numeric value is too large"));
502fa9e4066Sahrens 		return (-1);
503fa9e4066Sahrens 	}
504fa9e4066Sahrens 
505fa9e4066Sahrens 	/*
506fa9e4066Sahrens 	 * If we have a decimal value, then do the computation with floating
507fa9e4066Sahrens 	 * point arithmetic.  Otherwise, use standard arithmetic.
508fa9e4066Sahrens 	 */
509fa9e4066Sahrens 	if (*end == '.') {
510fa9e4066Sahrens 		double fval = strtod(value, &end);
511fa9e4066Sahrens 
51299653d4eSeschrock 		if ((shift = str2shift(hdl, end)) == -1)
513fa9e4066Sahrens 			return (-1);
514fa9e4066Sahrens 
515fa9e4066Sahrens 		fval *= pow(2, shift);
516fa9e4066Sahrens 
517fa9e4066Sahrens 		if (fval > UINT64_MAX) {
51899653d4eSeschrock 			if (hdl)
51999653d4eSeschrock 				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
52099653d4eSeschrock 				    "numeric value is too large"));
521fa9e4066Sahrens 			return (-1);
522fa9e4066Sahrens 		}
523fa9e4066Sahrens 
524fa9e4066Sahrens 		*num = (uint64_t)fval;
525fa9e4066Sahrens 	} else {
52699653d4eSeschrock 		if ((shift = str2shift(hdl, end)) == -1)
527fa9e4066Sahrens 			return (-1);
528fa9e4066Sahrens 
529fa9e4066Sahrens 		/* Check for overflow */
530fa9e4066Sahrens 		if (shift >= 64 || (*num << shift) >> shift != *num) {
53199653d4eSeschrock 			if (hdl)
53299653d4eSeschrock 				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
53399653d4eSeschrock 				    "numeric value is too large"));
534fa9e4066Sahrens 			return (-1);
535fa9e4066Sahrens 		}
536fa9e4066Sahrens 
537fa9e4066Sahrens 		*num <<= shift;
538fa9e4066Sahrens 	}
539fa9e4066Sahrens 
540fa9e4066Sahrens 	return (0);
541fa9e4066Sahrens }
542fa9e4066Sahrens 
543fa9e4066Sahrens int
544fa9e4066Sahrens zfs_nicestrtonum(const char *str, uint64_t *val)
545fa9e4066Sahrens {
54699653d4eSeschrock 	return (nicestrtonum(NULL, str, val));
547fa9e4066Sahrens }
548fa9e4066Sahrens 
549fa9e4066Sahrens /*
550fa9e4066Sahrens  * Given a property type and value, verify that the value is appropriate.  Used
551fa9e4066Sahrens  * by zfs_prop_set() and some libzfs consumers.
552fa9e4066Sahrens  */
553fa9e4066Sahrens int
55499653d4eSeschrock zfs_prop_validate(libzfs_handle_t *hdl, zfs_prop_t prop, const char *value,
55599653d4eSeschrock     uint64_t *intval)
556fa9e4066Sahrens {
557fa9e4066Sahrens 	const char *propname = zfs_prop_to_name(prop);
558fa9e4066Sahrens 	uint64_t number;
55999653d4eSeschrock 	char errbuf[1024];
560fa9e4066Sahrens 	int i;
561fa9e4066Sahrens 
562fa9e4066Sahrens 	/*
563fa9e4066Sahrens 	 * Check to see if this a read-only property.
564fa9e4066Sahrens 	 */
56599653d4eSeschrock 	if (zfs_prop_readonly(prop))
56699653d4eSeschrock 		return (zfs_error(hdl, EZFS_PROPREADONLY,
56799653d4eSeschrock 		    dgettext(TEXT_DOMAIN, "cannot set %s property"), propname));
56899653d4eSeschrock 
56999653d4eSeschrock 	(void) snprintf(errbuf, sizeof (errbuf),
57099653d4eSeschrock 	    dgettext(TEXT_DOMAIN, "bad %s value '%s'"), propname, value);
571fa9e4066Sahrens 
572fa9e4066Sahrens 	/* See if the property value is too long */
573fa9e4066Sahrens 	if (strlen(value) >= ZFS_MAXPROPLEN) {
57499653d4eSeschrock 		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "value is too long"));
57599653d4eSeschrock 		return (zfs_error(hdl, EZFS_BADPROP, errbuf));
576fa9e4066Sahrens 	}
577fa9e4066Sahrens 
578fa9e4066Sahrens 	/* Perform basic checking based on property type */
579fa9e4066Sahrens 	switch (zfs_prop_get_type(prop)) {
580fa9e4066Sahrens 	case prop_type_boolean:
581fa9e4066Sahrens 		if (strcmp(value, "on") == 0) {
582fa9e4066Sahrens 			number = 1;
583fa9e4066Sahrens 		} else if (strcmp(value, "off") == 0) {
584fa9e4066Sahrens 			number = 0;
585fa9e4066Sahrens 		} else {
58699653d4eSeschrock 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
58799653d4eSeschrock 			    "must be 'on' or 'off'"));
58899653d4eSeschrock 			return (zfs_error(hdl, EZFS_BADPROP, errbuf));
589fa9e4066Sahrens 		}
590fa9e4066Sahrens 		break;
591fa9e4066Sahrens 
592fa9e4066Sahrens 	case prop_type_number:
593fa9e4066Sahrens 		/* treat 'none' as 0 */
594fa9e4066Sahrens 		if (strcmp(value, "none") == 0) {
595fa9e4066Sahrens 			number = 0;
596fa9e4066Sahrens 			break;
597fa9e4066Sahrens 		}
598fa9e4066Sahrens 
59999653d4eSeschrock 		if (nicestrtonum(hdl, value, &number) != 0)
60099653d4eSeschrock 			return (zfs_error(hdl, EZFS_BADPROP, errbuf));
601fa9e4066Sahrens 
602fa9e4066Sahrens 		/* don't allow 0 for quota, use 'none' instead */
603fa9e4066Sahrens 		if (prop == ZFS_PROP_QUOTA && number == 0 &&
604fa9e4066Sahrens 		    strcmp(value, "none") != 0) {
60599653d4eSeschrock 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
60699653d4eSeschrock 			    "use 'quota=none' to disable"));
60799653d4eSeschrock 			return (zfs_error(hdl, EZFS_BADPROP, errbuf));
608fa9e4066Sahrens 		}
609fa9e4066Sahrens 
610fa9e4066Sahrens 		/* must be power of two within SPA_{MIN,MAX}BLOCKSIZE */
611fa9e4066Sahrens 		if (prop == ZFS_PROP_RECORDSIZE ||
612fa9e4066Sahrens 		    prop == ZFS_PROP_VOLBLOCKSIZE) {
613fa9e4066Sahrens 			if (number < SPA_MINBLOCKSIZE ||
614fa9e4066Sahrens 			    number > SPA_MAXBLOCKSIZE || !ISP2(number)) {
61599653d4eSeschrock 				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
616fa9e4066Sahrens 				    "must be power of 2 from %u to %uk"),
617fa9e4066Sahrens 				    (uint_t)SPA_MINBLOCKSIZE,
618fa9e4066Sahrens 				    (uint_t)SPA_MAXBLOCKSIZE >> 10);
61999653d4eSeschrock 				return (zfs_error(hdl, EZFS_BADPROP, errbuf));
620fa9e4066Sahrens 			}
621fa9e4066Sahrens 		}
622fa9e4066Sahrens 
623fa9e4066Sahrens 		break;
624fa9e4066Sahrens 
625fa9e4066Sahrens 	case prop_type_string:
626fa9e4066Sahrens 	case prop_type_index:
627fa9e4066Sahrens 		/*
628fa9e4066Sahrens 		 * The two writable string values, 'mountpoint' and
629fa9e4066Sahrens 		 * 'checksum' need special consideration.  The 'index' types are
630fa9e4066Sahrens 		 * specified as strings by the user, but passed to the kernel as
631fa9e4066Sahrens 		 * integers.
632fa9e4066Sahrens 		 */
633fa9e4066Sahrens 		switch (prop) {
634fa9e4066Sahrens 		case ZFS_PROP_MOUNTPOINT:
635fa9e4066Sahrens 			if (strcmp(value, ZFS_MOUNTPOINT_NONE) == 0 ||
636fa9e4066Sahrens 			    strcmp(value, ZFS_MOUNTPOINT_LEGACY) == 0)
637fa9e4066Sahrens 				break;
638fa9e4066Sahrens 
639fa9e4066Sahrens 			if (value[0] != '/') {
64099653d4eSeschrock 				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
64199653d4eSeschrock 				    "must be an absolute path, 'none', or "
64299653d4eSeschrock 				    "'legacy'"));
64399653d4eSeschrock 				return (zfs_error(hdl, EZFS_BADPROP, errbuf));
644fa9e4066Sahrens 			}
645fa9e4066Sahrens 			break;
646fa9e4066Sahrens 
647fa9e4066Sahrens 		case ZFS_PROP_CHECKSUM:
648fa9e4066Sahrens 			for (i = 0; checksum_table[i].name != NULL; i++) {
649fa9e4066Sahrens 				if (strcmp(value, checksum_table[i].name)
650fa9e4066Sahrens 				    == 0) {
651fa9e4066Sahrens 					number = checksum_table[i].value;
652fa9e4066Sahrens 					break;
653fa9e4066Sahrens 				}
654fa9e4066Sahrens 			}
655fa9e4066Sahrens 
656fa9e4066Sahrens 			if (checksum_table[i].name == NULL) {
65799653d4eSeschrock 				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
65899653d4eSeschrock 				    "must be 'on', 'off', 'fletcher2', "
65999653d4eSeschrock 				    "'fletcher4', or 'sha256'"));
66099653d4eSeschrock 				return (zfs_error(hdl, EZFS_BADPROP, errbuf));
661fa9e4066Sahrens 			}
662fa9e4066Sahrens 			break;
663fa9e4066Sahrens 
664fa9e4066Sahrens 		case ZFS_PROP_COMPRESSION:
665fa9e4066Sahrens 			for (i = 0; compress_table[i].name != NULL; i++) {
666fa9e4066Sahrens 				if (strcmp(value, compress_table[i].name)
667fa9e4066Sahrens 				    == 0) {
668fa9e4066Sahrens 					number = compress_table[i].value;
669fa9e4066Sahrens 					break;
670fa9e4066Sahrens 				}
671fa9e4066Sahrens 			}
672fa9e4066Sahrens 
673fa9e4066Sahrens 			if (compress_table[i].name == NULL) {
67499653d4eSeschrock 				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
67599653d4eSeschrock 				    "must be 'on', 'off', or 'lzjb'"));
67699653d4eSeschrock 				return (zfs_error(hdl, EZFS_BADPROP, errbuf));
677fa9e4066Sahrens 			}
678fa9e4066Sahrens 			break;
679fa9e4066Sahrens 
680fa9e4066Sahrens 		case ZFS_PROP_SNAPDIR:
681fa9e4066Sahrens 			for (i = 0; snapdir_table[i].name != NULL; i++) {
682fa9e4066Sahrens 				if (strcmp(value, snapdir_table[i].name) == 0) {
683fa9e4066Sahrens 					number = snapdir_table[i].value;
684fa9e4066Sahrens 					break;
685fa9e4066Sahrens 				}
686fa9e4066Sahrens 			}
687fa9e4066Sahrens 
688fa9e4066Sahrens 			if (snapdir_table[i].name == NULL) {
68999653d4eSeschrock 				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
69099653d4eSeschrock 				    "must be 'hidden' or 'visible'"));
69199653d4eSeschrock 				return (zfs_error(hdl, EZFS_BADPROP, errbuf));
692fa9e4066Sahrens 			}
693fa9e4066Sahrens 			break;
694fa9e4066Sahrens 
695fa9e4066Sahrens 		case ZFS_PROP_ACLMODE:
696fa9e4066Sahrens 			for (i = 0; acl_mode_table[i].name != NULL; i++) {
697fa9e4066Sahrens 				if (strcmp(value, acl_mode_table[i].name)
698fa9e4066Sahrens 				    == 0) {
699fa9e4066Sahrens 					number = acl_mode_table[i].value;
700fa9e4066Sahrens 					break;
701fa9e4066Sahrens 				}
702fa9e4066Sahrens 			}
703fa9e4066Sahrens 
704fa9e4066Sahrens 			if (acl_mode_table[i].name == NULL) {
70599653d4eSeschrock 				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
70699653d4eSeschrock 				    "must be 'disacard', 'groupmask', or "
70799653d4eSeschrock 				    "'passthrough'"));
70899653d4eSeschrock 				return (zfs_error(hdl, EZFS_BADPROP, errbuf));
709fa9e4066Sahrens 			}
710fa9e4066Sahrens 			break;
711fa9e4066Sahrens 
712fa9e4066Sahrens 		case ZFS_PROP_ACLINHERIT:
713fa9e4066Sahrens 			for (i = 0; acl_inherit_table[i].name != NULL; i++) {
714fa9e4066Sahrens 				if (strcmp(value, acl_inherit_table[i].name)
715fa9e4066Sahrens 				    == 0) {
716fa9e4066Sahrens 					number = acl_inherit_table[i].value;
717fa9e4066Sahrens 					break;
718fa9e4066Sahrens 				}
719fa9e4066Sahrens 			}
720fa9e4066Sahrens 
721fa9e4066Sahrens 			if (acl_inherit_table[i].name == NULL) {
72299653d4eSeschrock 				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
72399653d4eSeschrock 				    "must be 'discard, 'noallow', 'secure', "
72499653d4eSeschrock 				    "or 'passthrough'"));
72599653d4eSeschrock 				return (zfs_error(hdl, EZFS_BADPROP, errbuf));
726fa9e4066Sahrens 			}
727fa9e4066Sahrens 			break;
728fa9e4066Sahrens 
729fa9e4066Sahrens 		case ZFS_PROP_SHARENFS:
730fa9e4066Sahrens 			/*
731fa9e4066Sahrens 			 * Nothing to do for 'sharenfs', this gets passed on to
732fa9e4066Sahrens 			 * share(1M) verbatim.
733fa9e4066Sahrens 			 */
734fa9e4066Sahrens 			break;
735fa9e4066Sahrens 		}
736fa9e4066Sahrens 	}
737fa9e4066Sahrens 
738fa9e4066Sahrens 	if (intval != NULL)
739fa9e4066Sahrens 		*intval = number;
740fa9e4066Sahrens 
741fa9e4066Sahrens 	return (0);
742fa9e4066Sahrens }
743fa9e4066Sahrens 
744fa9e4066Sahrens /*
745fa9e4066Sahrens  * Given a property name and value, set the property for the given dataset.
746fa9e4066Sahrens  */
747fa9e4066Sahrens int
748fa9e4066Sahrens zfs_prop_set(zfs_handle_t *zhp, zfs_prop_t prop, const char *propval)
749fa9e4066Sahrens {
750fa9e4066Sahrens 	const char *propname = zfs_prop_to_name(prop);
751fa9e4066Sahrens 	uint64_t number;
752fa9e4066Sahrens 	zfs_cmd_t zc = { 0 };
753fa9e4066Sahrens 	int ret;
754fa9e4066Sahrens 	prop_changelist_t *cl;
75599653d4eSeschrock 	char errbuf[1024];
75699653d4eSeschrock 	libzfs_handle_t *hdl = zhp->zfs_hdl;
757fa9e4066Sahrens 
75899653d4eSeschrock 	if (zfs_prop_validate(zhp->zfs_hdl, prop, propval, &number) != 0)
759fa9e4066Sahrens 		return (-1);
760fa9e4066Sahrens 
76199653d4eSeschrock 
76299653d4eSeschrock 	(void) snprintf(errbuf, sizeof (errbuf),
76399653d4eSeschrock 	    dgettext(TEXT_DOMAIN, "cannot set %s for '%s'"), propname,
76499653d4eSeschrock 	    zhp->zfs_name);
76599653d4eSeschrock 
766fa9e4066Sahrens 	/*
767fa9e4066Sahrens 	 * Check to see if the value applies to this type
768fa9e4066Sahrens 	 */
76999653d4eSeschrock 	if (!zfs_prop_valid_for_type(prop, zhp->zfs_type))
77099653d4eSeschrock 		return (zfs_error(hdl, EZFS_PROPTYPE, errbuf));
771fa9e4066Sahrens 
772fa9e4066Sahrens 	/*
773fa9e4066Sahrens 	 * For the mountpoint and sharenfs properties, check if it can be set
774fa9e4066Sahrens 	 * in a global/non-global zone based on the zoned property value:
775fa9e4066Sahrens 	 *
776fa9e4066Sahrens 	 *		global zone	    non-global zone
777fa9e4066Sahrens 	 * -----------------------------------------------------
778fa9e4066Sahrens 	 * zoned=on	mountpoint (no)	    mountpoint (yes)
779fa9e4066Sahrens 	 *		sharenfs (no)	    sharenfs (no)
780fa9e4066Sahrens 	 *
781fa9e4066Sahrens 	 * zoned=off	mountpoint (yes)	N/A
782fa9e4066Sahrens 	 *		sharenfs (yes)
783fa9e4066Sahrens 	 */
784fa9e4066Sahrens 	if (prop == ZFS_PROP_MOUNTPOINT || prop == ZFS_PROP_SHARENFS) {
785fa9e4066Sahrens 		if (zfs_prop_get_int(zhp, ZFS_PROP_ZONED)) {
786fa9e4066Sahrens 			if (getzoneid() == GLOBAL_ZONEID) {
78799653d4eSeschrock 				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
78899653d4eSeschrock 				    "dataset is used in a non-global zone"));
78999653d4eSeschrock 				return (zfs_error(hdl, EZFS_ZONED, errbuf));
790fa9e4066Sahrens 			} else if (prop == ZFS_PROP_SHARENFS) {
79199653d4eSeschrock 				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
79299653d4eSeschrock 				    "filesystems cannot be shared in a "
79399653d4eSeschrock 				    "non-global zone"));
79499653d4eSeschrock 				return (zfs_error(hdl, EZFS_ZONED, errbuf));
795fa9e4066Sahrens 			}
796fa9e4066Sahrens 		} else if (getzoneid() != GLOBAL_ZONEID) {
797fa9e4066Sahrens 			/*
798fa9e4066Sahrens 			 * If zoned property is 'off', this must be in
799fa9e4066Sahrens 			 * a globle zone. If not, something is wrong.
800fa9e4066Sahrens 			 */
80199653d4eSeschrock 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
80299653d4eSeschrock 			    "dataset is used in a non-global zone, but "
80399653d4eSeschrock 			    "'zoned' property is not set"));
80499653d4eSeschrock 			return (zfs_error(hdl, EZFS_ZONED, errbuf));
805fa9e4066Sahrens 		}
806fa9e4066Sahrens 	}
807fa9e4066Sahrens 
808fa9e4066Sahrens 	if ((cl = changelist_gather(zhp, prop, 0)) == NULL)
809fa9e4066Sahrens 		return (-1);
810fa9e4066Sahrens 
811fa9e4066Sahrens 	if (prop == ZFS_PROP_MOUNTPOINT && changelist_haszonedchild(cl)) {
81299653d4eSeschrock 		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
81399653d4eSeschrock 		    "child dataset with inherited mountpoint is used "
81499653d4eSeschrock 		    "in a non-global zone"));
81599653d4eSeschrock 		ret = zfs_error(hdl, EZFS_ZONED, errbuf);
816fa9e4066Sahrens 		goto error;
817fa9e4066Sahrens 	}
818fa9e4066Sahrens 
819fa9e4066Sahrens 	if ((ret = changelist_prefix(cl)) != 0)
820fa9e4066Sahrens 		goto error;
821fa9e4066Sahrens 
822fa9e4066Sahrens 	/*
823fa9e4066Sahrens 	 * Execute the corresponding ioctl() to set this property.
824fa9e4066Sahrens 	 */
825fa9e4066Sahrens 	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
826fa9e4066Sahrens 
827fa9e4066Sahrens 	switch (prop) {
828fa9e4066Sahrens 	case ZFS_PROP_QUOTA:
829fa9e4066Sahrens 		zc.zc_cookie = number;
83099653d4eSeschrock 		ret = ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_SET_QUOTA, &zc);
831fa9e4066Sahrens 		break;
832fa9e4066Sahrens 	case ZFS_PROP_RESERVATION:
833fa9e4066Sahrens 		zc.zc_cookie = number;
83499653d4eSeschrock 		ret = ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_SET_RESERVATION,
83599653d4eSeschrock 		    &zc);
836fa9e4066Sahrens 		break;
837fa9e4066Sahrens 	case ZFS_PROP_MOUNTPOINT:
838fa9e4066Sahrens 	case ZFS_PROP_SHARENFS:
839fa9e4066Sahrens 		/*
840fa9e4066Sahrens 		 * These properties are passed down as real strings.
841fa9e4066Sahrens 		 */
842fa9e4066Sahrens 		(void) strlcpy(zc.zc_prop_name, propname,
843fa9e4066Sahrens 		    sizeof (zc.zc_prop_name));
844fa9e4066Sahrens 		(void) strlcpy(zc.zc_prop_value, propval,
845fa9e4066Sahrens 		    sizeof (zc.zc_prop_value));
846fa9e4066Sahrens 		zc.zc_intsz = 1;
847fa9e4066Sahrens 		zc.zc_numints = strlen(propval) + 1;
84899653d4eSeschrock 		ret = ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_SET_PROP, &zc);
849fa9e4066Sahrens 		break;
850fa9e4066Sahrens 	case ZFS_PROP_VOLSIZE:
851fa9e4066Sahrens 		zc.zc_volsize = number;
85299653d4eSeschrock 		ret = ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_SET_VOLSIZE, &zc);
853fa9e4066Sahrens 		break;
854fa9e4066Sahrens 	case ZFS_PROP_VOLBLOCKSIZE:
855fa9e4066Sahrens 		zc.zc_volblocksize = number;
85699653d4eSeschrock 		ret = ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_SET_VOLBLOCKSIZE,
85799653d4eSeschrock 		    &zc);
858fa9e4066Sahrens 		break;
859fa9e4066Sahrens 	default:
860fa9e4066Sahrens 		(void) strlcpy(zc.zc_prop_name, propname,
861fa9e4066Sahrens 		    sizeof (zc.zc_prop_name));
862fa9e4066Sahrens 		/* LINTED - alignment */
863fa9e4066Sahrens 		*(uint64_t *)zc.zc_prop_value = number;
864fa9e4066Sahrens 		zc.zc_intsz = 8;
865fa9e4066Sahrens 		zc.zc_numints = 1;
86699653d4eSeschrock 		ret = ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_SET_PROP, &zc);
867fa9e4066Sahrens 		break;
868fa9e4066Sahrens 	}
869fa9e4066Sahrens 
870fa9e4066Sahrens 	if (ret != 0) {
871fa9e4066Sahrens 		switch (errno) {
872fa9e4066Sahrens 
873fa9e4066Sahrens 		case ENOSPC:
874fa9e4066Sahrens 			/*
875fa9e4066Sahrens 			 * For quotas and reservations, ENOSPC indicates
876fa9e4066Sahrens 			 * something different; setting a quota or reservation
877fa9e4066Sahrens 			 * doesn't use any disk space.
878fa9e4066Sahrens 			 */
879fa9e4066Sahrens 			switch (prop) {
880fa9e4066Sahrens 			case ZFS_PROP_QUOTA:
88199653d4eSeschrock 				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
88299653d4eSeschrock 				    "size is less than current used or "
88399653d4eSeschrock 				    "reserved space"));
88499653d4eSeschrock 				(void) zfs_error(hdl, EZFS_PROPSPACE, errbuf);
885fa9e4066Sahrens 				break;
886fa9e4066Sahrens 
887fa9e4066Sahrens 			case ZFS_PROP_RESERVATION:
88899653d4eSeschrock 				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
88999653d4eSeschrock 				    "size is greater than available space"));
89099653d4eSeschrock 				(void) zfs_error(hdl, EZFS_PROPSPACE, errbuf);
891fa9e4066Sahrens 				break;
892fa9e4066Sahrens 
893fa9e4066Sahrens 			default:
89499653d4eSeschrock 				(void) zfs_standard_error(hdl, errno, errbuf);
895fa9e4066Sahrens 				break;
896fa9e4066Sahrens 			}
897fa9e4066Sahrens 			break;
898fa9e4066Sahrens 
899fa9e4066Sahrens 		case EBUSY:
90099653d4eSeschrock 			if (prop == ZFS_PROP_VOLBLOCKSIZE)
90199653d4eSeschrock 				(void) zfs_error(hdl, EZFS_VOLHASDATA, errbuf);
90299653d4eSeschrock 			else
90399653d4eSeschrock 				return (zfs_standard_error(hdl, EBUSY, errbuf));
904fa9e4066Sahrens 			break;
905fa9e4066Sahrens 
9062a79c5feSlling 		case EROFS:
90799653d4eSeschrock 			(void) zfs_error(hdl, EZFS_DSREADONLY, errbuf);
9082a79c5feSlling 			break;
9092a79c5feSlling 
910fa9e4066Sahrens 		case EOVERFLOW:
911fa9e4066Sahrens 			/*
912fa9e4066Sahrens 			 * This platform can't address a volume this big.
913fa9e4066Sahrens 			 */
914fa9e4066Sahrens #ifdef _ILP32
915fa9e4066Sahrens 			if (prop == ZFS_PROP_VOLSIZE) {
91699653d4eSeschrock 				(void) zfs_error(hdl, EZFS_VOLTOOBIG, errbuf);
917fa9e4066Sahrens 				break;
918fa9e4066Sahrens 			}
919fa9e4066Sahrens #endif
92099653d4eSeschrock 			/* FALLTHROUGH */
921fa9e4066Sahrens 		default:
92299653d4eSeschrock 			(void) zfs_standard_error(hdl, errno, errbuf);
923fa9e4066Sahrens 		}
924fa9e4066Sahrens 	} else {
925fa9e4066Sahrens 		/*
926fa9e4066Sahrens 		 * Refresh the statistics so the new property value
927fa9e4066Sahrens 		 * is reflected.
928fa9e4066Sahrens 		 */
929fa9e4066Sahrens 		if ((ret = changelist_postfix(cl)) != 0)
930fa9e4066Sahrens 			goto error;
931fa9e4066Sahrens 
932fa9e4066Sahrens 		(void) get_stats(zhp);
933fa9e4066Sahrens 	}
934fa9e4066Sahrens 
935fa9e4066Sahrens error:
936fa9e4066Sahrens 	changelist_free(cl);
937fa9e4066Sahrens 	return (ret);
938fa9e4066Sahrens }
939fa9e4066Sahrens 
940fa9e4066Sahrens /*
941fa9e4066Sahrens  * Given a property, inherit the value from the parent dataset.
942fa9e4066Sahrens  */
943fa9e4066Sahrens int
944fa9e4066Sahrens zfs_prop_inherit(zfs_handle_t *zhp, zfs_prop_t prop)
945fa9e4066Sahrens {
946fa9e4066Sahrens 	const char *propname = zfs_prop_to_name(prop);
947fa9e4066Sahrens 	zfs_cmd_t zc = { 0 };
948fa9e4066Sahrens 	int ret;
949fa9e4066Sahrens 	prop_changelist_t *cl;
95099653d4eSeschrock 	libzfs_handle_t *hdl = zhp->zfs_hdl;
95199653d4eSeschrock 	char errbuf[1024];
95299653d4eSeschrock 
95399653d4eSeschrock 	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
95499653d4eSeschrock 	    "cannot inherit %s for '%s'"), propname, zhp->zfs_name);
955fa9e4066Sahrens 
956fa9e4066Sahrens 	/*
957fa9e4066Sahrens 	 * Verify that this property is inheritable.
958fa9e4066Sahrens 	 */
95999653d4eSeschrock 	if (zfs_prop_readonly(prop))
96099653d4eSeschrock 		return (zfs_error(hdl, EZFS_PROPREADONLY, errbuf));
961fa9e4066Sahrens 
96299653d4eSeschrock 	if (!zfs_prop_inheritable(prop))
96399653d4eSeschrock 		return (zfs_error(hdl, EZFS_PROPNONINHERIT, errbuf));
964fa9e4066Sahrens 
965fa9e4066Sahrens 	/*
966fa9e4066Sahrens 	 * Check to see if the value applies to this type
967fa9e4066Sahrens 	 */
96899653d4eSeschrock 	if (!zfs_prop_valid_for_type(prop, zhp->zfs_type))
96999653d4eSeschrock 		return (zfs_error(hdl, EZFS_PROPTYPE, errbuf));
970fa9e4066Sahrens 
971fa9e4066Sahrens 	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
972fa9e4066Sahrens 	(void) strlcpy(zc.zc_prop_name, propname, sizeof (zc.zc_prop_name));
973fa9e4066Sahrens 
974fa9e4066Sahrens 	if (prop == ZFS_PROP_MOUNTPOINT && getzoneid() == GLOBAL_ZONEID &&
975fa9e4066Sahrens 	    zfs_prop_get_int(zhp, ZFS_PROP_ZONED)) {
97699653d4eSeschrock 		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
97799653d4eSeschrock 		    "dataset is used in a non-global zone"));
97899653d4eSeschrock 		return (zfs_error(hdl, EZFS_ZONED, errbuf));
979fa9e4066Sahrens 	}
980fa9e4066Sahrens 
981fa9e4066Sahrens 	/*
982fa9e4066Sahrens 	 * Determine datasets which will be affected by this change, if any.
983fa9e4066Sahrens 	 */
984fa9e4066Sahrens 	if ((cl = changelist_gather(zhp, prop, 0)) == NULL)
985fa9e4066Sahrens 		return (-1);
986fa9e4066Sahrens 
987fa9e4066Sahrens 	if (prop == ZFS_PROP_MOUNTPOINT && changelist_haszonedchild(cl)) {
98899653d4eSeschrock 		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
98999653d4eSeschrock 		    "child dataset with inherited mountpoint is used "
99099653d4eSeschrock 		    "in a non-global zone"));
99199653d4eSeschrock 		ret = zfs_error(hdl, EZFS_ZONED, errbuf);
992fa9e4066Sahrens 		goto error;
993fa9e4066Sahrens 	}
994fa9e4066Sahrens 
995fa9e4066Sahrens 	if ((ret = changelist_prefix(cl)) != 0)
996fa9e4066Sahrens 		goto error;
997fa9e4066Sahrens 
998fa9e4066Sahrens 	zc.zc_numints = 0;
999fa9e4066Sahrens 
100099653d4eSeschrock 	if ((ret = ioctl(zhp->zfs_hdl->libzfs_fd,
100199653d4eSeschrock 	    ZFS_IOC_SET_PROP, &zc)) != 0) {
100299653d4eSeschrock 		return (zfs_standard_error(hdl, errno, errbuf));
1003fa9e4066Sahrens 	} else {
1004fa9e4066Sahrens 
1005efc555ebSnd 		if ((ret = changelist_postfix(cl)) != 0)
1006fa9e4066Sahrens 			goto error;
1007fa9e4066Sahrens 
1008fa9e4066Sahrens 		/*
1009fa9e4066Sahrens 		 * Refresh the statistics so the new property is reflected.
1010fa9e4066Sahrens 		 */
1011fa9e4066Sahrens 		(void) get_stats(zhp);
1012fa9e4066Sahrens 	}
1013fa9e4066Sahrens 
1014fa9e4066Sahrens 
1015fa9e4066Sahrens error:
1016fa9e4066Sahrens 	changelist_free(cl);
1017fa9e4066Sahrens 	return (ret);
1018fa9e4066Sahrens }
1019fa9e4066Sahrens 
1020fa9e4066Sahrens static void
1021fa9e4066Sahrens nicebool(int value, char *buf, size_t buflen)
1022fa9e4066Sahrens {
1023fa9e4066Sahrens 	if (value)
1024fa9e4066Sahrens 		(void) strlcpy(buf, "on", buflen);
1025fa9e4066Sahrens 	else
1026fa9e4066Sahrens 		(void) strlcpy(buf, "off", buflen);
1027fa9e4066Sahrens }
1028fa9e4066Sahrens 
10297f7322feSeschrock /*
10307f7322feSeschrock  * True DSL properties are stored in an nvlist.  The following two functions
10317f7322feSeschrock  * extract them appropriately.
10327f7322feSeschrock  */
10337f7322feSeschrock static uint64_t
10347f7322feSeschrock getprop_uint64(zfs_handle_t *zhp, zfs_prop_t prop, char **source)
10357f7322feSeschrock {
10367f7322feSeschrock 	nvlist_t *nv;
10377f7322feSeschrock 	uint64_t value;
10387f7322feSeschrock 
10397f7322feSeschrock 	if (nvlist_lookup_nvlist(zhp->zfs_props,
10407f7322feSeschrock 	    zfs_prop_to_name(prop), &nv) == 0) {
10417f7322feSeschrock 		verify(nvlist_lookup_uint64(nv, ZFS_PROP_VALUE, &value) == 0);
10427f7322feSeschrock 		verify(nvlist_lookup_string(nv, ZFS_PROP_SOURCE, source) == 0);
10437f7322feSeschrock 	} else {
10447f7322feSeschrock 		value = zfs_prop_default_numeric(prop);
10457f7322feSeschrock 		*source = "";
10467f7322feSeschrock 	}
10477f7322feSeschrock 
10487f7322feSeschrock 	return (value);
10497f7322feSeschrock }
10507f7322feSeschrock 
10517f7322feSeschrock static char *
10527f7322feSeschrock getprop_string(zfs_handle_t *zhp, zfs_prop_t prop, char **source)
10537f7322feSeschrock {
10547f7322feSeschrock 	nvlist_t *nv;
10557f7322feSeschrock 	char *value;
10567f7322feSeschrock 
10577f7322feSeschrock 	if (nvlist_lookup_nvlist(zhp->zfs_props,
10587f7322feSeschrock 	    zfs_prop_to_name(prop), &nv) == 0) {
10597f7322feSeschrock 		verify(nvlist_lookup_string(nv, ZFS_PROP_VALUE, &value) == 0);
10607f7322feSeschrock 		verify(nvlist_lookup_string(nv, ZFS_PROP_SOURCE, source) == 0);
10617f7322feSeschrock 	} else {
10627f7322feSeschrock 		if ((value = (char *)zfs_prop_default_string(prop)) == NULL)
10637f7322feSeschrock 			value = "";
10647f7322feSeschrock 		*source = "";
10657f7322feSeschrock 	}
10667f7322feSeschrock 
10677f7322feSeschrock 	return (value);
10687f7322feSeschrock }
10697f7322feSeschrock 
1070fa9e4066Sahrens /*
1071fa9e4066Sahrens  * Internal function for getting a numeric property.  Both zfs_prop_get() and
1072fa9e4066Sahrens  * zfs_prop_get_int() are built using this interface.
1073fa9e4066Sahrens  *
1074fa9e4066Sahrens  * Certain properties can be overridden using 'mount -o'.  In this case, scan
1075fa9e4066Sahrens  * the contents of the /etc/mnttab entry, searching for the appropriate options.
1076fa9e4066Sahrens  * If they differ from the on-disk values, report the current values and mark
1077fa9e4066Sahrens  * the source "temporary".
1078fa9e4066Sahrens  */
107999653d4eSeschrock static int
1080fa9e4066Sahrens get_numeric_property(zfs_handle_t *zhp, zfs_prop_t prop, zfs_source_t *src,
108199653d4eSeschrock     char **source, uint64_t *val)
1082fa9e4066Sahrens {
1083fa9e4066Sahrens 	struct mnttab mnt;
1084fa9e4066Sahrens 
1085fa9e4066Sahrens 	*source = NULL;
1086fa9e4066Sahrens 
1087fa9e4066Sahrens 	if (zhp->zfs_mntopts == NULL)
1088fa9e4066Sahrens 		mnt.mnt_mntopts = "";
1089fa9e4066Sahrens 	else
1090fa9e4066Sahrens 		mnt.mnt_mntopts = zhp->zfs_mntopts;
1091fa9e4066Sahrens 
1092fa9e4066Sahrens 	switch (prop) {
1093fa9e4066Sahrens 	case ZFS_PROP_ATIME:
109499653d4eSeschrock 		*val = getprop_uint64(zhp, prop, source);
1095fa9e4066Sahrens 
109699653d4eSeschrock 		if (hasmntopt(&mnt, MNTOPT_ATIME) && !*val) {
109799653d4eSeschrock 			*val = B_TRUE;
1098fa9e4066Sahrens 			if (src)
1099fa9e4066Sahrens 				*src = ZFS_SRC_TEMPORARY;
110099653d4eSeschrock 		} else if (hasmntopt(&mnt, MNTOPT_NOATIME) && *val) {
110199653d4eSeschrock 			*val = B_FALSE;
1102fa9e4066Sahrens 			if (src)
1103fa9e4066Sahrens 				*src = ZFS_SRC_TEMPORARY;
1104fa9e4066Sahrens 		}
110599653d4eSeschrock 		break;
1106fa9e4066Sahrens 
1107fa9e4066Sahrens 	case ZFS_PROP_AVAILABLE:
110899653d4eSeschrock 		*val = zhp->zfs_dmustats.dds_available;
110999653d4eSeschrock 		break;
1110fa9e4066Sahrens 
1111fa9e4066Sahrens 	case ZFS_PROP_DEVICES:
111299653d4eSeschrock 		*val = getprop_uint64(zhp, prop, source);
1113fa9e4066Sahrens 
111499653d4eSeschrock 		if (hasmntopt(&mnt, MNTOPT_DEVICES) && !*val) {
111599653d4eSeschrock 			*val = B_TRUE;
1116fa9e4066Sahrens 			if (src)
1117fa9e4066Sahrens 				*src = ZFS_SRC_TEMPORARY;
111899653d4eSeschrock 		} else if (hasmntopt(&mnt, MNTOPT_NODEVICES) && *val) {
111999653d4eSeschrock 			*val = B_FALSE;
1120fa9e4066Sahrens 			if (src)
1121fa9e4066Sahrens 				*src = ZFS_SRC_TEMPORARY;
1122fa9e4066Sahrens 		}
112399653d4eSeschrock 		break;
1124fa9e4066Sahrens 
1125fa9e4066Sahrens 	case ZFS_PROP_EXEC:
112699653d4eSeschrock 		*val = getprop_uint64(zhp, prop, source);
1127fa9e4066Sahrens 
112899653d4eSeschrock 		if (hasmntopt(&mnt, MNTOPT_EXEC) && !*val) {
112999653d4eSeschrock 			*val = B_TRUE;
1130fa9e4066Sahrens 			if (src)
1131fa9e4066Sahrens 				*src = ZFS_SRC_TEMPORARY;
113299653d4eSeschrock 		} else if (hasmntopt(&mnt, MNTOPT_NOEXEC) && *val) {
113399653d4eSeschrock 			*val = B_FALSE;
1134fa9e4066Sahrens 			if (src)
1135fa9e4066Sahrens 				*src = ZFS_SRC_TEMPORARY;
1136fa9e4066Sahrens 		}
113799653d4eSeschrock 		break;
1138fa9e4066Sahrens 
1139fa9e4066Sahrens 	case ZFS_PROP_RECORDSIZE:
1140fa9e4066Sahrens 	case ZFS_PROP_COMPRESSION:
11417f7322feSeschrock 	case ZFS_PROP_ZONED:
114299653d4eSeschrock 		*val = getprop_uint64(zhp, prop, source);
114399653d4eSeschrock 		break;
1144fa9e4066Sahrens 
1145fa9e4066Sahrens 	case ZFS_PROP_READONLY:
114699653d4eSeschrock 		*val = getprop_uint64(zhp, prop, source);
1147fa9e4066Sahrens 
114899653d4eSeschrock 		if (hasmntopt(&mnt, MNTOPT_RO) && !*val) {
114999653d4eSeschrock 			*val = B_TRUE;
1150fa9e4066Sahrens 			if (src)
1151fa9e4066Sahrens 				*src = ZFS_SRC_TEMPORARY;
115299653d4eSeschrock 		} else if (hasmntopt(&mnt, MNTOPT_RW) && *val) {
115399653d4eSeschrock 			*val = B_FALSE;
1154fa9e4066Sahrens 			if (src)
1155fa9e4066Sahrens 				*src = ZFS_SRC_TEMPORARY;
1156fa9e4066Sahrens 		}
115799653d4eSeschrock 		break;
1158fa9e4066Sahrens 
1159ea8dc4b6Seschrock 	case ZFS_PROP_CREATION:
116099653d4eSeschrock 		*val = zhp->zfs_dmustats.dds_creation_time;
116199653d4eSeschrock 		break;
1162ea8dc4b6Seschrock 
1163fa9e4066Sahrens 	case ZFS_PROP_QUOTA:
1164fa9e4066Sahrens 		if (zhp->zfs_dmustats.dds_quota == 0)
1165fa9e4066Sahrens 			*source = "";	/* default */
1166fa9e4066Sahrens 		else
1167fa9e4066Sahrens 			*source = zhp->zfs_name;
116899653d4eSeschrock 		*val = zhp->zfs_dmustats.dds_quota;
116999653d4eSeschrock 		break;
1170fa9e4066Sahrens 
1171fa9e4066Sahrens 	case ZFS_PROP_RESERVATION:
1172fa9e4066Sahrens 		if (zhp->zfs_dmustats.dds_reserved == 0)
1173fa9e4066Sahrens 			*source = "";	/* default */
1174fa9e4066Sahrens 		else
1175fa9e4066Sahrens 			*source = zhp->zfs_name;
117699653d4eSeschrock 		*val = zhp->zfs_dmustats.dds_reserved;
117799653d4eSeschrock 		break;
1178fa9e4066Sahrens 
1179fa9e4066Sahrens 	case ZFS_PROP_COMPRESSRATIO:
1180fa9e4066Sahrens 		/*
1181fa9e4066Sahrens 		 * Using physical space and logical space, calculate the
1182fa9e4066Sahrens 		 * compression ratio.  We return the number as a multiple of
1183fa9e4066Sahrens 		 * 100, so '2.5x' would be returned as 250.
1184fa9e4066Sahrens 		 */
1185fa9e4066Sahrens 		if (zhp->zfs_dmustats.dds_compressed_bytes == 0)
118699653d4eSeschrock 			*val = 100ULL;
1187fa9e4066Sahrens 		else
118899653d4eSeschrock 			*val =
118999653d4eSeschrock 			    (zhp->zfs_dmustats.dds_uncompressed_bytes * 100 /
1190fa9e4066Sahrens 			    zhp->zfs_dmustats.dds_compressed_bytes);
119199653d4eSeschrock 		break;
1192fa9e4066Sahrens 
1193fa9e4066Sahrens 	case ZFS_PROP_REFERENCED:
1194fa9e4066Sahrens 		/*
1195fa9e4066Sahrens 		 * 'referenced' refers to the amount of physical space
1196fa9e4066Sahrens 		 * referenced (possibly shared) by this object.
1197fa9e4066Sahrens 		 */
119899653d4eSeschrock 		*val = zhp->zfs_dmustats.dds_space_refd;
119999653d4eSeschrock 		break;
1200fa9e4066Sahrens 
1201fa9e4066Sahrens 	case ZFS_PROP_SETUID:
120299653d4eSeschrock 		*val = getprop_uint64(zhp, prop, source);
1203fa9e4066Sahrens 
120499653d4eSeschrock 		if (hasmntopt(&mnt, MNTOPT_SETUID) && !*val) {
120599653d4eSeschrock 			*val = B_TRUE;
1206fa9e4066Sahrens 			if (src)
1207fa9e4066Sahrens 				*src = ZFS_SRC_TEMPORARY;
120899653d4eSeschrock 		} else if (hasmntopt(&mnt, MNTOPT_NOSETUID) && *val) {
120999653d4eSeschrock 			*val = B_FALSE;
1210fa9e4066Sahrens 			if (src)
1211fa9e4066Sahrens 				*src = ZFS_SRC_TEMPORARY;
1212fa9e4066Sahrens 		}
121399653d4eSeschrock 		break;
1214fa9e4066Sahrens 
1215fa9e4066Sahrens 	case ZFS_PROP_VOLSIZE:
121699653d4eSeschrock 		*val = zhp->zfs_volsize;
121799653d4eSeschrock 		break;
1218fa9e4066Sahrens 
1219fa9e4066Sahrens 	case ZFS_PROP_VOLBLOCKSIZE:
122099653d4eSeschrock 		*val = zhp->zfs_volblocksize;
122199653d4eSeschrock 		break;
1222fa9e4066Sahrens 
1223fa9e4066Sahrens 	case ZFS_PROP_USED:
122499653d4eSeschrock 		*val = zhp->zfs_dmustats.dds_space_used;
122599653d4eSeschrock 		break;
1226fa9e4066Sahrens 
1227fa9e4066Sahrens 	case ZFS_PROP_CREATETXG:
122899653d4eSeschrock 		*val = zhp->zfs_dmustats.dds_creation_txg;
122999653d4eSeschrock 		break;
1230fa9e4066Sahrens 
1231fa9e4066Sahrens 	case ZFS_PROP_MOUNTED:
1232fa9e4066Sahrens 		/*
1233fa9e4066Sahrens 		 * Unlike other properties, we defer calculation of 'MOUNTED'
1234fa9e4066Sahrens 		 * until actually requested.  This is because the getmntany()
1235fa9e4066Sahrens 		 * call can be extremely expensive on systems with a large
1236fa9e4066Sahrens 		 * number of filesystems, and the property isn't needed in
1237fa9e4066Sahrens 		 * normal use cases.
1238fa9e4066Sahrens 		 */
1239fa9e4066Sahrens 		if (zhp->zfs_mntopts == NULL) {
1240fa9e4066Sahrens 			struct mnttab search = { 0 }, entry;
1241fa9e4066Sahrens 
1242fa9e4066Sahrens 			search.mnt_special = (char *)zhp->zfs_name;
124396dedd18Snd 			search.mnt_fstype = MNTTYPE_ZFS;
124499653d4eSeschrock 			rewind(zhp->zfs_hdl->libzfs_mnttab);
1245fa9e4066Sahrens 
124699653d4eSeschrock 			if (getmntany(zhp->zfs_hdl->libzfs_mnttab, &entry,
124799653d4eSeschrock 			    &search) == 0 && (zhp->zfs_mntopts =
124899653d4eSeschrock 			    zfs_strdup(zhp->zfs_hdl,
124999653d4eSeschrock 			    entry.mnt_mntopts)) == NULL)
125099653d4eSeschrock 				return (-1);
1251fa9e4066Sahrens 		}
125299653d4eSeschrock 		*val = (zhp->zfs_mntopts != NULL);
125399653d4eSeschrock 		break;
1254fa9e4066Sahrens 
1255fa9e4066Sahrens 	default:
125699653d4eSeschrock 		zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
125799653d4eSeschrock 		    "cannot get non-numeric property"));
125899653d4eSeschrock 		return (zfs_error(zhp->zfs_hdl, EZFS_BADPROP,
125999653d4eSeschrock 		    dgettext(TEXT_DOMAIN, "internal error")));
1260fa9e4066Sahrens 	}
1261fa9e4066Sahrens 
1262fa9e4066Sahrens 	return (0);
1263fa9e4066Sahrens }
1264fa9e4066Sahrens 
1265fa9e4066Sahrens /*
1266fa9e4066Sahrens  * Calculate the source type, given the raw source string.
1267fa9e4066Sahrens  */
1268fa9e4066Sahrens static void
1269fa9e4066Sahrens get_source(zfs_handle_t *zhp, zfs_source_t *srctype, char *source,
1270fa9e4066Sahrens     char *statbuf, size_t statlen)
1271fa9e4066Sahrens {
1272fa9e4066Sahrens 	if (statbuf == NULL || *srctype == ZFS_SRC_TEMPORARY)
1273fa9e4066Sahrens 		return;
1274fa9e4066Sahrens 
1275fa9e4066Sahrens 	if (source == NULL) {
1276fa9e4066Sahrens 		*srctype = ZFS_SRC_NONE;
1277fa9e4066Sahrens 	} else if (source[0] == '\0') {
1278fa9e4066Sahrens 		*srctype = ZFS_SRC_DEFAULT;
1279fa9e4066Sahrens 	} else {
1280fa9e4066Sahrens 		if (strcmp(source, zhp->zfs_name) == 0) {
1281fa9e4066Sahrens 			*srctype = ZFS_SRC_LOCAL;
1282fa9e4066Sahrens 		} else {
1283fa9e4066Sahrens 			(void) strlcpy(statbuf, source, statlen);
1284fa9e4066Sahrens 			*srctype = ZFS_SRC_INHERITED;
1285fa9e4066Sahrens 		}
1286fa9e4066Sahrens 	}
1287fa9e4066Sahrens 
1288fa9e4066Sahrens }
1289fa9e4066Sahrens 
1290fa9e4066Sahrens /*
1291fa9e4066Sahrens  * Retrieve a property from the given object.  If 'literal' is specified, then
1292fa9e4066Sahrens  * numbers are left as exact values.  Otherwise, numbers are converted to a
1293fa9e4066Sahrens  * human-readable form.
1294fa9e4066Sahrens  *
1295fa9e4066Sahrens  * Returns 0 on success, or -1 on error.
1296fa9e4066Sahrens  */
1297fa9e4066Sahrens int
1298fa9e4066Sahrens zfs_prop_get(zfs_handle_t *zhp, zfs_prop_t prop, char *propbuf, size_t proplen,
129999653d4eSeschrock     zfs_source_t *src, char *statbuf, size_t statlen, boolean_t literal)
1300fa9e4066Sahrens {
1301fa9e4066Sahrens 	char *source = NULL;
1302fa9e4066Sahrens 	uint64_t val;
1303fa9e4066Sahrens 	char *str;
1304fa9e4066Sahrens 	int i;
1305fa9e4066Sahrens 	const char *root;
1306fa9e4066Sahrens 
1307fa9e4066Sahrens 	/*
1308fa9e4066Sahrens 	 * Check to see if this property applies to our object
1309fa9e4066Sahrens 	 */
1310fa9e4066Sahrens 	if (!zfs_prop_valid_for_type(prop, zhp->zfs_type))
1311fa9e4066Sahrens 		return (-1);
1312fa9e4066Sahrens 
1313fa9e4066Sahrens 	if (src)
1314fa9e4066Sahrens 		*src = ZFS_SRC_NONE;
1315fa9e4066Sahrens 
1316fa9e4066Sahrens 	switch (prop) {
1317fa9e4066Sahrens 	case ZFS_PROP_ATIME:
1318fa9e4066Sahrens 	case ZFS_PROP_READONLY:
1319fa9e4066Sahrens 	case ZFS_PROP_SETUID:
1320fa9e4066Sahrens 	case ZFS_PROP_ZONED:
1321fa9e4066Sahrens 	case ZFS_PROP_DEVICES:
1322fa9e4066Sahrens 	case ZFS_PROP_EXEC:
1323fa9e4066Sahrens 		/*
1324fa9e4066Sahrens 		 * Basic boolean values are built on top of
1325fa9e4066Sahrens 		 * get_numeric_property().
1326fa9e4066Sahrens 		 */
132799653d4eSeschrock 		if (get_numeric_property(zhp, prop, src, &source, &val) != 0)
132899653d4eSeschrock 			return (-1);
132999653d4eSeschrock 		nicebool(val, propbuf, proplen);
1330fa9e4066Sahrens 
1331fa9e4066Sahrens 		break;
1332fa9e4066Sahrens 
1333fa9e4066Sahrens 	case ZFS_PROP_AVAILABLE:
1334fa9e4066Sahrens 	case ZFS_PROP_RECORDSIZE:
1335fa9e4066Sahrens 	case ZFS_PROP_CREATETXG:
1336fa9e4066Sahrens 	case ZFS_PROP_REFERENCED:
1337fa9e4066Sahrens 	case ZFS_PROP_USED:
1338fa9e4066Sahrens 	case ZFS_PROP_VOLSIZE:
1339fa9e4066Sahrens 	case ZFS_PROP_VOLBLOCKSIZE:
1340fa9e4066Sahrens 		/*
1341fa9e4066Sahrens 		 * Basic numeric values are built on top of
1342fa9e4066Sahrens 		 * get_numeric_property().
1343fa9e4066Sahrens 		 */
134499653d4eSeschrock 		if (get_numeric_property(zhp, prop, src, &source, &val) != 0)
134599653d4eSeschrock 			return (-1);
1346fa9e4066Sahrens 		if (literal)
1347fa9e4066Sahrens 			(void) snprintf(propbuf, proplen, "%llu", val);
1348fa9e4066Sahrens 		else
1349fa9e4066Sahrens 			zfs_nicenum(val, propbuf, proplen);
1350fa9e4066Sahrens 		break;
1351fa9e4066Sahrens 
1352fa9e4066Sahrens 	case ZFS_PROP_COMPRESSION:
13537f7322feSeschrock 		val = getprop_uint64(zhp, prop, &source);
1354fa9e4066Sahrens 		for (i = 0; compress_table[i].name != NULL; i++) {
13557f7322feSeschrock 			if (compress_table[i].value == val)
1356fa9e4066Sahrens 				break;
1357fa9e4066Sahrens 		}
1358fa9e4066Sahrens 		assert(compress_table[i].name != NULL);
1359fa9e4066Sahrens 		(void) strlcpy(propbuf, compress_table[i].name, proplen);
1360fa9e4066Sahrens 		break;
1361fa9e4066Sahrens 
1362fa9e4066Sahrens 	case ZFS_PROP_CHECKSUM:
13637f7322feSeschrock 		val = getprop_uint64(zhp, prop, &source);
1364fa9e4066Sahrens 		for (i = 0; checksum_table[i].name != NULL; i++) {
13657f7322feSeschrock 			if (checksum_table[i].value == val)
1366fa9e4066Sahrens 				break;
1367fa9e4066Sahrens 		}
1368fa9e4066Sahrens 		assert(checksum_table[i].name != NULL);
1369fa9e4066Sahrens 		(void) strlcpy(propbuf, checksum_table[i].name, proplen);
1370fa9e4066Sahrens 		break;
1371fa9e4066Sahrens 
1372fa9e4066Sahrens 	case ZFS_PROP_SNAPDIR:
13737f7322feSeschrock 		val = getprop_uint64(zhp, prop, &source);
1374fa9e4066Sahrens 		for (i = 0; snapdir_table[i].name != NULL; i++) {
13757f7322feSeschrock 			if (snapdir_table[i].value == val)
1376fa9e4066Sahrens 				break;
1377fa9e4066Sahrens 		}
1378fa9e4066Sahrens 		assert(snapdir_table[i].name != NULL);
1379fa9e4066Sahrens 		(void) strlcpy(propbuf, snapdir_table[i].name, proplen);
1380fa9e4066Sahrens 		break;
1381fa9e4066Sahrens 
1382fa9e4066Sahrens 	case ZFS_PROP_ACLMODE:
13837f7322feSeschrock 		val = getprop_uint64(zhp, prop, &source);
1384fa9e4066Sahrens 		for (i = 0; acl_mode_table[i].name != NULL; i++) {
13857f7322feSeschrock 			if (acl_mode_table[i].value == val)
1386fa9e4066Sahrens 				break;
1387fa9e4066Sahrens 		}
1388fa9e4066Sahrens 		assert(acl_mode_table[i].name != NULL);
1389fa9e4066Sahrens 		(void) strlcpy(propbuf, acl_mode_table[i].name, proplen);
1390fa9e4066Sahrens 		break;
1391fa9e4066Sahrens 
1392fa9e4066Sahrens 	case ZFS_PROP_ACLINHERIT:
13937f7322feSeschrock 		val = getprop_uint64(zhp, prop, &source);
1394fa9e4066Sahrens 		for (i = 0; acl_inherit_table[i].name != NULL; i++) {
13957f7322feSeschrock 			if (acl_inherit_table[i].value == val)
1396fa9e4066Sahrens 				break;
1397fa9e4066Sahrens 		}
1398fa9e4066Sahrens 		assert(acl_inherit_table[i].name != NULL);
1399fa9e4066Sahrens 		(void) strlcpy(propbuf, acl_inherit_table[i].name, proplen);
1400fa9e4066Sahrens 		break;
1401fa9e4066Sahrens 
1402fa9e4066Sahrens 	case ZFS_PROP_CREATION:
1403fa9e4066Sahrens 		/*
1404fa9e4066Sahrens 		 * 'creation' is a time_t stored in the statistics.  We convert
1405fa9e4066Sahrens 		 * this into a string unless 'literal' is specified.
1406fa9e4066Sahrens 		 */
1407fa9e4066Sahrens 		{
1408fa9e4066Sahrens 			time_t time = (time_t)
1409fa9e4066Sahrens 			    zhp->zfs_dmustats.dds_creation_time;
1410fa9e4066Sahrens 			struct tm t;
1411fa9e4066Sahrens 
1412fa9e4066Sahrens 			if (literal ||
1413fa9e4066Sahrens 			    localtime_r(&time, &t) == NULL ||
1414fa9e4066Sahrens 			    strftime(propbuf, proplen, "%a %b %e %k:%M %Y",
1415fa9e4066Sahrens 			    &t) == 0)
1416fa9e4066Sahrens 				(void) snprintf(propbuf, proplen, "%llu",
1417fa9e4066Sahrens 				    zhp->zfs_dmustats.dds_creation_time);
1418fa9e4066Sahrens 		}
1419fa9e4066Sahrens 		break;
1420fa9e4066Sahrens 
1421fa9e4066Sahrens 	case ZFS_PROP_MOUNTPOINT:
1422fa9e4066Sahrens 		/*
1423fa9e4066Sahrens 		 * Getting the precise mountpoint can be tricky.
1424fa9e4066Sahrens 		 *
1425fa9e4066Sahrens 		 *  - for 'none' or 'legacy', return those values.
1426fa9e4066Sahrens 		 *  - for default mountpoints, construct it as /zfs/<dataset>
1427fa9e4066Sahrens 		 *  - for inherited mountpoints, we want to take everything
1428fa9e4066Sahrens 		 *    after our ancestor and append it to the inherited value.
1429fa9e4066Sahrens 		 *
1430fa9e4066Sahrens 		 * If the pool has an alternate root, we want to prepend that
1431fa9e4066Sahrens 		 * root to any values we return.
1432fa9e4066Sahrens 		 */
1433ea8dc4b6Seschrock 		root = zhp->zfs_root;
14347f7322feSeschrock 		str = getprop_string(zhp, prop, &source);
1435fa9e4066Sahrens 
14367f7322feSeschrock 		if (str[0] == '\0') {
1437fa9e4066Sahrens 			(void) snprintf(propbuf, proplen, "%s/zfs/%s",
1438fa9e4066Sahrens 			    root, zhp->zfs_name);
14397f7322feSeschrock 		} else if (str[0] == '/') {
14407f7322feSeschrock 			const char *relpath = zhp->zfs_name + strlen(source);
1441fa9e4066Sahrens 
1442fa9e4066Sahrens 			if (relpath[0] == '/')
1443fa9e4066Sahrens 				relpath++;
14447f7322feSeschrock 			if (str[1] == '\0')
14457f7322feSeschrock 				str++;
1446fa9e4066Sahrens 
1447fa9e4066Sahrens 			if (relpath[0] == '\0')
1448fa9e4066Sahrens 				(void) snprintf(propbuf, proplen, "%s%s",
14497f7322feSeschrock 				    root, str);
1450fa9e4066Sahrens 			else
1451fa9e4066Sahrens 				(void) snprintf(propbuf, proplen, "%s%s%s%s",
14527f7322feSeschrock 				    root, str, relpath[0] == '@' ? "" : "/",
1453fa9e4066Sahrens 				    relpath);
1454fa9e4066Sahrens 		} else {
1455fa9e4066Sahrens 			/* 'legacy' or 'none' */
14567f7322feSeschrock 			(void) strlcpy(propbuf, str, proplen);
1457fa9e4066Sahrens 		}
1458fa9e4066Sahrens 
1459fa9e4066Sahrens 		break;
1460fa9e4066Sahrens 
1461fa9e4066Sahrens 	case ZFS_PROP_SHARENFS:
14627f7322feSeschrock 		(void) strlcpy(propbuf, getprop_string(zhp, prop, &source),
14637f7322feSeschrock 		    proplen);
1464fa9e4066Sahrens 		break;
1465fa9e4066Sahrens 
1466fa9e4066Sahrens 	case ZFS_PROP_ORIGIN:
1467ea8dc4b6Seschrock 		(void) strlcpy(propbuf, zhp->zfs_dmustats.dds_clone_of,
1468fa9e4066Sahrens 		    proplen);
1469fa9e4066Sahrens 		/*
1470fa9e4066Sahrens 		 * If there is no parent at all, return failure to indicate that
1471fa9e4066Sahrens 		 * it doesn't apply to this dataset.
1472fa9e4066Sahrens 		 */
1473fa9e4066Sahrens 		if (propbuf[0] == '\0')
1474fa9e4066Sahrens 			return (-1);
1475fa9e4066Sahrens 		break;
1476fa9e4066Sahrens 
1477fa9e4066Sahrens 	case ZFS_PROP_QUOTA:
1478fa9e4066Sahrens 	case ZFS_PROP_RESERVATION:
147999653d4eSeschrock 		if (get_numeric_property(zhp, prop, src, &source, &val) != 0)
148099653d4eSeschrock 			return (-1);
1481fa9e4066Sahrens 
1482fa9e4066Sahrens 		/*
1483fa9e4066Sahrens 		 * If quota or reservation is 0, we translate this into 'none'
1484fa9e4066Sahrens 		 * (unless literal is set), and indicate that it's the default
1485fa9e4066Sahrens 		 * value.  Otherwise, we print the number nicely and indicate
1486fa9e4066Sahrens 		 * that its set locally.
1487fa9e4066Sahrens 		 */
1488fa9e4066Sahrens 		if (val == 0) {
1489fa9e4066Sahrens 			if (literal)
1490fa9e4066Sahrens 				(void) strlcpy(propbuf, "0", proplen);
1491fa9e4066Sahrens 			else
1492fa9e4066Sahrens 				(void) strlcpy(propbuf, "none", proplen);
1493fa9e4066Sahrens 		} else {
1494fa9e4066Sahrens 			if (literal)
1495fa9e4066Sahrens 				(void) snprintf(propbuf, proplen, "%llu", val);
1496fa9e4066Sahrens 			else
1497fa9e4066Sahrens 				zfs_nicenum(val, propbuf, proplen);
1498fa9e4066Sahrens 		}
1499fa9e4066Sahrens 		break;
1500fa9e4066Sahrens 
1501fa9e4066Sahrens 	case ZFS_PROP_COMPRESSRATIO:
150299653d4eSeschrock 		if (get_numeric_property(zhp, prop, src, &source, &val) != 0)
150399653d4eSeschrock 			return (-1);
1504fa9e4066Sahrens 		(void) snprintf(propbuf, proplen, "%lld.%02lldx", val / 100,
1505fa9e4066Sahrens 		    val % 100);
1506fa9e4066Sahrens 		break;
1507fa9e4066Sahrens 
1508fa9e4066Sahrens 	case ZFS_PROP_TYPE:
1509fa9e4066Sahrens 		switch (zhp->zfs_type) {
1510fa9e4066Sahrens 		case ZFS_TYPE_FILESYSTEM:
1511fa9e4066Sahrens 			str = "filesystem";
1512fa9e4066Sahrens 			break;
1513fa9e4066Sahrens 		case ZFS_TYPE_VOLUME:
1514fa9e4066Sahrens 			str = "volume";
1515fa9e4066Sahrens 			break;
1516fa9e4066Sahrens 		case ZFS_TYPE_SNAPSHOT:
1517fa9e4066Sahrens 			str = "snapshot";
1518fa9e4066Sahrens 			break;
1519fa9e4066Sahrens 		default:
152099653d4eSeschrock 			abort();
1521fa9e4066Sahrens 		}
1522fa9e4066Sahrens 		(void) snprintf(propbuf, proplen, "%s", str);
1523fa9e4066Sahrens 		break;
1524fa9e4066Sahrens 
1525fa9e4066Sahrens 	case ZFS_PROP_MOUNTED:
1526fa9e4066Sahrens 		/*
1527fa9e4066Sahrens 		 * The 'mounted' property is a pseudo-property that described
1528fa9e4066Sahrens 		 * whether the filesystem is currently mounted.  Even though
1529fa9e4066Sahrens 		 * it's a boolean value, the typical values of "on" and "off"
1530fa9e4066Sahrens 		 * don't make sense, so we translate to "yes" and "no".
1531fa9e4066Sahrens 		 */
153299653d4eSeschrock 		if (get_numeric_property(zhp, ZFS_PROP_MOUNTED,
153399653d4eSeschrock 		    src, &source, &val) != 0)
153499653d4eSeschrock 			return (-1);
153599653d4eSeschrock 		if (val)
1536fa9e4066Sahrens 			(void) strlcpy(propbuf, "yes", proplen);
1537fa9e4066Sahrens 		else
1538fa9e4066Sahrens 			(void) strlcpy(propbuf, "no", proplen);
1539fa9e4066Sahrens 		break;
1540fa9e4066Sahrens 
1541fa9e4066Sahrens 	case ZFS_PROP_NAME:
1542fa9e4066Sahrens 		/*
1543fa9e4066Sahrens 		 * The 'name' property is a pseudo-property derived from the
1544fa9e4066Sahrens 		 * dataset name.  It is presented as a real property to simplify
1545fa9e4066Sahrens 		 * consumers.
1546fa9e4066Sahrens 		 */
1547fa9e4066Sahrens 		(void) strlcpy(propbuf, zhp->zfs_name, proplen);
1548fa9e4066Sahrens 		break;
1549fa9e4066Sahrens 
1550fa9e4066Sahrens 	default:
155199653d4eSeschrock 		abort();
1552fa9e4066Sahrens 	}
1553fa9e4066Sahrens 
1554fa9e4066Sahrens 	get_source(zhp, src, source, statbuf, statlen);
1555fa9e4066Sahrens 
1556fa9e4066Sahrens 	return (0);
1557fa9e4066Sahrens }
1558fa9e4066Sahrens 
1559fa9e4066Sahrens /*
1560fa9e4066Sahrens  * Utility function to get the given numeric property.  Does no validation that
1561fa9e4066Sahrens  * the given property is the appropriate type; should only be used with
1562fa9e4066Sahrens  * hard-coded property types.
1563fa9e4066Sahrens  */
1564fa9e4066Sahrens uint64_t
1565fa9e4066Sahrens zfs_prop_get_int(zfs_handle_t *zhp, zfs_prop_t prop)
1566fa9e4066Sahrens {
1567fa9e4066Sahrens 	char *source;
1568fa9e4066Sahrens 	zfs_source_t sourcetype = ZFS_SRC_NONE;
156999653d4eSeschrock 	uint64_t val;
157099653d4eSeschrock 
157199653d4eSeschrock 	(void) get_numeric_property(zhp, prop, &sourcetype, &source, &val);
1572fa9e4066Sahrens 
157399653d4eSeschrock 	return (val);
1574fa9e4066Sahrens }
1575fa9e4066Sahrens 
1576fa9e4066Sahrens /*
1577fa9e4066Sahrens  * Similar to zfs_prop_get(), but returns the value as an integer.
1578fa9e4066Sahrens  */
1579fa9e4066Sahrens int
1580fa9e4066Sahrens zfs_prop_get_numeric(zfs_handle_t *zhp, zfs_prop_t prop, uint64_t *value,
1581fa9e4066Sahrens     zfs_source_t *src, char *statbuf, size_t statlen)
1582fa9e4066Sahrens {
1583fa9e4066Sahrens 	char *source;
1584fa9e4066Sahrens 
1585fa9e4066Sahrens 	/*
1586fa9e4066Sahrens 	 * Check to see if this property applies to our object
1587fa9e4066Sahrens 	 */
1588fa9e4066Sahrens 	if (!zfs_prop_valid_for_type(prop, zhp->zfs_type))
158999653d4eSeschrock 		return (zfs_error(zhp->zfs_hdl, EZFS_PROPTYPE,
159099653d4eSeschrock 		    dgettext(TEXT_DOMAIN, "cannot get property '%s'"),
159199653d4eSeschrock 		    zfs_prop_to_name(prop)));
1592fa9e4066Sahrens 
1593fa9e4066Sahrens 	if (src)
1594fa9e4066Sahrens 		*src = ZFS_SRC_NONE;
1595fa9e4066Sahrens 
159699653d4eSeschrock 	if (get_numeric_property(zhp, prop, src, &source, value) != 0)
159799653d4eSeschrock 		return (-1);
1598fa9e4066Sahrens 
1599fa9e4066Sahrens 	get_source(zhp, src, source, statbuf, statlen);
1600fa9e4066Sahrens 
1601fa9e4066Sahrens 	return (0);
1602fa9e4066Sahrens }
1603fa9e4066Sahrens 
1604fa9e4066Sahrens /*
1605fa9e4066Sahrens  * Returns the name of the given zfs handle.
1606fa9e4066Sahrens  */
1607fa9e4066Sahrens const char *
1608fa9e4066Sahrens zfs_get_name(const zfs_handle_t *zhp)
1609fa9e4066Sahrens {
1610fa9e4066Sahrens 	return (zhp->zfs_name);
1611fa9e4066Sahrens }
1612fa9e4066Sahrens 
1613fa9e4066Sahrens /*
1614fa9e4066Sahrens  * Returns the type of the given zfs handle.
1615fa9e4066Sahrens  */
1616fa9e4066Sahrens zfs_type_t
1617fa9e4066Sahrens zfs_get_type(const zfs_handle_t *zhp)
1618fa9e4066Sahrens {
1619fa9e4066Sahrens 	return (zhp->zfs_type);
1620fa9e4066Sahrens }
1621fa9e4066Sahrens 
1622fa9e4066Sahrens /*
16237f7322feSeschrock  * Iterate over all child filesystems
1624fa9e4066Sahrens  */
1625fa9e4066Sahrens int
16267f7322feSeschrock zfs_iter_filesystems(zfs_handle_t *zhp, zfs_iter_f func, void *data)
1627fa9e4066Sahrens {
1628fa9e4066Sahrens 	zfs_cmd_t zc = { 0 };
1629fa9e4066Sahrens 	zfs_handle_t *nzhp;
1630fa9e4066Sahrens 	int ret;
1631fa9e4066Sahrens 
1632fa9e4066Sahrens 	for ((void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
163399653d4eSeschrock 	    ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_DATASET_LIST_NEXT, &zc) == 0;
1634fa9e4066Sahrens 	    (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name))) {
1635fa9e4066Sahrens 		/*
1636fa9e4066Sahrens 		 * Ignore private dataset names.
1637fa9e4066Sahrens 		 */
1638fa9e4066Sahrens 		if (dataset_name_hidden(zc.zc_name))
1639fa9e4066Sahrens 			continue;
1640fa9e4066Sahrens 
1641fa9e4066Sahrens 		/*
1642fa9e4066Sahrens 		 * Silently ignore errors, as the only plausible explanation is
1643fa9e4066Sahrens 		 * that the pool has since been removed.
1644fa9e4066Sahrens 		 */
164599653d4eSeschrock 		if ((nzhp = make_dataset_handle(zhp->zfs_hdl,
164699653d4eSeschrock 		    zc.zc_name)) == NULL)
1647fa9e4066Sahrens 			continue;
1648fa9e4066Sahrens 
1649fa9e4066Sahrens 		if ((ret = func(nzhp, data)) != 0)
1650fa9e4066Sahrens 			return (ret);
1651fa9e4066Sahrens 	}
1652fa9e4066Sahrens 
1653fa9e4066Sahrens 	/*
1654fa9e4066Sahrens 	 * An errno value of ESRCH indicates normal completion.  If ENOENT is
1655fa9e4066Sahrens 	 * returned, then the underlying dataset has been removed since we
1656fa9e4066Sahrens 	 * obtained the handle.
1657fa9e4066Sahrens 	 */
1658fa9e4066Sahrens 	if (errno != ESRCH && errno != ENOENT)
165999653d4eSeschrock 		return (zfs_standard_error(zhp->zfs_hdl, errno,
166099653d4eSeschrock 		    dgettext(TEXT_DOMAIN, "cannot iterate filesystems")));
1661fa9e4066Sahrens 
16627f7322feSeschrock 	return (0);
16637f7322feSeschrock }
16647f7322feSeschrock 
16657f7322feSeschrock /*
16667f7322feSeschrock  * Iterate over all snapshots
16677f7322feSeschrock  */
16687f7322feSeschrock int
16697f7322feSeschrock zfs_iter_snapshots(zfs_handle_t *zhp, zfs_iter_f func, void *data)
16707f7322feSeschrock {
16717f7322feSeschrock 	zfs_cmd_t zc = { 0 };
16727f7322feSeschrock 	zfs_handle_t *nzhp;
16737f7322feSeschrock 	int ret;
1674fa9e4066Sahrens 
1675fa9e4066Sahrens 	for ((void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
167699653d4eSeschrock 	    ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_SNAPSHOT_LIST_NEXT,
167799653d4eSeschrock 	    &zc) == 0;
1678fa9e4066Sahrens 	    (void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name))) {
1679fa9e4066Sahrens 
168099653d4eSeschrock 		if ((nzhp = make_dataset_handle(zhp->zfs_hdl,
168199653d4eSeschrock 		    zc.zc_name)) == NULL)
1682fa9e4066Sahrens 			continue;
1683fa9e4066Sahrens 
1684fa9e4066Sahrens 		if ((ret = func(nzhp, data)) != 0)
1685fa9e4066Sahrens 			return (ret);
1686fa9e4066Sahrens 	}
1687fa9e4066Sahrens 
1688fa9e4066Sahrens 	/*
1689fa9e4066Sahrens 	 * An errno value of ESRCH indicates normal completion.  If ENOENT is
1690fa9e4066Sahrens 	 * returned, then the underlying dataset has been removed since we
1691fa9e4066Sahrens 	 * obtained the handle.  Silently ignore this case, and return success.
1692fa9e4066Sahrens 	 */
1693fa9e4066Sahrens 	if (errno != ESRCH && errno != ENOENT)
169499653d4eSeschrock 		return (zfs_standard_error(zhp->zfs_hdl, errno,
169599653d4eSeschrock 		    dgettext(TEXT_DOMAIN, "cannot iterate filesystems")));
1696fa9e4066Sahrens 
1697fa9e4066Sahrens 	return (0);
1698fa9e4066Sahrens }
1699fa9e4066Sahrens 
17007f7322feSeschrock /*
17017f7322feSeschrock  * Iterate over all children, snapshots and filesystems
17027f7322feSeschrock  */
17037f7322feSeschrock int
17047f7322feSeschrock zfs_iter_children(zfs_handle_t *zhp, zfs_iter_f func, void *data)
17057f7322feSeschrock {
17067f7322feSeschrock 	int ret;
17077f7322feSeschrock 
17087f7322feSeschrock 	if ((ret = zfs_iter_filesystems(zhp, func, data)) != 0)
17097f7322feSeschrock 		return (ret);
17107f7322feSeschrock 
17117f7322feSeschrock 	return (zfs_iter_snapshots(zhp, func, data));
17127f7322feSeschrock }
17137f7322feSeschrock 
1714fa9e4066Sahrens /*
1715fa9e4066Sahrens  * Given a complete name, return just the portion that refers to the parent.
1716fa9e4066Sahrens  * Can return NULL if this is a pool.
1717fa9e4066Sahrens  */
1718fa9e4066Sahrens static int
1719fa9e4066Sahrens parent_name(const char *path, char *buf, size_t buflen)
1720fa9e4066Sahrens {
1721fa9e4066Sahrens 	char *loc;
1722fa9e4066Sahrens 
1723fa9e4066Sahrens 	if ((loc = strrchr(path, '/')) == NULL)
1724fa9e4066Sahrens 		return (-1);
1725fa9e4066Sahrens 
1726fa9e4066Sahrens 	(void) strncpy(buf, path, MIN(buflen, loc - path));
1727fa9e4066Sahrens 	buf[loc - path] = '\0';
1728fa9e4066Sahrens 
1729fa9e4066Sahrens 	return (0);
1730fa9e4066Sahrens }
1731fa9e4066Sahrens 
1732fa9e4066Sahrens /*
1733fa9e4066Sahrens  * Checks to make sure that the given path has a parent, and that it exists.
1734fa9e4066Sahrens  */
1735fa9e4066Sahrens static int
173699653d4eSeschrock check_parents(libzfs_handle_t *hdl, const char *path)
1737fa9e4066Sahrens {
1738fa9e4066Sahrens 	zfs_cmd_t zc = { 0 };
1739fa9e4066Sahrens 	char parent[ZFS_MAXNAMELEN];
1740fa9e4066Sahrens 	char *slash;
17417f7322feSeschrock 	zfs_handle_t *zhp;
174299653d4eSeschrock 	char errbuf[1024];
174399653d4eSeschrock 
174499653d4eSeschrock 	(void) snprintf(errbuf, sizeof (errbuf), "cannot create '%s'",
174599653d4eSeschrock 	    path);
1746fa9e4066Sahrens 
1747fa9e4066Sahrens 	/* get parent, and check to see if this is just a pool */
1748fa9e4066Sahrens 	if (parent_name(path, parent, sizeof (parent)) != 0) {
174999653d4eSeschrock 		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
175099653d4eSeschrock 		    "missing dataset name"));
175199653d4eSeschrock 		return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
1752fa9e4066Sahrens 	}
1753fa9e4066Sahrens 
1754fa9e4066Sahrens 	/* check to see if the pool exists */
1755fa9e4066Sahrens 	if ((slash = strchr(parent, '/')) == NULL)
1756fa9e4066Sahrens 		slash = parent + strlen(parent);
1757fa9e4066Sahrens 	(void) strncpy(zc.zc_name, parent, slash - parent);
1758fa9e4066Sahrens 	zc.zc_name[slash - parent] = '\0';
175999653d4eSeschrock 	if (ioctl(hdl->libzfs_fd, ZFS_IOC_OBJSET_STATS, &zc) != 0 &&
1760fa9e4066Sahrens 	    errno == ENOENT) {
176199653d4eSeschrock 		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
176299653d4eSeschrock 		    "no such pool '%s'"), zc.zc_name);
176399653d4eSeschrock 		return (zfs_error(hdl, EZFS_NOENT, errbuf));
1764fa9e4066Sahrens 	}
1765fa9e4066Sahrens 
1766fa9e4066Sahrens 	/* check to see if the parent dataset exists */
176799653d4eSeschrock 	if ((zhp = make_dataset_handle(hdl, parent)) == NULL) {
1768fa9e4066Sahrens 		switch (errno) {
1769fa9e4066Sahrens 		case ENOENT:
177099653d4eSeschrock 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
177199653d4eSeschrock 			    "parent does not exist"));
177299653d4eSeschrock 			return (zfs_error(hdl, EZFS_NOENT, errbuf));
1773fa9e4066Sahrens 
1774fa9e4066Sahrens 		default:
177599653d4eSeschrock 			return (zfs_standard_error(hdl, errno, errbuf));
1776fa9e4066Sahrens 		}
1777fa9e4066Sahrens 	}
1778fa9e4066Sahrens 
1779fa9e4066Sahrens 	/* we are in a non-global zone, but parent is in the global zone */
17807f7322feSeschrock 	if (getzoneid() != GLOBAL_ZONEID &&
178120c8013fSlling 	    !zfs_prop_get_int(zhp, ZFS_PROP_ZONED)) {
178299653d4eSeschrock 		(void) zfs_standard_error(hdl, EPERM, errbuf);
17837f7322feSeschrock 		zfs_close(zhp);
1784fa9e4066Sahrens 		return (-1);
1785fa9e4066Sahrens 	}
1786fa9e4066Sahrens 
1787fa9e4066Sahrens 	/* make sure parent is a filesystem */
17887f7322feSeschrock 	if (zfs_get_type(zhp) != ZFS_TYPE_FILESYSTEM) {
178999653d4eSeschrock 		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
179099653d4eSeschrock 		    "parent is not a filesystem"));
179199653d4eSeschrock 		(void) zfs_error(hdl, EZFS_BADTYPE, errbuf);
17927f7322feSeschrock 		zfs_close(zhp);
1793fa9e4066Sahrens 		return (-1);
1794fa9e4066Sahrens 	}
1795fa9e4066Sahrens 
17967f7322feSeschrock 	zfs_close(zhp);
1797fa9e4066Sahrens 	return (0);
1798fa9e4066Sahrens }
1799fa9e4066Sahrens 
1800fa9e4066Sahrens /*
1801fa9e4066Sahrens  * Create a new filesystem or volume.  'sizestr' and 'blocksizestr' are used
1802fa9e4066Sahrens  * only for volumes, and indicate the size and blocksize of the volume.
1803fa9e4066Sahrens  */
1804fa9e4066Sahrens int
180599653d4eSeschrock zfs_create(libzfs_handle_t *hdl, const char *path, zfs_type_t type,
1806fa9e4066Sahrens 	const char *sizestr, const char *blocksizestr)
1807fa9e4066Sahrens {
1808fa9e4066Sahrens 	zfs_cmd_t zc = { 0 };
1809fa9e4066Sahrens 	int ret;
1810fa9e4066Sahrens 	uint64_t size = 0;
1811fa9e4066Sahrens 	uint64_t blocksize = zfs_prop_default_numeric(ZFS_PROP_VOLBLOCKSIZE);
181299653d4eSeschrock 	char errbuf[1024];
1813fa9e4066Sahrens 
1814fa9e4066Sahrens 	/* convert sizestr into integer size */
181599653d4eSeschrock 	if (sizestr != NULL && nicestrtonum(hdl, sizestr, &size) != 0)
181699653d4eSeschrock 		return (zfs_error(hdl, EZFS_BADPROP, dgettext(TEXT_DOMAIN,
181799653d4eSeschrock 		    "bad volume size '%s'"), sizestr));
1818fa9e4066Sahrens 
1819fa9e4066Sahrens 	/* convert blocksizestr into integer blocksize */
182099653d4eSeschrock 	if (blocksizestr != NULL && nicestrtonum(hdl, blocksizestr,
182199653d4eSeschrock 	    &blocksize) != 0)
182299653d4eSeschrock 		return (zfs_error(hdl, EZFS_BADPROP, dgettext(TEXT_DOMAIN,
182399653d4eSeschrock 		    "bad volume blocksize '%s'"), blocksizestr));
182499653d4eSeschrock 
182599653d4eSeschrock 	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
182699653d4eSeschrock 	    "cannot create '%s'"), path);
1827fa9e4066Sahrens 
1828fa9e4066Sahrens 	/* validate the path, taking care to note the extended error message */
182999653d4eSeschrock 	if (!zfs_validate_name(hdl, path, type))
183099653d4eSeschrock 		return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
1831fa9e4066Sahrens 
1832fa9e4066Sahrens 	/* validate parents exist */
183399653d4eSeschrock 	if (check_parents(hdl, path) != 0)
1834fa9e4066Sahrens 		return (-1);
1835fa9e4066Sahrens 
1836fa9e4066Sahrens 	/*
1837fa9e4066Sahrens 	 * The failure modes when creating a dataset of a different type over
1838fa9e4066Sahrens 	 * one that already exists is a little strange.  In particular, if you
1839fa9e4066Sahrens 	 * try to create a dataset on top of an existing dataset, the ioctl()
1840fa9e4066Sahrens 	 * will return ENOENT, not EEXIST.  To prevent this from happening, we
1841fa9e4066Sahrens 	 * first try to see if the dataset exists.
1842fa9e4066Sahrens 	 */
1843fa9e4066Sahrens 	(void) strlcpy(zc.zc_name, path, sizeof (zc.zc_name));
184499653d4eSeschrock 	if (ioctl(hdl->libzfs_fd, ZFS_IOC_OBJSET_STATS, &zc) == 0) {
184599653d4eSeschrock 		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
184699653d4eSeschrock 		    "dataset already exists"));
184799653d4eSeschrock 		return (zfs_error(hdl, EZFS_EXISTS, errbuf));
1848fa9e4066Sahrens 	}
1849fa9e4066Sahrens 
1850fa9e4066Sahrens 	if (type == ZFS_TYPE_VOLUME)
1851fa9e4066Sahrens 		zc.zc_objset_type = DMU_OST_ZVOL;
1852fa9e4066Sahrens 	else
1853fa9e4066Sahrens 		zc.zc_objset_type = DMU_OST_ZFS;
1854fa9e4066Sahrens 
1855fa9e4066Sahrens 	if (type == ZFS_TYPE_VOLUME) {
18565c5460e9Seschrock 		/*
18575c5460e9Seschrock 		 * If we are creating a volume, the size and block size must
18585c5460e9Seschrock 		 * satisfy a few restraints.  First, the blocksize must be a
18595c5460e9Seschrock 		 * valid block size between SPA_{MIN,MAX}BLOCKSIZE.  Second, the
18605c5460e9Seschrock 		 * volsize must be a multiple of the block size, and cannot be
18615c5460e9Seschrock 		 * zero.
18625c5460e9Seschrock 		 */
1863fa9e4066Sahrens 		if (size == 0) {
186499653d4eSeschrock 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
186599653d4eSeschrock 			    "cannot be zero"));
186699653d4eSeschrock 			return (zfs_error(hdl, EZFS_BADPROP,
186799653d4eSeschrock 			    dgettext(TEXT_DOMAIN, "bad volume size '%s'"),
186899653d4eSeschrock 			    sizestr));
1869fa9e4066Sahrens 		}
1870fa9e4066Sahrens 
18715c5460e9Seschrock 		if (blocksize < SPA_MINBLOCKSIZE ||
18725c5460e9Seschrock 		    blocksize > SPA_MAXBLOCKSIZE || !ISP2(blocksize)) {
187399653d4eSeschrock 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
18745c5460e9Seschrock 			    "must be power of 2 from %u to %uk"),
18755c5460e9Seschrock 			    (uint_t)SPA_MINBLOCKSIZE,
18765c5460e9Seschrock 			    (uint_t)SPA_MAXBLOCKSIZE >> 10);
187799653d4eSeschrock 			return (zfs_error(hdl, EZFS_BADPROP,
187899653d4eSeschrock 			    dgettext(TEXT_DOMAIN,
187999653d4eSeschrock 			    "bad volume block size '%s'"), blocksizestr));
18805c5460e9Seschrock 		}
18815c5460e9Seschrock 
18825c5460e9Seschrock 		if (size % blocksize != 0) {
188399653d4eSeschrock 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
188499653d4eSeschrock 			    "must be a multiple of volume block size"));
188599653d4eSeschrock 			return (zfs_error(hdl, EZFS_BADPROP,
188699653d4eSeschrock 			    dgettext(TEXT_DOMAIN, "bad volume size '%s'"),
188799653d4eSeschrock 			    sizestr));
18885c5460e9Seschrock 		}
18895c5460e9Seschrock 
1890fa9e4066Sahrens 		zc.zc_volsize = size;
1891fa9e4066Sahrens 		zc.zc_volblocksize = blocksize;
1892fa9e4066Sahrens 	}
1893fa9e4066Sahrens 
1894fa9e4066Sahrens 	/* create the dataset */
189599653d4eSeschrock 	ret = ioctl(hdl->libzfs_fd, ZFS_IOC_CREATE, &zc);
1896fa9e4066Sahrens 
1897fa9e4066Sahrens 	if (ret == 0 && type == ZFS_TYPE_VOLUME)
189899653d4eSeschrock 		ret = zvol_create_link(hdl, path);
1899fa9e4066Sahrens 
1900fa9e4066Sahrens 	/* check for failure */
1901fa9e4066Sahrens 	if (ret != 0) {
1902fa9e4066Sahrens 		char parent[ZFS_MAXNAMELEN];
1903fa9e4066Sahrens 		(void) parent_name(path, parent, sizeof (parent));
1904fa9e4066Sahrens 
1905fa9e4066Sahrens 		switch (errno) {
1906fa9e4066Sahrens 		case ENOENT:
190799653d4eSeschrock 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
190899653d4eSeschrock 			    "no such parent '%s'"), parent);
190999653d4eSeschrock 			return (zfs_error(hdl, EZFS_NOENT, errbuf));
1910fa9e4066Sahrens 
1911fa9e4066Sahrens 		case EINVAL:
191299653d4eSeschrock 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
191399653d4eSeschrock 			    "parent '%s' is not a filesysem"), parent);
191499653d4eSeschrock 			return (zfs_error(hdl, EZFS_BADTYPE, errbuf));
1915fa9e4066Sahrens 
1916fa9e4066Sahrens 		case EDOM:
191799653d4eSeschrock 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1918fa9e4066Sahrens 			    "must be power of 2 from %u to %uk"),
1919fa9e4066Sahrens 			    (uint_t)SPA_MINBLOCKSIZE,
1920fa9e4066Sahrens 			    (uint_t)SPA_MAXBLOCKSIZE >> 10);
192199653d4eSeschrock 
192299653d4eSeschrock 			return (zfs_error(hdl, EZFS_BADPROP,
192399653d4eSeschrock 			    dgettext(TEXT_DOMAIN, "bad block size '%s'"),
192499653d4eSeschrock 			    blocksizestr ? blocksizestr : "<unknown>"));
192599653d4eSeschrock 
1926fa9e4066Sahrens #ifdef _ILP32
1927fa9e4066Sahrens 		case EOVERFLOW:
1928fa9e4066Sahrens 			/*
1929fa9e4066Sahrens 			 * This platform can't address a volume this big.
1930fa9e4066Sahrens 			 */
193199653d4eSeschrock 			if (type == ZFS_TYPE_VOLUME)
193299653d4eSeschrock 				return (zfs_error(hdl, EZFS_VOLTOOBIG,
193399653d4eSeschrock 				    errbuf));
1934fa9e4066Sahrens #endif
193599653d4eSeschrock 			/* FALLTHROUGH */
1936fa9e4066Sahrens 		default:
193799653d4eSeschrock 			return (zfs_standard_error(hdl, errno, errbuf));
1938fa9e4066Sahrens 		}
1939fa9e4066Sahrens 	}
1940fa9e4066Sahrens 
1941fa9e4066Sahrens 	return (0);
1942fa9e4066Sahrens }
1943fa9e4066Sahrens 
1944fa9e4066Sahrens /*
1945fa9e4066Sahrens  * Destroys the given dataset.  The caller must make sure that the filesystem
1946fa9e4066Sahrens  * isn't mounted, and that there are no active dependents.
1947fa9e4066Sahrens  */
1948fa9e4066Sahrens int
1949fa9e4066Sahrens zfs_destroy(zfs_handle_t *zhp)
1950fa9e4066Sahrens {
1951fa9e4066Sahrens 	zfs_cmd_t zc = { 0 };
1952fa9e4066Sahrens 	int ret;
1953fa9e4066Sahrens 
1954fa9e4066Sahrens 	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
1955fa9e4066Sahrens 
1956fa9e4066Sahrens 	/*
1957fa9e4066Sahrens 	 * We use the check for 'zfs_volblocksize' instead of ZFS_TYPE_VOLUME
1958fa9e4066Sahrens 	 * so that we do the right thing for snapshots of volumes.
1959fa9e4066Sahrens 	 */
1960fa9e4066Sahrens 	if (zhp->zfs_volblocksize != 0) {
196199653d4eSeschrock 		if (zvol_remove_link(zhp->zfs_hdl, zhp->zfs_name) != 0)
1962fa9e4066Sahrens 			return (-1);
1963fa9e4066Sahrens 
1964fa9e4066Sahrens 		zc.zc_objset_type = DMU_OST_ZVOL;
1965fa9e4066Sahrens 	} else {
1966fa9e4066Sahrens 		zc.zc_objset_type = DMU_OST_ZFS;
1967fa9e4066Sahrens 	}
1968fa9e4066Sahrens 
196999653d4eSeschrock 	ret = ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_DESTROY, &zc);
1970*1d452cf5Sahrens 	if (ret != 0) {
197199653d4eSeschrock 		return (zfs_standard_error(zhp->zfs_hdl, errno,
197299653d4eSeschrock 		    dgettext(TEXT_DOMAIN, "cannot destroy '%s'"),
197399653d4eSeschrock 		    zhp->zfs_name));
1974*1d452cf5Sahrens 	}
1975fa9e4066Sahrens 
1976fa9e4066Sahrens 	remove_mountpoint(zhp);
1977fa9e4066Sahrens 
1978fa9e4066Sahrens 	return (0);
1979fa9e4066Sahrens }
1980fa9e4066Sahrens 
1981*1d452cf5Sahrens struct destroydata {
1982*1d452cf5Sahrens 	char *snapname;
1983*1d452cf5Sahrens 	boolean_t gotone;
1984*1d452cf5Sahrens };
1985*1d452cf5Sahrens 
1986*1d452cf5Sahrens static int
1987*1d452cf5Sahrens zfs_remove_link_cb(zfs_handle_t *zhp, void *arg)
1988*1d452cf5Sahrens {
1989*1d452cf5Sahrens 	struct destroydata *dd = arg;
1990*1d452cf5Sahrens 	zfs_handle_t *szhp;
1991*1d452cf5Sahrens 	char name[ZFS_MAXNAMELEN];
1992*1d452cf5Sahrens 
1993*1d452cf5Sahrens 	(void) strcpy(name, zhp->zfs_name);
1994*1d452cf5Sahrens 	(void) strcat(name, "@");
1995*1d452cf5Sahrens 	(void) strcat(name, dd->snapname);
1996*1d452cf5Sahrens 
1997*1d452cf5Sahrens 	szhp = make_dataset_handle(zhp->zfs_hdl, name);
1998*1d452cf5Sahrens 	if (szhp) {
1999*1d452cf5Sahrens 		dd->gotone = B_TRUE;
2000*1d452cf5Sahrens 		zfs_close(szhp);
2001*1d452cf5Sahrens 	}
2002*1d452cf5Sahrens 
2003*1d452cf5Sahrens 	if (zhp->zfs_type == ZFS_TYPE_VOLUME) {
2004*1d452cf5Sahrens 		(void) zvol_remove_link(zhp->zfs_hdl, name);
2005*1d452cf5Sahrens 		/*
2006*1d452cf5Sahrens 		 * NB: this is simply a best-effort.  We don't want to
2007*1d452cf5Sahrens 		 * return an error, because then we wouldn't visit all
2008*1d452cf5Sahrens 		 * the volumes.
2009*1d452cf5Sahrens 		 */
2010*1d452cf5Sahrens 	}
2011*1d452cf5Sahrens 
2012*1d452cf5Sahrens 	return (zfs_iter_filesystems(zhp, zfs_remove_link_cb, arg));
2013*1d452cf5Sahrens }
2014*1d452cf5Sahrens 
2015*1d452cf5Sahrens /*
2016*1d452cf5Sahrens  * Destroys all snapshots with the given name in zhp & descendants.
2017*1d452cf5Sahrens  */
2018*1d452cf5Sahrens int
2019*1d452cf5Sahrens zfs_destroy_snaps(zfs_handle_t *zhp, char *snapname)
2020*1d452cf5Sahrens {
2021*1d452cf5Sahrens 	zfs_cmd_t zc = { 0 };
2022*1d452cf5Sahrens 	int ret;
2023*1d452cf5Sahrens 	struct destroydata dd = { 0 };
2024*1d452cf5Sahrens 
2025*1d452cf5Sahrens 	dd.snapname = snapname;
2026*1d452cf5Sahrens 	(void) zfs_remove_link_cb(zhp, &dd);
2027*1d452cf5Sahrens 
2028*1d452cf5Sahrens 	if (!dd.gotone) {
2029*1d452cf5Sahrens 		return (zfs_standard_error(zhp->zfs_hdl, ENOENT,
2030*1d452cf5Sahrens 		    dgettext(TEXT_DOMAIN, "cannot destroy '%s@%s'"),
2031*1d452cf5Sahrens 		    zhp->zfs_name, snapname));
2032*1d452cf5Sahrens 	}
2033*1d452cf5Sahrens 
2034*1d452cf5Sahrens 	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
2035*1d452cf5Sahrens 	(void) strlcpy(zc.zc_prop_value, snapname, sizeof (zc.zc_prop_value));
2036*1d452cf5Sahrens 
2037*1d452cf5Sahrens 	ret = ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_DESTROY_SNAPS, &zc);
2038*1d452cf5Sahrens 	if (ret != 0) {
2039*1d452cf5Sahrens 		char errbuf[1024];
2040*1d452cf5Sahrens 
2041*1d452cf5Sahrens 		(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
2042*1d452cf5Sahrens 		    "cannot destroy '%s@%s'"), zc.zc_name, snapname);
2043*1d452cf5Sahrens 
2044*1d452cf5Sahrens 		switch (errno) {
2045*1d452cf5Sahrens 		case EEXIST:
2046*1d452cf5Sahrens 			zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
2047*1d452cf5Sahrens 			    "snapshot is cloned"));
2048*1d452cf5Sahrens 			return (zfs_error(zhp->zfs_hdl, EZFS_EXISTS, errbuf));
2049*1d452cf5Sahrens 
2050*1d452cf5Sahrens 		default:
2051*1d452cf5Sahrens 			return (zfs_standard_error(zhp->zfs_hdl, errno,
2052*1d452cf5Sahrens 			    errbuf));
2053*1d452cf5Sahrens 		}
2054*1d452cf5Sahrens 	}
2055*1d452cf5Sahrens 
2056*1d452cf5Sahrens 	return (0);
2057*1d452cf5Sahrens }
2058*1d452cf5Sahrens 
2059fa9e4066Sahrens /*
2060fa9e4066Sahrens  * Clones the given dataset.  The target must be of the same type as the source.
2061fa9e4066Sahrens  */
2062fa9e4066Sahrens int
2063fa9e4066Sahrens zfs_clone(zfs_handle_t *zhp, const char *target)
2064fa9e4066Sahrens {
2065fa9e4066Sahrens 	zfs_cmd_t zc = { 0 };
2066fa9e4066Sahrens 	char parent[ZFS_MAXNAMELEN];
2067fa9e4066Sahrens 	int ret;
206899653d4eSeschrock 	char errbuf[1024];
206999653d4eSeschrock 	libzfs_handle_t *hdl = zhp->zfs_hdl;
2070fa9e4066Sahrens 
2071fa9e4066Sahrens 	assert(zhp->zfs_type == ZFS_TYPE_SNAPSHOT);
2072fa9e4066Sahrens 
207399653d4eSeschrock 	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
207499653d4eSeschrock 	    "cannot create '%s'"), target);
207599653d4eSeschrock 
2076fa9e4066Sahrens 	/* validate the target name */
207799653d4eSeschrock 	if (!zfs_validate_name(hdl, target, ZFS_TYPE_FILESYSTEM))
207899653d4eSeschrock 		return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
2079fa9e4066Sahrens 
2080fa9e4066Sahrens 	/* validate parents exist */
208199653d4eSeschrock 	if (check_parents(zhp->zfs_hdl, target) != 0)
2082fa9e4066Sahrens 		return (-1);
2083fa9e4066Sahrens 
2084fa9e4066Sahrens 	(void) parent_name(target, parent, sizeof (parent));
2085fa9e4066Sahrens 
2086fa9e4066Sahrens 	/* do the clone */
2087fa9e4066Sahrens 	if (zhp->zfs_volblocksize != 0)
2088fa9e4066Sahrens 		zc.zc_objset_type = DMU_OST_ZVOL;
2089fa9e4066Sahrens 	else
2090fa9e4066Sahrens 		zc.zc_objset_type = DMU_OST_ZFS;
2091fa9e4066Sahrens 
2092fa9e4066Sahrens 	(void) strlcpy(zc.zc_name, target, sizeof (zc.zc_name));
2093fa9e4066Sahrens 	(void) strlcpy(zc.zc_filename, zhp->zfs_name, sizeof (zc.zc_filename));
209499653d4eSeschrock 	ret = ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_CREATE, &zc);
2095fa9e4066Sahrens 
2096fa9e4066Sahrens 	if (ret != 0) {
2097fa9e4066Sahrens 		switch (errno) {
2098fa9e4066Sahrens 
2099fa9e4066Sahrens 		case ENOENT:
2100fa9e4066Sahrens 			/*
2101fa9e4066Sahrens 			 * The parent doesn't exist.  We should have caught this
2102fa9e4066Sahrens 			 * above, but there may a race condition that has since
2103fa9e4066Sahrens 			 * destroyed the parent.
2104fa9e4066Sahrens 			 *
2105fa9e4066Sahrens 			 * At this point, we don't know whether it's the source
2106fa9e4066Sahrens 			 * that doesn't exist anymore, or whether the target
2107fa9e4066Sahrens 			 * dataset doesn't exist.
2108fa9e4066Sahrens 			 */
210999653d4eSeschrock 			zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
211099653d4eSeschrock 			    "no such parent '%s'"), parent);
211199653d4eSeschrock 			return (zfs_error(zhp->zfs_hdl, EZFS_NOENT, errbuf));
2112fa9e4066Sahrens 
211399653d4eSeschrock 		case EXDEV:
211499653d4eSeschrock 			zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
211599653d4eSeschrock 			    "source and target pools differ"));
211699653d4eSeschrock 			return (zfs_error(zhp->zfs_hdl, EZFS_CROSSTARGET,
211799653d4eSeschrock 			    errbuf));
2118fa9e4066Sahrens 
211999653d4eSeschrock 		default:
212099653d4eSeschrock 			return (zfs_standard_error(zhp->zfs_hdl, errno,
212199653d4eSeschrock 			    errbuf));
212299653d4eSeschrock 		}
212399653d4eSeschrock 	} else if (zhp->zfs_volblocksize != 0) {
212499653d4eSeschrock 		ret = zvol_create_link(zhp->zfs_hdl, target);
212599653d4eSeschrock 	}
2126fa9e4066Sahrens 
212799653d4eSeschrock 	return (ret);
212899653d4eSeschrock }
212999653d4eSeschrock 
213099653d4eSeschrock typedef struct promote_data {
213199653d4eSeschrock 	char cb_mountpoint[MAXPATHLEN];
213299653d4eSeschrock 	const char *cb_target;
213399653d4eSeschrock 	const char *cb_errbuf;
213499653d4eSeschrock 	uint64_t cb_pivot_txg;
213599653d4eSeschrock } promote_data_t;
213699653d4eSeschrock 
213799653d4eSeschrock static int
213899653d4eSeschrock promote_snap_cb(zfs_handle_t *zhp, void *data)
213999653d4eSeschrock {
214099653d4eSeschrock 	promote_data_t *pd = data;
214199653d4eSeschrock 	zfs_handle_t *szhp;
214299653d4eSeschrock 	int err;
214399653d4eSeschrock 	char snapname[MAXPATHLEN];
214499653d4eSeschrock 	char *cp;
214599653d4eSeschrock 
214699653d4eSeschrock 	/* We don't care about snapshots after the pivot point */
214799653d4eSeschrock 	if (zfs_prop_get_int(zhp, ZFS_PROP_CREATETXG) > pd->cb_pivot_txg)
214899653d4eSeschrock 		return (0);
214999653d4eSeschrock 
215099653d4eSeschrock 	/*
215199653d4eSeschrock 	 * Unmount it.  We actually need to open it to provoke it to be
215299653d4eSeschrock 	 * mounted first, because if it is not mounted, umount2 will
215399653d4eSeschrock 	 * mount it!
215499653d4eSeschrock 	 */
215599653d4eSeschrock 	(void) strcpy(snapname, pd->cb_mountpoint);
215699653d4eSeschrock 	(void) strcat(snapname, "/.zfs/snapshot/");
215799653d4eSeschrock 	cp = strchr(zhp->zfs_name, '@');
215899653d4eSeschrock 	(void) strcat(snapname, cp+1);
215999653d4eSeschrock 	err = open(snapname, O_RDONLY);
216099653d4eSeschrock 	if (err != -1)
216199653d4eSeschrock 		(void) close(err);
216299653d4eSeschrock 	(void) umount2(snapname, MS_FORCE);
216399653d4eSeschrock 
216499653d4eSeschrock 	/* Check for conflicting names */
216599653d4eSeschrock 	(void) strcpy(snapname, pd->cb_target);
216699653d4eSeschrock 	(void) strcat(snapname, cp);
216799653d4eSeschrock 	szhp = make_dataset_handle(zhp->zfs_hdl, snapname);
216899653d4eSeschrock 	if (szhp != NULL) {
216999653d4eSeschrock 		zfs_close(szhp);
217099653d4eSeschrock 		zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
217199653d4eSeschrock 		    "snapshot name '%s' from origin \n"
217299653d4eSeschrock 		    "conflicts with '%s' from target"),
217399653d4eSeschrock 		    zhp->zfs_name, snapname);
217499653d4eSeschrock 		return (zfs_error(zhp->zfs_hdl, EZFS_EXISTS, pd->cb_errbuf));
217599653d4eSeschrock 	}
217699653d4eSeschrock 	return (0);
217799653d4eSeschrock }
217899653d4eSeschrock 
217999653d4eSeschrock /*
218099653d4eSeschrock  * Promotes the given clone fs to be the clone parent.
218199653d4eSeschrock  */
218299653d4eSeschrock int
218399653d4eSeschrock zfs_promote(zfs_handle_t *zhp)
218499653d4eSeschrock {
218599653d4eSeschrock 	libzfs_handle_t *hdl = zhp->zfs_hdl;
218699653d4eSeschrock 	zfs_cmd_t zc = { 0 };
218799653d4eSeschrock 	char parent[MAXPATHLEN];
218899653d4eSeschrock 	char *cp;
218999653d4eSeschrock 	int ret;
219099653d4eSeschrock 	zfs_handle_t *pzhp;
219199653d4eSeschrock 	promote_data_t pd;
219299653d4eSeschrock 	char errbuf[1024];
219399653d4eSeschrock 
219499653d4eSeschrock 	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
219599653d4eSeschrock 	    "cannot promote '%s'"), zhp->zfs_name);
219699653d4eSeschrock 
219799653d4eSeschrock 	if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT) {
219899653d4eSeschrock 		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
219999653d4eSeschrock 		    "snapshots can not be promoted"));
220099653d4eSeschrock 		return (zfs_error(hdl, EZFS_BADTYPE, errbuf));
220199653d4eSeschrock 	}
220299653d4eSeschrock 
220399653d4eSeschrock 	(void) strcpy(parent, zhp->zfs_dmustats.dds_clone_of);
220499653d4eSeschrock 	if (parent[0] == '\0') {
220599653d4eSeschrock 		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
220699653d4eSeschrock 		    "not a cloned filesystem"));
220799653d4eSeschrock 		return (zfs_error(hdl, EZFS_BADTYPE, errbuf));
220899653d4eSeschrock 	}
220999653d4eSeschrock 	cp = strchr(parent, '@');
221099653d4eSeschrock 	*cp = '\0';
221199653d4eSeschrock 
221299653d4eSeschrock 	/* Walk the snapshots we will be moving */
221399653d4eSeschrock 	pzhp = zfs_open(hdl, zhp->zfs_dmustats.dds_clone_of, ZFS_TYPE_SNAPSHOT);
221499653d4eSeschrock 	if (pzhp == NULL)
221599653d4eSeschrock 		return (-1);
221699653d4eSeschrock 	pd.cb_pivot_txg = zfs_prop_get_int(pzhp, ZFS_PROP_CREATETXG);
221799653d4eSeschrock 	zfs_close(pzhp);
221899653d4eSeschrock 	pd.cb_target = zhp->zfs_name;
221999653d4eSeschrock 	pd.cb_errbuf = errbuf;
222099653d4eSeschrock 	pzhp = zfs_open(hdl, parent, ZFS_TYPE_ANY);
222199653d4eSeschrock 	if (pzhp == NULL)
222299653d4eSeschrock 		return (-1);
222399653d4eSeschrock 	(void) zfs_prop_get(pzhp, ZFS_PROP_MOUNTPOINT, pd.cb_mountpoint,
222499653d4eSeschrock 	    sizeof (pd.cb_mountpoint), NULL, NULL, 0, FALSE);
222599653d4eSeschrock 	ret = zfs_iter_snapshots(pzhp, promote_snap_cb, &pd);
222699653d4eSeschrock 	if (ret != 0)
222799653d4eSeschrock 		return (-1);
222899653d4eSeschrock 
222999653d4eSeschrock 	/* issue the ioctl */
223099653d4eSeschrock 	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
223199653d4eSeschrock 	ret = ioctl(hdl->libzfs_fd, ZFS_IOC_PROMOTE, &zc);
223299653d4eSeschrock 
223399653d4eSeschrock 	if (ret != 0) {
223499653d4eSeschrock 		switch (errno) {
223599653d4eSeschrock 
223699653d4eSeschrock 		case EEXIST:
2237fa9e4066Sahrens 			/*
223899653d4eSeschrock 			 * There is a conflicting snapshot name.  We
223999653d4eSeschrock 			 * should have caught this above, but they could
224099653d4eSeschrock 			 * have renamed something in the mean time.
2241fa9e4066Sahrens 			 */
224299653d4eSeschrock 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
224399653d4eSeschrock 			    "conflicting snapshot name from parent '%s'"),
224499653d4eSeschrock 			    parent);
224599653d4eSeschrock 			return (zfs_error(hdl, EZFS_EXISTS, errbuf));
2246fa9e4066Sahrens 
2247fa9e4066Sahrens 		default:
224899653d4eSeschrock 			return (zfs_standard_error(hdl, errno, errbuf));
2249fa9e4066Sahrens 		}
2250fa9e4066Sahrens 	}
2251fa9e4066Sahrens 
2252fa9e4066Sahrens 	return (ret);
2253fa9e4066Sahrens }
2254fa9e4066Sahrens 
2255*1d452cf5Sahrens static int
2256*1d452cf5Sahrens zfs_create_link_cb(zfs_handle_t *zhp, void *arg)
2257*1d452cf5Sahrens {
2258*1d452cf5Sahrens 	char *snapname = arg;
2259*1d452cf5Sahrens 
2260*1d452cf5Sahrens 	if (zhp->zfs_type == ZFS_TYPE_VOLUME) {
2261*1d452cf5Sahrens 		char name[MAXPATHLEN];
2262*1d452cf5Sahrens 
2263*1d452cf5Sahrens 		(void) strcpy(name, zhp->zfs_name);
2264*1d452cf5Sahrens 		(void) strcat(name, "@");
2265*1d452cf5Sahrens 		(void) strcat(name, snapname);
2266*1d452cf5Sahrens 		(void) zvol_create_link(zhp->zfs_hdl, name);
2267*1d452cf5Sahrens 		/*
2268*1d452cf5Sahrens 		 * NB: this is simply a best-effort.  We don't want to
2269*1d452cf5Sahrens 		 * return an error, because then we wouldn't visit all
2270*1d452cf5Sahrens 		 * the volumes.
2271*1d452cf5Sahrens 		 */
2272*1d452cf5Sahrens 	}
2273*1d452cf5Sahrens 	return (zfs_iter_filesystems(zhp, zfs_create_link_cb, snapname));
2274*1d452cf5Sahrens }
2275*1d452cf5Sahrens 
2276fa9e4066Sahrens /*
2277fa9e4066Sahrens  * Takes a snapshot of the given dataset
2278fa9e4066Sahrens  */
2279fa9e4066Sahrens int
2280*1d452cf5Sahrens zfs_snapshot(libzfs_handle_t *hdl, const char *path, boolean_t recursive)
2281fa9e4066Sahrens {
2282fa9e4066Sahrens 	const char *delim;
2283fa9e4066Sahrens 	char *parent;
2284fa9e4066Sahrens 	zfs_handle_t *zhp;
2285fa9e4066Sahrens 	zfs_cmd_t zc = { 0 };
2286fa9e4066Sahrens 	int ret;
228799653d4eSeschrock 	char errbuf[1024];
2288fa9e4066Sahrens 
228999653d4eSeschrock 	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
229099653d4eSeschrock 	    "cannot snapshot '%s'"), path);
229199653d4eSeschrock 
229299653d4eSeschrock 	/* validate the target name */
229399653d4eSeschrock 	if (!zfs_validate_name(hdl, path, ZFS_TYPE_SNAPSHOT))
229499653d4eSeschrock 		return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
2295fa9e4066Sahrens 
2296fa9e4066Sahrens 	/* make sure the parent exists and is of the appropriate type */
2297*1d452cf5Sahrens 	delim = strchr(path, '@');
229899653d4eSeschrock 	if ((parent = zfs_alloc(hdl, delim - path + 1)) == NULL)
229999653d4eSeschrock 		return (-1);
2300fa9e4066Sahrens 	(void) strncpy(parent, path, delim - path);
2301fa9e4066Sahrens 	parent[delim - path] = '\0';
2302fa9e4066Sahrens 
230399653d4eSeschrock 	if ((zhp = zfs_open(hdl, parent, ZFS_TYPE_FILESYSTEM |
2304fa9e4066Sahrens 	    ZFS_TYPE_VOLUME)) == NULL) {
2305fa9e4066Sahrens 		free(parent);
2306fa9e4066Sahrens 		return (-1);
2307fa9e4066Sahrens 	}
2308fa9e4066Sahrens 
2309*1d452cf5Sahrens 	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
2310*1d452cf5Sahrens 	(void) strlcpy(zc.zc_prop_value, delim+1, sizeof (zc.zc_prop_value));
2311*1d452cf5Sahrens 	zc.zc_cookie = recursive;
2312*1d452cf5Sahrens 	ret = ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_SNAPSHOT, &zc);
2313fa9e4066Sahrens 
2314*1d452cf5Sahrens 	/*
2315*1d452cf5Sahrens 	 * if it was recursive, the one that actually failed will be in
2316*1d452cf5Sahrens 	 * zc.zc_name.
2317*1d452cf5Sahrens 	 */
2318*1d452cf5Sahrens 	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
2319*1d452cf5Sahrens 	    "cannot create snapshot '%s@%s'"), zc.zc_name, zc.zc_prop_value);
2320*1d452cf5Sahrens 	if (ret == 0 && recursive) {
2321*1d452cf5Sahrens 		(void) zfs_iter_filesystems(zhp,
2322*1d452cf5Sahrens 		    zfs_create_link_cb, (char *)delim+1);
2323*1d452cf5Sahrens 	}
2324fa9e4066Sahrens 	if (ret == 0 && zhp->zfs_type == ZFS_TYPE_VOLUME) {
232599653d4eSeschrock 		ret = zvol_create_link(zhp->zfs_hdl, path);
2326*1d452cf5Sahrens 		if (ret != 0) {
232799653d4eSeschrock 			(void) ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_DESTROY,
232899653d4eSeschrock 			    &zc);
2329*1d452cf5Sahrens 		}
2330fa9e4066Sahrens 	}
2331fa9e4066Sahrens 
233299653d4eSeschrock 	if (ret != 0)
233399653d4eSeschrock 		(void) zfs_standard_error(hdl, errno, errbuf);
2334fa9e4066Sahrens 
2335fa9e4066Sahrens 	free(parent);
2336fa9e4066Sahrens 	zfs_close(zhp);
2337fa9e4066Sahrens 
2338fa9e4066Sahrens 	return (ret);
2339fa9e4066Sahrens }
2340fa9e4066Sahrens 
2341fa9e4066Sahrens /*
2342fa9e4066Sahrens  * Dumps a backup of tosnap, incremental from fromsnap if it isn't NULL.
2343fa9e4066Sahrens  */
2344fa9e4066Sahrens int
2345f2a3c691Sahrens zfs_send(zfs_handle_t *zhp_to, zfs_handle_t *zhp_from)
2346fa9e4066Sahrens {
2347fa9e4066Sahrens 	zfs_cmd_t zc = { 0 };
2348fa9e4066Sahrens 	int ret;
234999653d4eSeschrock 	char errbuf[1024];
235099653d4eSeschrock 	libzfs_handle_t *hdl = zhp_to->zfs_hdl;
235199653d4eSeschrock 
235299653d4eSeschrock 	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
235399653d4eSeschrock 	    "cannot send '%s'"), zhp_to->zfs_name);
2354fa9e4066Sahrens 
2355fa9e4066Sahrens 	/* do the ioctl() */
2356fa9e4066Sahrens 	(void) strlcpy(zc.zc_name, zhp_to->zfs_name, sizeof (zc.zc_name));
2357fa9e4066Sahrens 	if (zhp_from) {
2358fa9e4066Sahrens 		(void) strlcpy(zc.zc_prop_value, zhp_from->zfs_name,
2359fa9e4066Sahrens 		    sizeof (zc.zc_name));
2360fa9e4066Sahrens 	} else {
2361fa9e4066Sahrens 		zc.zc_prop_value[0] = '\0';
2362fa9e4066Sahrens 	}
2363fa9e4066Sahrens 	zc.zc_cookie = STDOUT_FILENO;
2364fa9e4066Sahrens 
236599653d4eSeschrock 	ret = ioctl(zhp_to->zfs_hdl->libzfs_fd, ZFS_IOC_SENDBACKUP, &zc);
2366fa9e4066Sahrens 	if (ret != 0) {
2367fa9e4066Sahrens 		switch (errno) {
2368fa9e4066Sahrens 
2369fa9e4066Sahrens 		case EXDEV:
237099653d4eSeschrock 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
237199653d4eSeschrock 			    "not an ealier snapshot from the same fs"));
237299653d4eSeschrock 			return (zfs_error(hdl, EZFS_CROSSTARGET, errbuf));
2373fa9e4066Sahrens 
2374fa9e4066Sahrens 		case EDQUOT:
2375fa9e4066Sahrens 		case EFBIG:
2376fa9e4066Sahrens 		case EIO:
2377fa9e4066Sahrens 		case ENOLINK:
2378fa9e4066Sahrens 		case ENOSPC:
2379fa9e4066Sahrens 		case ENOSTR:
2380fa9e4066Sahrens 		case ENXIO:
2381fa9e4066Sahrens 		case EPIPE:
2382fa9e4066Sahrens 		case ERANGE:
2383fa9e4066Sahrens 		case EFAULT:
2384fa9e4066Sahrens 		case EROFS:
238599653d4eSeschrock 			zfs_error_aux(hdl, strerror(errno));
238699653d4eSeschrock 			return (zfs_error(hdl, EZFS_BADBACKUP, errbuf));
2387fa9e4066Sahrens 
2388fa9e4066Sahrens 		default:
238999653d4eSeschrock 			return (zfs_standard_error(hdl, errno, errbuf));
2390fa9e4066Sahrens 		}
2391fa9e4066Sahrens 	}
2392fa9e4066Sahrens 
2393fa9e4066Sahrens 	return (ret);
2394fa9e4066Sahrens }
2395fa9e4066Sahrens 
2396fa9e4066Sahrens /*
2397fa9e4066Sahrens  * Restores a backup of tosnap from stdin.
2398fa9e4066Sahrens  */
2399fa9e4066Sahrens int
240099653d4eSeschrock zfs_receive(libzfs_handle_t *hdl, const char *tosnap, int isprefix,
240199653d4eSeschrock     int verbose, int dryrun)
2402fa9e4066Sahrens {
2403fa9e4066Sahrens 	zfs_cmd_t zc = { 0 };
2404fa9e4066Sahrens 	time_t begin_time;
24059b4f025eSahrens 	int ioctl_err, err, bytes, size;
2406fa9e4066Sahrens 	char *cp;
2407fa9e4066Sahrens 	dmu_replay_record_t drr;
2408fa9e4066Sahrens 	struct drr_begin *drrb = &zc.zc_begin_record;
240999653d4eSeschrock 	char errbuf[1024];
2410fa9e4066Sahrens 
2411fa9e4066Sahrens 	begin_time = time(NULL);
2412fa9e4066Sahrens 
241399653d4eSeschrock 	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
241499653d4eSeschrock 	    "cannot receive"));
241599653d4eSeschrock 
2416fa9e4066Sahrens 	/* trim off snapname, if any */
2417fa9e4066Sahrens 	(void) strcpy(zc.zc_name, tosnap);
2418fa9e4066Sahrens 	cp = strchr(zc.zc_name, '@');
2419fa9e4066Sahrens 	if (cp)
2420fa9e4066Sahrens 		*cp = '\0';
2421fa9e4066Sahrens 
2422fa9e4066Sahrens 	/* read in the BEGIN record */
2423fa9e4066Sahrens 	cp = (char *)&drr;
2424fa9e4066Sahrens 	bytes = 0;
2425fa9e4066Sahrens 	do {
24269b4f025eSahrens 		size = read(STDIN_FILENO, cp, sizeof (drr) - bytes);
24279b4f025eSahrens 		cp += size;
24289b4f025eSahrens 		bytes += size;
24299b4f025eSahrens 	} while (size > 0);
2430fa9e4066Sahrens 
24319b4f025eSahrens 	if (size < 0 || bytes != sizeof (drr)) {
243299653d4eSeschrock 		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "invalid "
243399653d4eSeschrock 		    "stream (failed to read first record)"));
243499653d4eSeschrock 		return (zfs_error(hdl, EZFS_BADSTREAM, errbuf));
2435fa9e4066Sahrens 	}
2436fa9e4066Sahrens 
2437fa9e4066Sahrens 	zc.zc_begin_record = drr.drr_u.drr_begin;
2438fa9e4066Sahrens 
2439fa9e4066Sahrens 	if (drrb->drr_magic != DMU_BACKUP_MAGIC &&
2440fa9e4066Sahrens 	    drrb->drr_magic != BSWAP_64(DMU_BACKUP_MAGIC)) {
244199653d4eSeschrock 		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "invalid "
244299653d4eSeschrock 		    "stream (bad magic number)"));
244399653d4eSeschrock 		return (zfs_error(hdl, EZFS_BADSTREAM, errbuf));
2444fa9e4066Sahrens 	}
2445fa9e4066Sahrens 
2446fa9e4066Sahrens 	if (drrb->drr_version != DMU_BACKUP_VERSION &&
2447fa9e4066Sahrens 	    drrb->drr_version != BSWAP_64(DMU_BACKUP_VERSION)) {
244899653d4eSeschrock 		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "only version "
244999653d4eSeschrock 		    "0x%llx is supported (stream is version 0x%llx)"),
2450fa9e4066Sahrens 		    DMU_BACKUP_VERSION, drrb->drr_version);
245199653d4eSeschrock 		return (zfs_error(hdl, EZFS_BADSTREAM, errbuf));
2452fa9e4066Sahrens 	}
2453fa9e4066Sahrens 
2454fa9e4066Sahrens 	/*
2455fa9e4066Sahrens 	 * Determine name of destination snapshot.
2456fa9e4066Sahrens 	 */
2457ea8dc4b6Seschrock 	(void) strcpy(zc.zc_filename, tosnap);
2458fa9e4066Sahrens 	if (isprefix) {
2459fa9e4066Sahrens 		if (strchr(tosnap, '@') != NULL) {
246099653d4eSeschrock 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
246199653d4eSeschrock 			    "destination must be a filesystem"));
246299653d4eSeschrock 			return (zfs_error(hdl, EZFS_BADTYPE, errbuf));
2463fa9e4066Sahrens 		}
2464fa9e4066Sahrens 
2465fa9e4066Sahrens 		cp = strchr(drr.drr_u.drr_begin.drr_toname, '/');
2466fa9e4066Sahrens 		if (cp == NULL)
2467fa9e4066Sahrens 			cp = drr.drr_u.drr_begin.drr_toname;
2468fa9e4066Sahrens 		else
2469fa9e4066Sahrens 			cp++;
2470fa9e4066Sahrens 
2471ea8dc4b6Seschrock 		(void) strcat(zc.zc_filename, "/");
2472ea8dc4b6Seschrock 		(void) strcat(zc.zc_filename, cp);
2473fa9e4066Sahrens 	} else if (strchr(tosnap, '@') == NULL) {
2474fa9e4066Sahrens 		/*
2475fa9e4066Sahrens 		 * they specified just a filesystem; tack on the
2476fa9e4066Sahrens 		 * snapname from the backup.
2477fa9e4066Sahrens 		 */
2478fa9e4066Sahrens 		cp = strchr(drr.drr_u.drr_begin.drr_toname, '@');
247999653d4eSeschrock 		if (cp == NULL || strlen(tosnap) + strlen(cp) >= MAXNAMELEN)
248099653d4eSeschrock 			return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
2481ea8dc4b6Seschrock 		(void) strcat(zc.zc_filename, cp);
2482fa9e4066Sahrens 	}
2483fa9e4066Sahrens 
2484fa9e4066Sahrens 	if (drrb->drr_fromguid) {
2485fa9e4066Sahrens 		zfs_handle_t *h;
2486fa9e4066Sahrens 		/* incremental backup stream */
2487fa9e4066Sahrens 
2488fa9e4066Sahrens 		/* do the ioctl to the containing fs */
2489ea8dc4b6Seschrock 		(void) strcpy(zc.zc_name, zc.zc_filename);
2490fa9e4066Sahrens 		cp = strchr(zc.zc_name, '@');
2491fa9e4066Sahrens 		*cp = '\0';
2492fa9e4066Sahrens 
2493fa9e4066Sahrens 		/* make sure destination fs exists */
249499653d4eSeschrock 		h = zfs_open(hdl, zc.zc_name,
249599653d4eSeschrock 		    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
249699653d4eSeschrock 		if (h == NULL)
2497fa9e4066Sahrens 			return (-1);
24989b4f025eSahrens 		if (!dryrun) {
24999b4f025eSahrens 			/* unmount destination fs or remove device link. */
25009b4f025eSahrens 			if (h->zfs_type == ZFS_TYPE_FILESYSTEM) {
25019b4f025eSahrens 				(void) zfs_unmount(h, NULL, 0);
25029b4f025eSahrens 			} else {
250399653d4eSeschrock 				(void) zvol_remove_link(hdl, h->zfs_name);
25049b4f025eSahrens 			}
25059b4f025eSahrens 		}
2506fa9e4066Sahrens 		zfs_close(h);
2507fa9e4066Sahrens 	} else {
2508fa9e4066Sahrens 		/* full backup stream */
2509fa9e4066Sahrens 
2510ea8dc4b6Seschrock 		(void) strcpy(zc.zc_name, zc.zc_filename);
25119b4f025eSahrens 
2512f2a3c691Sahrens 		/* make sure they aren't trying to receive into the root */
25139b4f025eSahrens 		if (strchr(zc.zc_name, '/') == NULL) {
2514fa9e4066Sahrens 			cp = strchr(zc.zc_name, '@');
2515fa9e4066Sahrens 			if (cp)
2516fa9e4066Sahrens 				*cp = '\0';
251799653d4eSeschrock 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
251899653d4eSeschrock 			    "destination '%s' already exists"), zc.zc_name);
251999653d4eSeschrock 			return (zfs_error(hdl, EZFS_EXISTS, errbuf));
2520fa9e4066Sahrens 		}
2521fa9e4066Sahrens 
2522fa9e4066Sahrens 		if (isprefix) {
2523fa9e4066Sahrens 			zfs_handle_t *h;
2524fa9e4066Sahrens 
25259b4f025eSahrens 			/* make sure prefix exists */
252699653d4eSeschrock 			h = zfs_open(hdl, tosnap, ZFS_TYPE_FILESYSTEM);
252799653d4eSeschrock 			if (h == NULL)
2528fa9e4066Sahrens 				return (-1);
2529ea8dc4b6Seschrock 			zfs_close(h);
2530fa9e4066Sahrens 
2531fa9e4066Sahrens 			/* create any necessary ancestors up to prefix */
25329b4f025eSahrens 			zc.zc_objset_type = DMU_OST_ZFS;
2533ea8dc4b6Seschrock 
25349b4f025eSahrens 			/*
25359b4f025eSahrens 			 * zc.zc_name is now the full name of the snap
2536ea8dc4b6Seschrock 			 * we're restoring into.  Attempt to create,
2537ea8dc4b6Seschrock 			 * mount, and share any ancestor filesystems, up
2538ea8dc4b6Seschrock 			 * to the one that was named.
25399b4f025eSahrens 			 */
2540ea8dc4b6Seschrock 			for (cp = zc.zc_name + strlen(tosnap) + 1;
2541ea8dc4b6Seschrock 			    cp = strchr(cp, '/'); *cp = '/', cp++) {
2542ea8dc4b6Seschrock 				const char *opname;
2543fa9e4066Sahrens 				*cp = '\0';
2544ea8dc4b6Seschrock 
254599653d4eSeschrock 				opname = dgettext(TEXT_DOMAIN, "create");
254699653d4eSeschrock 				if (zfs_create(hdl, zc.zc_name,
254799653d4eSeschrock 				    ZFS_TYPE_FILESYSTEM, NULL, NULL) != 0) {
2548ea8dc4b6Seschrock 					if (errno == EEXIST)
2549ea8dc4b6Seschrock 						continue;
2550ea8dc4b6Seschrock 					goto ancestorerr;
2551fa9e4066Sahrens 				}
2552ea8dc4b6Seschrock 
255399653d4eSeschrock 				opname = dgettext(TEXT_DOMAIN, "open");
255499653d4eSeschrock 				h = zfs_open(hdl, zc.zc_name,
255599653d4eSeschrock 				    ZFS_TYPE_FILESYSTEM);
2556ea8dc4b6Seschrock 				if (h == NULL)
2557ea8dc4b6Seschrock 					goto ancestorerr;
2558ea8dc4b6Seschrock 
255999653d4eSeschrock 				opname = dgettext(TEXT_DOMAIN, "mount");
2560ea8dc4b6Seschrock 				if (zfs_mount(h, NULL, 0) != 0)
2561ea8dc4b6Seschrock 					goto ancestorerr;
2562ea8dc4b6Seschrock 
256399653d4eSeschrock 				opname = dgettext(TEXT_DOMAIN, "share");
2564ea8dc4b6Seschrock 				if (zfs_share(h) != 0)
2565ea8dc4b6Seschrock 					goto ancestorerr;
2566ea8dc4b6Seschrock 
2567ea8dc4b6Seschrock 				zfs_close(h);
2568ea8dc4b6Seschrock 
2569ea8dc4b6Seschrock 				continue;
2570ea8dc4b6Seschrock ancestorerr:
257199653d4eSeschrock 				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
257299653d4eSeschrock 				    "failed to %s ancestor '%s'"), opname,
257399653d4eSeschrock 				    zc.zc_name);
257499653d4eSeschrock 				return (zfs_error(hdl, EZFS_BADRESTORE,
257599653d4eSeschrock 				    errbuf));
2576fa9e4066Sahrens 			}
2577fa9e4066Sahrens 		}
25789b4f025eSahrens 
25799b4f025eSahrens 		/* Make sure destination fs does not exist */
25809b4f025eSahrens 		cp = strchr(zc.zc_name, '@');
25819b4f025eSahrens 		*cp = '\0';
258299653d4eSeschrock 		if (ioctl(hdl->libzfs_fd, ZFS_IOC_OBJSET_STATS, &zc) == 0) {
258399653d4eSeschrock 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
258499653d4eSeschrock 			    "destination '%s' exists"), zc.zc_name);
258599653d4eSeschrock 			return (zfs_error(hdl, EZFS_EXISTS, errbuf));
25869b4f025eSahrens 		}
25879b4f025eSahrens 
25889b4f025eSahrens 		/* Do the recvbackup ioctl to the fs's parent. */
25899b4f025eSahrens 		cp = strrchr(zc.zc_name, '/');
25909b4f025eSahrens 		*cp = '\0';
2591fa9e4066Sahrens 	}
2592fa9e4066Sahrens 
2593fa9e4066Sahrens 	(void) strcpy(zc.zc_prop_value, tosnap);
2594fa9e4066Sahrens 	zc.zc_cookie = STDIN_FILENO;
2595fa9e4066Sahrens 	zc.zc_intsz = isprefix;
2596fa9e4066Sahrens 	if (verbose) {
2597f2a3c691Sahrens 		(void) printf("%s %s stream of %s into %s\n",
2598f2a3c691Sahrens 		    dryrun ? "would receive" : "receiving",
2599fa9e4066Sahrens 		    drrb->drr_fromguid ? "incremental" : "full",
2600fa9e4066Sahrens 		    drr.drr_u.drr_begin.drr_toname,
2601ea8dc4b6Seschrock 		    zc.zc_filename);
2602fa9e4066Sahrens 		(void) fflush(stdout);
2603fa9e4066Sahrens 	}
2604fa9e4066Sahrens 	if (dryrun)
2605fa9e4066Sahrens 		return (0);
260699653d4eSeschrock 	err = ioctl_err = ioctl(hdl->libzfs_fd, ZFS_IOC_RECVBACKUP, &zc);
26079b4f025eSahrens 	if (ioctl_err != 0) {
2608fa9e4066Sahrens 		switch (errno) {
2609fa9e4066Sahrens 		case ENODEV:
261099653d4eSeschrock 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
261199653d4eSeschrock 			    "most recent snapshot does not match incremental "
261299653d4eSeschrock 			    "source"));
261399653d4eSeschrock 			(void) zfs_error(hdl, EZFS_BADRESTORE, errbuf);
2614fa9e4066Sahrens 			break;
2615fa9e4066Sahrens 		case ETXTBSY:
261699653d4eSeschrock 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
261799653d4eSeschrock 			    "destination has been modified since most recent "
261899653d4eSeschrock 			    "snapshot"));
261999653d4eSeschrock 			(void) zfs_error(hdl, EZFS_BADRESTORE, errbuf);
2620fa9e4066Sahrens 			break;
2621fa9e4066Sahrens 		case EEXIST:
2622fa9e4066Sahrens 			if (drrb->drr_fromguid == 0) {
2623fa9e4066Sahrens 				/* it's the containing fs that exists */
2624ea8dc4b6Seschrock 				cp = strchr(zc.zc_filename, '@');
2625fa9e4066Sahrens 				*cp = '\0';
2626fa9e4066Sahrens 			}
262799653d4eSeschrock 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
262899653d4eSeschrock 			    "destination already exists"));
262999653d4eSeschrock 			(void) zfs_error(hdl, EZFS_EXISTS, dgettext(TEXT_DOMAIN,
263099653d4eSeschrock 			    "cannot restore to %s"), zc.zc_filename);
2631fa9e4066Sahrens 			break;
2632fa9e4066Sahrens 		case EINVAL:
263399653d4eSeschrock 			(void) zfs_error(hdl, EZFS_BADSTREAM, errbuf);
26349b4f025eSahrens 			break;
2635ea8dc4b6Seschrock 		case ECKSUM:
263699653d4eSeschrock 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
263799653d4eSeschrock 			    "invalid stream (checksum mismatch)"));
263899653d4eSeschrock 			(void) zfs_error(hdl, EZFS_BADSTREAM, errbuf);
2639fa9e4066Sahrens 			break;
2640fa9e4066Sahrens 		default:
264199653d4eSeschrock 			(void) zfs_standard_error(hdl, errno, errbuf);
2642fa9e4066Sahrens 		}
2643fa9e4066Sahrens 	}
2644fa9e4066Sahrens 
2645fa9e4066Sahrens 	/*
26469b4f025eSahrens 	 * Mount or recreate the /dev links for the target filesystem
26479b4f025eSahrens 	 * (if created, or if we tore them down to do an incremental
26489b4f025eSahrens 	 * restore), and the /dev links for the new snapshot (if
26499b4f025eSahrens 	 * created).
2650fa9e4066Sahrens 	 */
2651ea8dc4b6Seschrock 	cp = strchr(zc.zc_filename, '@');
26529b4f025eSahrens 	if (cp && (ioctl_err == 0 || drrb->drr_fromguid)) {
2653fa9e4066Sahrens 		zfs_handle_t *h;
2654fa9e4066Sahrens 
2655fa9e4066Sahrens 		*cp = '\0';
265699653d4eSeschrock 		h = zfs_open(hdl, zc.zc_filename,
2657fa9e4066Sahrens 		    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
26589b4f025eSahrens 		*cp = '@';
2659fa9e4066Sahrens 		if (h) {
26609b4f025eSahrens 			if (h->zfs_type == ZFS_TYPE_FILESYSTEM) {
2661fa9e4066Sahrens 				err = zfs_mount(h, NULL, 0);
26629b4f025eSahrens 			} else {
266399653d4eSeschrock 				err = zvol_create_link(hdl, h->zfs_name);
2664ea8dc4b6Seschrock 				if (err == 0 && ioctl_err == 0)
266599653d4eSeschrock 					err = zvol_create_link(hdl,
266699653d4eSeschrock 					    zc.zc_filename);
26679b4f025eSahrens 			}
2668fa9e4066Sahrens 			zfs_close(h);
2669fa9e4066Sahrens 		}
2670fa9e4066Sahrens 	}
2671fa9e4066Sahrens 
26729b4f025eSahrens 	if (err || ioctl_err)
26739b4f025eSahrens 		return (-1);
2674fa9e4066Sahrens 
2675fa9e4066Sahrens 	if (verbose) {
2676fa9e4066Sahrens 		char buf1[64];
2677fa9e4066Sahrens 		char buf2[64];
2678fa9e4066Sahrens 		uint64_t bytes = zc.zc_cookie;
2679fa9e4066Sahrens 		time_t delta = time(NULL) - begin_time;
2680fa9e4066Sahrens 		if (delta == 0)
2681fa9e4066Sahrens 			delta = 1;
2682fa9e4066Sahrens 		zfs_nicenum(bytes, buf1, sizeof (buf1));
2683fa9e4066Sahrens 		zfs_nicenum(bytes/delta, buf2, sizeof (buf1));
2684fa9e4066Sahrens 
2685f2a3c691Sahrens 		(void) printf("received %sb stream in %lu seconds (%sb/sec)\n",
2686fa9e4066Sahrens 		    buf1, delta, buf2);
2687fa9e4066Sahrens 	}
2688fa9e4066Sahrens 	return (0);
2689fa9e4066Sahrens }
2690fa9e4066Sahrens 
2691fa9e4066Sahrens /*
2692b12a1c38Slling  * Destroy any more recent snapshots.  We invoke this callback on any dependents
2693b12a1c38Slling  * of the snapshot first.  If the 'cb_dependent' member is non-zero, then this
2694b12a1c38Slling  * is a dependent and we should just destroy it without checking the transaction
2695b12a1c38Slling  * group.
2696fa9e4066Sahrens  */
2697b12a1c38Slling typedef struct rollback_data {
2698b12a1c38Slling 	const char	*cb_target;		/* the snapshot */
2699b12a1c38Slling 	uint64_t	cb_create;		/* creation time reference */
2700b12a1c38Slling 	prop_changelist_t *cb_clp;		/* changelist pointer */
2701b12a1c38Slling 	int		cb_error;
270299653d4eSeschrock 	boolean_t	cb_dependent;
2703b12a1c38Slling } rollback_data_t;
2704b12a1c38Slling 
2705b12a1c38Slling static int
2706b12a1c38Slling rollback_destroy(zfs_handle_t *zhp, void *data)
2707b12a1c38Slling {
2708b12a1c38Slling 	rollback_data_t *cbp = data;
2709b12a1c38Slling 
2710b12a1c38Slling 	if (!cbp->cb_dependent) {
2711b12a1c38Slling 		if (strcmp(zhp->zfs_name, cbp->cb_target) != 0 &&
2712b12a1c38Slling 		    zfs_get_type(zhp) == ZFS_TYPE_SNAPSHOT &&
2713b12a1c38Slling 		    zfs_prop_get_int(zhp, ZFS_PROP_CREATETXG) >
2714b12a1c38Slling 		    cbp->cb_create) {
2715b12a1c38Slling 
271699653d4eSeschrock 			cbp->cb_dependent = B_TRUE;
2717b12a1c38Slling 			(void) zfs_iter_dependents(zhp, rollback_destroy, cbp);
271899653d4eSeschrock 			cbp->cb_dependent = B_FALSE;
2719b12a1c38Slling 
2720b12a1c38Slling 			if (zfs_destroy(zhp) != 0)
2721b12a1c38Slling 				cbp->cb_error = 1;
2722b12a1c38Slling 			else
2723b12a1c38Slling 				changelist_remove(zhp, cbp->cb_clp);
2724b12a1c38Slling 		}
2725b12a1c38Slling 	} else {
2726b12a1c38Slling 		if (zfs_destroy(zhp) != 0)
2727b12a1c38Slling 			cbp->cb_error = 1;
2728b12a1c38Slling 		else
2729b12a1c38Slling 			changelist_remove(zhp, cbp->cb_clp);
2730b12a1c38Slling 	}
2731b12a1c38Slling 
2732b12a1c38Slling 	zfs_close(zhp);
2733b12a1c38Slling 	return (0);
2734b12a1c38Slling }
2735b12a1c38Slling 
2736b12a1c38Slling /*
2737b12a1c38Slling  * Rollback the dataset to its latest snapshot.
2738b12a1c38Slling  */
2739b12a1c38Slling static int
2740b12a1c38Slling do_rollback(zfs_handle_t *zhp)
2741fa9e4066Sahrens {
2742fa9e4066Sahrens 	int ret;
2743fa9e4066Sahrens 	zfs_cmd_t zc = { 0 };
2744fa9e4066Sahrens 
2745fa9e4066Sahrens 	assert(zhp->zfs_type == ZFS_TYPE_FILESYSTEM ||
2746fa9e4066Sahrens 	    zhp->zfs_type == ZFS_TYPE_VOLUME);
2747fa9e4066Sahrens 
2748fa9e4066Sahrens 	if (zhp->zfs_type == ZFS_TYPE_VOLUME &&
274999653d4eSeschrock 	    zvol_remove_link(zhp->zfs_hdl, zhp->zfs_name) != 0)
2750fa9e4066Sahrens 		return (-1);
2751fa9e4066Sahrens 
2752fa9e4066Sahrens 	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
2753fa9e4066Sahrens 
2754fa9e4066Sahrens 	if (zhp->zfs_volblocksize != 0)
2755fa9e4066Sahrens 		zc.zc_objset_type = DMU_OST_ZVOL;
2756fa9e4066Sahrens 	else
2757fa9e4066Sahrens 		zc.zc_objset_type = DMU_OST_ZFS;
2758fa9e4066Sahrens 
2759fa9e4066Sahrens 	/*
2760fa9e4066Sahrens 	 * We rely on the consumer to verify that there are no newer snapshots
2761fa9e4066Sahrens 	 * for the given dataset.  Given these constraints, we can simply pass
2762fa9e4066Sahrens 	 * the name on to the ioctl() call.  There is still an unlikely race
2763fa9e4066Sahrens 	 * condition where the user has taken a snapshot since we verified that
2764fa9e4066Sahrens 	 * this was the most recent.
2765fa9e4066Sahrens 	 */
276699653d4eSeschrock 	if ((ret = ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_ROLLBACK,
276799653d4eSeschrock 	    &zc)) != 0) {
276899653d4eSeschrock 		(void) zfs_standard_error(zhp->zfs_hdl, errno,
276999653d4eSeschrock 		    dgettext(TEXT_DOMAIN, "cannot rollback '%s'"),
277099653d4eSeschrock 		    zhp->zfs_name);
2771fa9e4066Sahrens 	} else if (zhp->zfs_type == ZFS_TYPE_VOLUME) {
277299653d4eSeschrock 		ret = zvol_create_link(zhp->zfs_hdl, zhp->zfs_name);
2773fa9e4066Sahrens 	}
2774fa9e4066Sahrens 
2775fa9e4066Sahrens 	return (ret);
2776fa9e4066Sahrens }
2777fa9e4066Sahrens 
2778b12a1c38Slling /*
2779b12a1c38Slling  * Given a dataset, rollback to a specific snapshot, discarding any
2780b12a1c38Slling  * data changes since then and making it the active dataset.
2781b12a1c38Slling  *
2782b12a1c38Slling  * Any snapshots more recent than the target are destroyed, along with
2783b12a1c38Slling  * their dependents.
2784b12a1c38Slling  */
2785b12a1c38Slling int
2786b12a1c38Slling zfs_rollback(zfs_handle_t *zhp, zfs_handle_t *snap, int flag)
2787b12a1c38Slling {
2788b12a1c38Slling 	int ret;
2789b12a1c38Slling 	rollback_data_t cb = { 0 };
2790b12a1c38Slling 	prop_changelist_t *clp;
2791b12a1c38Slling 
2792b12a1c38Slling 	/*
2793b12a1c38Slling 	 * Unmount all dependendents of the dataset and the dataset itself.
2794b12a1c38Slling 	 * The list we need to gather is the same as for doing rename
2795b12a1c38Slling 	 */
2796b12a1c38Slling 	clp = changelist_gather(zhp, ZFS_PROP_NAME, flag ? MS_FORCE: 0);
2797b12a1c38Slling 	if (clp == NULL)
2798b12a1c38Slling 		return (-1);
2799b12a1c38Slling 
2800b12a1c38Slling 	if ((ret = changelist_prefix(clp)) != 0)
2801b12a1c38Slling 		goto out;
2802b12a1c38Slling 
2803b12a1c38Slling 	/*
2804b12a1c38Slling 	 * Destroy all recent snapshots and its dependends.
2805b12a1c38Slling 	 */
2806b12a1c38Slling 	cb.cb_target = snap->zfs_name;
2807b12a1c38Slling 	cb.cb_create = zfs_prop_get_int(snap, ZFS_PROP_CREATETXG);
2808b12a1c38Slling 	cb.cb_clp = clp;
2809b12a1c38Slling 	(void) zfs_iter_children(zhp, rollback_destroy, &cb);
2810b12a1c38Slling 
2811b12a1c38Slling 	if ((ret = cb.cb_error) != 0) {
2812b12a1c38Slling 		(void) changelist_postfix(clp);
2813b12a1c38Slling 		goto out;
2814b12a1c38Slling 	}
2815b12a1c38Slling 
2816b12a1c38Slling 	/*
2817b12a1c38Slling 	 * Now that we have verified that the snapshot is the latest,
2818b12a1c38Slling 	 * rollback to the given snapshot.
2819b12a1c38Slling 	 */
2820b12a1c38Slling 	ret = do_rollback(zhp);
2821b12a1c38Slling 
2822b12a1c38Slling 	if (ret != 0) {
2823b12a1c38Slling 		(void) changelist_postfix(clp);
2824b12a1c38Slling 		goto out;
2825b12a1c38Slling 	}
2826b12a1c38Slling 
2827b12a1c38Slling 	/*
2828b12a1c38Slling 	 * We only want to re-mount the filesystem if it was mounted in the
2829b12a1c38Slling 	 * first place.
2830b12a1c38Slling 	 */
2831b12a1c38Slling 	ret = changelist_postfix(clp);
2832b12a1c38Slling 
2833b12a1c38Slling out:
2834b12a1c38Slling 	changelist_free(clp);
2835b12a1c38Slling 	return (ret);
2836b12a1c38Slling }
2837b12a1c38Slling 
2838fa9e4066Sahrens /*
2839fa9e4066Sahrens  * Iterate over all dependents for a given dataset.  This includes both
2840fa9e4066Sahrens  * hierarchical dependents (children) and data dependents (snapshots and
2841fa9e4066Sahrens  * clones).  The bulk of the processing occurs in get_dependents() in
2842fa9e4066Sahrens  * libzfs_graph.c.
2843fa9e4066Sahrens  */
2844fa9e4066Sahrens int
2845fa9e4066Sahrens zfs_iter_dependents(zfs_handle_t *zhp, zfs_iter_f func, void *data)
2846fa9e4066Sahrens {
2847fa9e4066Sahrens 	char **dependents;
2848fa9e4066Sahrens 	size_t count;
2849fa9e4066Sahrens 	int i;
2850fa9e4066Sahrens 	zfs_handle_t *child;
2851fa9e4066Sahrens 	int ret = 0;
2852fa9e4066Sahrens 
285399653d4eSeschrock 	dependents = get_dependents(zhp->zfs_hdl, zhp->zfs_name, &count);
2854fa9e4066Sahrens 	for (i = 0; i < count; i++) {
285599653d4eSeschrock 		if ((child = make_dataset_handle(zhp->zfs_hdl,
285699653d4eSeschrock 		    dependents[i])) == NULL)
2857fa9e4066Sahrens 			continue;
2858fa9e4066Sahrens 
2859fa9e4066Sahrens 		if ((ret = func(child, data)) != 0)
2860fa9e4066Sahrens 			break;
2861fa9e4066Sahrens 	}
2862fa9e4066Sahrens 
2863fa9e4066Sahrens 	for (i = 0; i < count; i++)
2864fa9e4066Sahrens 		free(dependents[i]);
2865fa9e4066Sahrens 	free(dependents);
2866fa9e4066Sahrens 
2867fa9e4066Sahrens 	return (ret);
2868fa9e4066Sahrens }
2869fa9e4066Sahrens 
2870fa9e4066Sahrens /*
2871fa9e4066Sahrens  * Renames the given dataset.
2872fa9e4066Sahrens  */
2873fa9e4066Sahrens int
2874fa9e4066Sahrens zfs_rename(zfs_handle_t *zhp, const char *target)
2875fa9e4066Sahrens {
2876fa9e4066Sahrens 	int ret;
2877fa9e4066Sahrens 	zfs_cmd_t zc = { 0 };
2878fa9e4066Sahrens 	char *delim;
2879fa9e4066Sahrens 	prop_changelist_t *cl;
2880fa9e4066Sahrens 	char parent[ZFS_MAXNAMELEN];
288199653d4eSeschrock 	libzfs_handle_t *hdl = zhp->zfs_hdl;
288299653d4eSeschrock 	char errbuf[1024];
2883fa9e4066Sahrens 
2884fa9e4066Sahrens 	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
2885fa9e4066Sahrens 	(void) strlcpy(zc.zc_prop_value, target, sizeof (zc.zc_prop_value));
2886fa9e4066Sahrens 
2887fa9e4066Sahrens 	/* if we have the same exact name, just return success */
2888fa9e4066Sahrens 	if (strcmp(zhp->zfs_name, target) == 0)
2889fa9e4066Sahrens 		return (0);
2890fa9e4066Sahrens 
289199653d4eSeschrock 	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
289299653d4eSeschrock 	    "cannot rename to '%s'"), target);
289399653d4eSeschrock 
2894fa9e4066Sahrens 	/*
2895fa9e4066Sahrens 	 * Make sure the target name is valid
2896fa9e4066Sahrens 	 */
289799653d4eSeschrock 	if (!zfs_validate_name(hdl, target, zhp->zfs_type))
289899653d4eSeschrock 		return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
2899fa9e4066Sahrens 
2900fa9e4066Sahrens 	if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT) {
290199653d4eSeschrock 
2902fa9e4066Sahrens 		if ((delim = strchr(target, '@')) == NULL) {
290399653d4eSeschrock 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
290499653d4eSeschrock 			    "not a snapshot"));
290599653d4eSeschrock 			return (zfs_error(hdl, EZFS_BADTYPE, errbuf));
2906fa9e4066Sahrens 		}
2907fa9e4066Sahrens 
2908fa9e4066Sahrens 		/*
2909fa9e4066Sahrens 		 * Make sure we're renaming within the same dataset.
2910fa9e4066Sahrens 		 */
2911fa9e4066Sahrens 		if (strncmp(zhp->zfs_name, target, delim - target) != 0 ||
2912fa9e4066Sahrens 		    zhp->zfs_name[delim - target] != '@') {
291399653d4eSeschrock 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
291499653d4eSeschrock 			    "snapshots must be part of same dataset"));
291599653d4eSeschrock 			return (zfs_error(hdl, EZFS_CROSSTARGET, errbuf));
2916fa9e4066Sahrens 		}
2917fa9e4066Sahrens 
2918fa9e4066Sahrens 		(void) strncpy(parent, target, delim - target);
2919fa9e4066Sahrens 		parent[delim - target] = '\0';
2920fa9e4066Sahrens 	} else {
2921fa9e4066Sahrens 		/* validate parents */
292299653d4eSeschrock 		if (check_parents(hdl, target) != 0)
2923fa9e4066Sahrens 			return (-1);
2924fa9e4066Sahrens 
2925fa9e4066Sahrens 		(void) parent_name(target, parent, sizeof (parent));
2926fa9e4066Sahrens 
2927fa9e4066Sahrens 		/* make sure we're in the same pool */
2928fa9e4066Sahrens 		verify((delim = strchr(target, '/')) != NULL);
2929fa9e4066Sahrens 		if (strncmp(zhp->zfs_name, target, delim - target) != 0 ||
2930fa9e4066Sahrens 		    zhp->zfs_name[delim - target] != '/') {
293199653d4eSeschrock 			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
293299653d4eSeschrock 			    "datasets must be within same pool"));
293399653d4eSeschrock 			return (zfs_error(hdl, EZFS_CROSSTARGET, errbuf));
2934fa9e4066Sahrens 		}
2935fa9e4066Sahrens 	}
2936fa9e4066Sahrens 
293799653d4eSeschrock 	(void) snprintf(errbuf, sizeof (errbuf),
293899653d4eSeschrock 	    dgettext(TEXT_DOMAIN, "cannot rename '%s'"), zhp->zfs_name);
293999653d4eSeschrock 
2940fa9e4066Sahrens 	if (getzoneid() == GLOBAL_ZONEID &&
2941fa9e4066Sahrens 	    zfs_prop_get_int(zhp, ZFS_PROP_ZONED)) {
294299653d4eSeschrock 		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
294399653d4eSeschrock 		    "dataset is used in a non-global zone"));
294499653d4eSeschrock 		return (zfs_error(hdl, EZFS_ZONED, errbuf));
2945fa9e4066Sahrens 	}
2946fa9e4066Sahrens 
2947fa9e4066Sahrens 	if ((cl = changelist_gather(zhp, ZFS_PROP_NAME, 0)) == NULL)
294899653d4eSeschrock 		return (-1);
2949fa9e4066Sahrens 
2950fa9e4066Sahrens 	if (changelist_haszonedchild(cl)) {
295199653d4eSeschrock 		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
295299653d4eSeschrock 		    "child dataset with inherited mountpoint is used "
295399653d4eSeschrock 		    "in a non-global zone"));
295499653d4eSeschrock 		ret = zfs_error(hdl, EZFS_ZONED, errbuf);
2955fa9e4066Sahrens 		goto error;
2956fa9e4066Sahrens 	}
2957fa9e4066Sahrens 
2958fa9e4066Sahrens 	if ((ret = changelist_prefix(cl)) != 0)
2959fa9e4066Sahrens 		goto error;
2960fa9e4066Sahrens 
2961fa9e4066Sahrens 	if (zhp->zfs_volblocksize != 0)
2962fa9e4066Sahrens 		zc.zc_objset_type = DMU_OST_ZVOL;
2963fa9e4066Sahrens 	else
2964fa9e4066Sahrens 		zc.zc_objset_type = DMU_OST_ZFS;
2965fa9e4066Sahrens 
296699653d4eSeschrock 	if ((ret = ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_RENAME, &zc)) != 0) {
296799653d4eSeschrock 		(void) zfs_standard_error(zhp->zfs_hdl, errno, errbuf);
2968fa9e4066Sahrens 
2969fa9e4066Sahrens 		/*
2970fa9e4066Sahrens 		 * On failure, we still want to remount any filesystems that
2971fa9e4066Sahrens 		 * were previously mounted, so we don't alter the system state.
2972fa9e4066Sahrens 		 */
2973fa9e4066Sahrens 		(void) changelist_postfix(cl);
2974fa9e4066Sahrens 	} else {
2975fa9e4066Sahrens 		changelist_rename(cl, zfs_get_name(zhp), target);
2976fa9e4066Sahrens 
2977fa9e4066Sahrens 		ret = changelist_postfix(cl);
2978fa9e4066Sahrens 	}
2979fa9e4066Sahrens 
2980fa9e4066Sahrens error:
2981fa9e4066Sahrens 	changelist_free(cl);
2982fa9e4066Sahrens 	return (ret);
2983fa9e4066Sahrens }
2984fa9e4066Sahrens 
2985fa9e4066Sahrens /*
2986fa9e4066Sahrens  * Given a zvol dataset, issue the ioctl to create the appropriate minor node,
2987fa9e4066Sahrens  * poke devfsadm to create the /dev link, and then wait for the link to appear.
2988fa9e4066Sahrens  */
2989fa9e4066Sahrens int
299099653d4eSeschrock zvol_create_link(libzfs_handle_t *hdl, const char *dataset)
2991fa9e4066Sahrens {
2992fa9e4066Sahrens 	zfs_cmd_t zc = { 0 };
299399653d4eSeschrock 	di_devlink_handle_t dhdl;
2994fa9e4066Sahrens 
2995fa9e4066Sahrens 	(void) strlcpy(zc.zc_name, dataset, sizeof (zc.zc_name));
2996fa9e4066Sahrens 
2997fa9e4066Sahrens 	/*
2998fa9e4066Sahrens 	 * Issue the appropriate ioctl.
2999fa9e4066Sahrens 	 */
300099653d4eSeschrock 	if (ioctl(hdl->libzfs_fd, ZFS_IOC_CREATE_MINOR, &zc) != 0) {
3001fa9e4066Sahrens 		switch (errno) {
3002fa9e4066Sahrens 		case EEXIST:
3003fa9e4066Sahrens 			/*
3004fa9e4066Sahrens 			 * Silently ignore the case where the link already
3005fa9e4066Sahrens 			 * exists.  This allows 'zfs volinit' to be run multiple
3006fa9e4066Sahrens 			 * times without errors.
3007fa9e4066Sahrens 			 */
3008fa9e4066Sahrens 			return (0);
3009fa9e4066Sahrens 
3010fa9e4066Sahrens 		default:
301199653d4eSeschrock 			return (zfs_standard_error(hdl, errno,
301299653d4eSeschrock 			    dgettext(TEXT_DOMAIN, "cannot create device links "
301399653d4eSeschrock 			    "for '%s'"), dataset));
3014fa9e4066Sahrens 		}
3015fa9e4066Sahrens 	}
3016fa9e4066Sahrens 
3017fa9e4066Sahrens 	/*
3018fa9e4066Sahrens 	 * Call devfsadm and wait for the links to magically appear.
3019fa9e4066Sahrens 	 */
302099653d4eSeschrock 	if ((dhdl = di_devlink_init(ZFS_DRIVER, DI_MAKE_LINK)) == NULL) {
302199653d4eSeschrock 		zfs_error_aux(hdl, strerror(errno));
302299653d4eSeschrock 		(void) zfs_error(hdl, EZFS_DEVLINKS,
302399653d4eSeschrock 		    dgettext(TEXT_DOMAIN, "cannot create device links "
302499653d4eSeschrock 		    "for '%s'"), dataset);
302599653d4eSeschrock 		(void) ioctl(hdl->libzfs_fd, ZFS_IOC_REMOVE_MINOR, &zc);
3026fa9e4066Sahrens 		return (-1);
3027fa9e4066Sahrens 	} else {
302899653d4eSeschrock 		(void) di_devlink_fini(&dhdl);
3029fa9e4066Sahrens 	}
3030fa9e4066Sahrens 
3031fa9e4066Sahrens 	return (0);
3032fa9e4066Sahrens }
3033fa9e4066Sahrens 
3034fa9e4066Sahrens /*
3035fa9e4066Sahrens  * Remove a minor node for the given zvol and the associated /dev links.
3036fa9e4066Sahrens  */
3037fa9e4066Sahrens int
303899653d4eSeschrock zvol_remove_link(libzfs_handle_t *hdl, const char *dataset)
3039fa9e4066Sahrens {
3040fa9e4066Sahrens 	zfs_cmd_t zc = { 0 };
3041fa9e4066Sahrens 
3042fa9e4066Sahrens 	(void) strlcpy(zc.zc_name, dataset, sizeof (zc.zc_name));
3043fa9e4066Sahrens 
304499653d4eSeschrock 	if (ioctl(hdl->libzfs_fd, ZFS_IOC_REMOVE_MINOR, &zc) != 0) {
3045fa9e4066Sahrens 		switch (errno) {
3046fa9e4066Sahrens 		case ENXIO:
3047fa9e4066Sahrens 			/*
3048fa9e4066Sahrens 			 * Silently ignore the case where the link no longer
3049fa9e4066Sahrens 			 * exists, so that 'zfs volfini' can be run multiple
3050fa9e4066Sahrens 			 * times without errors.
3051fa9e4066Sahrens 			 */
3052fa9e4066Sahrens 			return (0);
3053fa9e4066Sahrens 
3054fa9e4066Sahrens 		default:
305599653d4eSeschrock 			return (zfs_standard_error(hdl, errno,
305699653d4eSeschrock 			    dgettext(TEXT_DOMAIN, "cannot remove device "
305799653d4eSeschrock 			    "links for '%s'"), dataset));
3058fa9e4066Sahrens 		}
3059fa9e4066Sahrens 	}
3060fa9e4066Sahrens 
3061fa9e4066Sahrens 	return (0);
3062fa9e4066Sahrens }
3063