1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22/*
23 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Copyright (c) 2018, Joyent, Inc. All rights reserved.
25 * Copyright (c) 2011, 2016 by Delphix. All rights reserved.
26 * Copyright (c) 2012 DEY Storage Systems, Inc.  All rights reserved.
27 * Copyright (c) 2011-2012 Pawel Jakub Dawidek. All rights reserved.
28 * Copyright (c) 2013 Martin Matuska. All rights reserved.
29 * Copyright (c) 2013 Steven Hartland. All rights reserved.
30 * Copyright (c) 2014 Integros [integros.com]
31 * Copyright 2017 Nexenta Systems, Inc.
32 * Copyright 2016 Igor Kozhukhov <ikozhukhov@gmail.com>
33 * Copyright 2017-2018 RackTop Systems.
34 * Copyright (c) 2019 Datto Inc.
35 */
36
37#include <ctype.h>
38#include <errno.h>
39#include <libintl.h>
40#include <math.h>
41#include <stdio.h>
42#include <stdlib.h>
43#include <strings.h>
44#include <unistd.h>
45#include <stddef.h>
46#include <zone.h>
47#include <fcntl.h>
48#include <sys/mntent.h>
49#include <sys/mount.h>
50#include <priv.h>
51#include <pwd.h>
52#include <grp.h>
53#include <stddef.h>
54#ifdef illumos
55#include <idmap.h>
56#endif
57
58#include <sys/dnode.h>
59#include <sys/spa.h>
60#include <sys/zap.h>
61#include <sys/misc.h>
62#include <libzfs.h>
63
64#include "zfs_namecheck.h"
65#include "zfs_prop.h"
66#include "libzfs_impl.h"
67#include "zfs_deleg.h"
68
69static int userquota_propname_decode(const char *propname, boolean_t zoned,
70    zfs_userquota_prop_t *typep, char *domain, int domainlen, uint64_t *ridp);
71
72/*
73 * Given a single type (not a mask of types), return the type in a human
74 * readable form.
75 */
76const char *
77zfs_type_to_name(zfs_type_t type)
78{
79	switch (type) {
80	case ZFS_TYPE_FILESYSTEM:
81		return (dgettext(TEXT_DOMAIN, "filesystem"));
82	case ZFS_TYPE_SNAPSHOT:
83		return (dgettext(TEXT_DOMAIN, "snapshot"));
84	case ZFS_TYPE_VOLUME:
85		return (dgettext(TEXT_DOMAIN, "volume"));
86	case ZFS_TYPE_POOL:
87		return (dgettext(TEXT_DOMAIN, "pool"));
88	case ZFS_TYPE_BOOKMARK:
89		return (dgettext(TEXT_DOMAIN, "bookmark"));
90	default:
91		assert(!"unhandled zfs_type_t");
92	}
93
94	return (NULL);
95}
96
97/*
98 * Validate a ZFS path.  This is used even before trying to open the dataset, to
99 * provide a more meaningful error message.  We call zfs_error_aux() to
100 * explain exactly why the name was not valid.
101 */
102int
103zfs_validate_name(libzfs_handle_t *hdl, const char *path, int type,
104    boolean_t modifying)
105{
106	namecheck_err_t why;
107	char what;
108
109	if (entity_namecheck(path, &why, &what) != 0) {
110		if (hdl != NULL) {
111			switch (why) {
112			case NAME_ERR_TOOLONG:
113				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
114				    "name is too long"));
115				break;
116
117			case NAME_ERR_LEADING_SLASH:
118				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
119				    "leading slash in name"));
120				break;
121
122			case NAME_ERR_EMPTY_COMPONENT:
123				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
124				    "empty component in name"));
125				break;
126
127			case NAME_ERR_TRAILING_SLASH:
128				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
129				    "trailing slash in name"));
130				break;
131
132			case NAME_ERR_INVALCHAR:
133				zfs_error_aux(hdl,
134				    dgettext(TEXT_DOMAIN, "invalid character "
135				    "'%c' in name"), what);
136				break;
137
138			case NAME_ERR_MULTIPLE_DELIMITERS:
139				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
140				    "multiple '@' and/or '#' delimiters in "
141				    "name"));
142				break;
143
144			case NAME_ERR_NOLETTER:
145				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
146				    "pool doesn't begin with a letter"));
147				break;
148
149			case NAME_ERR_RESERVED:
150				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
151				    "name is reserved"));
152				break;
153
154			case NAME_ERR_DISKLIKE:
155				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
156				    "reserved disk name"));
157				break;
158
159			default:
160				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
161				    "(%d) not defined"), why);
162				break;
163			}
164		}
165
166		return (0);
167	}
168
169	if (!(type & ZFS_TYPE_SNAPSHOT) && strchr(path, '@') != NULL) {
170		if (hdl != NULL)
171			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
172			    "snapshot delimiter '@' is not expected here"));
173		return (0);
174	}
175
176	if (type == ZFS_TYPE_SNAPSHOT && strchr(path, '@') == NULL) {
177		if (hdl != NULL)
178			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
179			    "missing '@' delimiter in snapshot name"));
180		return (0);
181	}
182
183	if (!(type & ZFS_TYPE_BOOKMARK) && strchr(path, '#') != NULL) {
184		if (hdl != NULL)
185			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
186			    "bookmark delimiter '#' is not expected here"));
187		return (0);
188	}
189
190	if (type == ZFS_TYPE_BOOKMARK && strchr(path, '#') == NULL) {
191		if (hdl != NULL)
192			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
193			    "missing '#' delimiter in bookmark name"));
194		return (0);
195	}
196
197	if (modifying && strchr(path, '%') != NULL) {
198		if (hdl != NULL)
199			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
200			    "invalid character %c in name"), '%');
201		return (0);
202	}
203
204	return (-1);
205}
206
207int
208zfs_name_valid(const char *name, zfs_type_t type)
209{
210	if (type == ZFS_TYPE_POOL)
211		return (zpool_name_valid(NULL, B_FALSE, name));
212	return (zfs_validate_name(NULL, name, type, B_FALSE));
213}
214
215/*
216 * This function takes the raw DSL properties, and filters out the user-defined
217 * properties into a separate nvlist.
218 */
219static nvlist_t *
220process_user_props(zfs_handle_t *zhp, nvlist_t *props)
221{
222	libzfs_handle_t *hdl = zhp->zfs_hdl;
223	nvpair_t *elem;
224	nvlist_t *propval;
225	nvlist_t *nvl;
226
227	if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) {
228		(void) no_memory(hdl);
229		return (NULL);
230	}
231
232	elem = NULL;
233	while ((elem = nvlist_next_nvpair(props, elem)) != NULL) {
234		if (!zfs_prop_user(nvpair_name(elem)))
235			continue;
236
237		verify(nvpair_value_nvlist(elem, &propval) == 0);
238		if (nvlist_add_nvlist(nvl, nvpair_name(elem), propval) != 0) {
239			nvlist_free(nvl);
240			(void) no_memory(hdl);
241			return (NULL);
242		}
243	}
244
245	return (nvl);
246}
247
248static zpool_handle_t *
249zpool_add_handle(zfs_handle_t *zhp, const char *pool_name)
250{
251	libzfs_handle_t *hdl = zhp->zfs_hdl;
252	zpool_handle_t *zph;
253
254	if ((zph = zpool_open_canfail(hdl, pool_name)) != NULL) {
255		if (hdl->libzfs_pool_handles != NULL)
256			zph->zpool_next = hdl->libzfs_pool_handles;
257		hdl->libzfs_pool_handles = zph;
258	}
259	return (zph);
260}
261
262static zpool_handle_t *
263zpool_find_handle(zfs_handle_t *zhp, const char *pool_name, int len)
264{
265	libzfs_handle_t *hdl = zhp->zfs_hdl;
266	zpool_handle_t *zph = hdl->libzfs_pool_handles;
267
268	while ((zph != NULL) &&
269	    (strncmp(pool_name, zpool_get_name(zph), len) != 0))
270		zph = zph->zpool_next;
271	return (zph);
272}
273
274/*
275 * Returns a handle to the pool that contains the provided dataset.
276 * If a handle to that pool already exists then that handle is returned.
277 * Otherwise, a new handle is created and added to the list of handles.
278 */
279static zpool_handle_t *
280zpool_handle(zfs_handle_t *zhp)
281{
282	char *pool_name;
283	int len;
284	zpool_handle_t *zph;
285
286	len = strcspn(zhp->zfs_name, "/@#") + 1;
287	pool_name = zfs_alloc(zhp->zfs_hdl, len);
288	(void) strlcpy(pool_name, zhp->zfs_name, len);
289
290	zph = zpool_find_handle(zhp, pool_name, len);
291	if (zph == NULL)
292		zph = zpool_add_handle(zhp, pool_name);
293
294	free(pool_name);
295	return (zph);
296}
297
298void
299zpool_free_handles(libzfs_handle_t *hdl)
300{
301	zpool_handle_t *next, *zph = hdl->libzfs_pool_handles;
302
303	while (zph != NULL) {
304		next = zph->zpool_next;
305		zpool_close(zph);
306		zph = next;
307	}
308	hdl->libzfs_pool_handles = NULL;
309}
310
311/*
312 * Utility function to gather stats (objset and zpl) for the given object.
313 */
314static int
315get_stats_ioctl(zfs_handle_t *zhp, zfs_cmd_t *zc)
316{
317	libzfs_handle_t *hdl = zhp->zfs_hdl;
318
319	(void) strlcpy(zc->zc_name, zhp->zfs_name, sizeof (zc->zc_name));
320
321	while (ioctl(hdl->libzfs_fd, ZFS_IOC_OBJSET_STATS, zc) != 0) {
322		if (errno == ENOMEM) {
323			if (zcmd_expand_dst_nvlist(hdl, zc) != 0) {
324				return (-1);
325			}
326		} else {
327			return (-1);
328		}
329	}
330	return (0);
331}
332
333/*
334 * Utility function to get the received properties of the given object.
335 */
336static int
337get_recvd_props_ioctl(zfs_handle_t *zhp)
338{
339	libzfs_handle_t *hdl = zhp->zfs_hdl;
340	nvlist_t *recvdprops;
341	zfs_cmd_t zc = { 0 };
342	int err;
343
344	if (zcmd_alloc_dst_nvlist(hdl, &zc, 0) != 0)
345		return (-1);
346
347	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
348
349	while (ioctl(hdl->libzfs_fd, ZFS_IOC_OBJSET_RECVD_PROPS, &zc) != 0) {
350		if (errno == ENOMEM) {
351			if (zcmd_expand_dst_nvlist(hdl, &zc) != 0) {
352				return (-1);
353			}
354		} else {
355			zcmd_free_nvlists(&zc);
356			return (-1);
357		}
358	}
359
360	err = zcmd_read_dst_nvlist(zhp->zfs_hdl, &zc, &recvdprops);
361	zcmd_free_nvlists(&zc);
362	if (err != 0)
363		return (-1);
364
365	nvlist_free(zhp->zfs_recvd_props);
366	zhp->zfs_recvd_props = recvdprops;
367
368	return (0);
369}
370
371static int
372put_stats_zhdl(zfs_handle_t *zhp, zfs_cmd_t *zc)
373{
374	nvlist_t *allprops, *userprops;
375
376	zhp->zfs_dmustats = zc->zc_objset_stats; /* structure assignment */
377
378	if (zcmd_read_dst_nvlist(zhp->zfs_hdl, zc, &allprops) != 0) {
379		return (-1);
380	}
381
382	/*
383	 * XXX Why do we store the user props separately, in addition to
384	 * storing them in zfs_props?
385	 */
386	if ((userprops = process_user_props(zhp, allprops)) == NULL) {
387		nvlist_free(allprops);
388		return (-1);
389	}
390
391	nvlist_free(zhp->zfs_props);
392	nvlist_free(zhp->zfs_user_props);
393
394	zhp->zfs_props = allprops;
395	zhp->zfs_user_props = userprops;
396
397	return (0);
398}
399
400static int
401get_stats(zfs_handle_t *zhp)
402{
403	int rc = 0;
404	zfs_cmd_t zc = { 0 };
405
406	if (zcmd_alloc_dst_nvlist(zhp->zfs_hdl, &zc, 0) != 0)
407		return (-1);
408	if (get_stats_ioctl(zhp, &zc) != 0)
409		rc = -1;
410	else if (put_stats_zhdl(zhp, &zc) != 0)
411		rc = -1;
412	zcmd_free_nvlists(&zc);
413	return (rc);
414}
415
416/*
417 * Refresh the properties currently stored in the handle.
418 */
419void
420zfs_refresh_properties(zfs_handle_t *zhp)
421{
422	(void) get_stats(zhp);
423}
424
425/*
426 * Makes a handle from the given dataset name.  Used by zfs_open() and
427 * zfs_iter_* to create child handles on the fly.
428 */
429static int
430make_dataset_handle_common(zfs_handle_t *zhp, zfs_cmd_t *zc)
431{
432	if (put_stats_zhdl(zhp, zc) != 0)
433		return (-1);
434
435	/*
436	 * We've managed to open the dataset and gather statistics.  Determine
437	 * the high-level type.
438	 */
439	if (zhp->zfs_dmustats.dds_type == DMU_OST_ZVOL)
440		zhp->zfs_head_type = ZFS_TYPE_VOLUME;
441	else if (zhp->zfs_dmustats.dds_type == DMU_OST_ZFS)
442		zhp->zfs_head_type = ZFS_TYPE_FILESYSTEM;
443	else if (zhp->zfs_dmustats.dds_type == DMU_OST_OTHER)
444		return (-1);
445	else
446		abort();
447
448	if (zhp->zfs_dmustats.dds_is_snapshot)
449		zhp->zfs_type = ZFS_TYPE_SNAPSHOT;
450	else if (zhp->zfs_dmustats.dds_type == DMU_OST_ZVOL)
451		zhp->zfs_type = ZFS_TYPE_VOLUME;
452	else if (zhp->zfs_dmustats.dds_type == DMU_OST_ZFS)
453		zhp->zfs_type = ZFS_TYPE_FILESYSTEM;
454	else
455		abort();	/* we should never see any other types */
456
457	if ((zhp->zpool_hdl = zpool_handle(zhp)) == NULL)
458		return (-1);
459
460	return (0);
461}
462
463zfs_handle_t *
464make_dataset_handle(libzfs_handle_t *hdl, const char *path)
465{
466	zfs_cmd_t zc = { 0 };
467
468	zfs_handle_t *zhp = calloc(sizeof (zfs_handle_t), 1);
469
470	if (zhp == NULL)
471		return (NULL);
472
473	zhp->zfs_hdl = hdl;
474	(void) strlcpy(zhp->zfs_name, path, sizeof (zhp->zfs_name));
475	if (zcmd_alloc_dst_nvlist(hdl, &zc, 0) != 0) {
476		free(zhp);
477		return (NULL);
478	}
479	if (get_stats_ioctl(zhp, &zc) == -1) {
480		zcmd_free_nvlists(&zc);
481		free(zhp);
482		return (NULL);
483	}
484	if (make_dataset_handle_common(zhp, &zc) == -1) {
485		free(zhp);
486		zhp = NULL;
487	}
488	zcmd_free_nvlists(&zc);
489	return (zhp);
490}
491
492zfs_handle_t *
493make_dataset_handle_zc(libzfs_handle_t *hdl, zfs_cmd_t *zc)
494{
495	zfs_handle_t *zhp = calloc(sizeof (zfs_handle_t), 1);
496
497	if (zhp == NULL)
498		return (NULL);
499
500	zhp->zfs_hdl = hdl;
501	(void) strlcpy(zhp->zfs_name, zc->zc_name, sizeof (zhp->zfs_name));
502	if (make_dataset_handle_common(zhp, zc) == -1) {
503		free(zhp);
504		return (NULL);
505	}
506	return (zhp);
507}
508
509zfs_handle_t *
510make_dataset_simple_handle_zc(zfs_handle_t *pzhp, zfs_cmd_t *zc)
511{
512	zfs_handle_t *zhp = calloc(sizeof (zfs_handle_t), 1);
513
514	if (zhp == NULL)
515		return (NULL);
516
517	zhp->zfs_hdl = pzhp->zfs_hdl;
518	(void) strlcpy(zhp->zfs_name, zc->zc_name, sizeof (zhp->zfs_name));
519	zhp->zfs_head_type = pzhp->zfs_type;
520	zhp->zfs_type = ZFS_TYPE_SNAPSHOT;
521	zhp->zpool_hdl = zpool_handle(zhp);
522	return (zhp);
523}
524
525zfs_handle_t *
526zfs_handle_dup(zfs_handle_t *zhp_orig)
527{
528	zfs_handle_t *zhp = calloc(sizeof (zfs_handle_t), 1);
529
530	if (zhp == NULL)
531		return (NULL);
532
533	zhp->zfs_hdl = zhp_orig->zfs_hdl;
534	zhp->zpool_hdl = zhp_orig->zpool_hdl;
535	(void) strlcpy(zhp->zfs_name, zhp_orig->zfs_name,
536	    sizeof (zhp->zfs_name));
537	zhp->zfs_type = zhp_orig->zfs_type;
538	zhp->zfs_head_type = zhp_orig->zfs_head_type;
539	zhp->zfs_dmustats = zhp_orig->zfs_dmustats;
540	if (zhp_orig->zfs_props != NULL) {
541		if (nvlist_dup(zhp_orig->zfs_props, &zhp->zfs_props, 0) != 0) {
542			(void) no_memory(zhp->zfs_hdl);
543			zfs_close(zhp);
544			return (NULL);
545		}
546	}
547	if (zhp_orig->zfs_user_props != NULL) {
548		if (nvlist_dup(zhp_orig->zfs_user_props,
549		    &zhp->zfs_user_props, 0) != 0) {
550			(void) no_memory(zhp->zfs_hdl);
551			zfs_close(zhp);
552			return (NULL);
553		}
554	}
555	if (zhp_orig->zfs_recvd_props != NULL) {
556		if (nvlist_dup(zhp_orig->zfs_recvd_props,
557		    &zhp->zfs_recvd_props, 0)) {
558			(void) no_memory(zhp->zfs_hdl);
559			zfs_close(zhp);
560			return (NULL);
561		}
562	}
563	zhp->zfs_mntcheck = zhp_orig->zfs_mntcheck;
564	if (zhp_orig->zfs_mntopts != NULL) {
565		zhp->zfs_mntopts = zfs_strdup(zhp_orig->zfs_hdl,
566		    zhp_orig->zfs_mntopts);
567	}
568	zhp->zfs_props_table = zhp_orig->zfs_props_table;
569	return (zhp);
570}
571
572boolean_t
573zfs_bookmark_exists(const char *path)
574{
575	nvlist_t *bmarks;
576	nvlist_t *props;
577	char fsname[ZFS_MAX_DATASET_NAME_LEN];
578	char *bmark_name;
579	char *pound;
580	int err;
581	boolean_t rv;
582
583
584	(void) strlcpy(fsname, path, sizeof (fsname));
585	pound = strchr(fsname, '#');
586	if (pound == NULL)
587		return (B_FALSE);
588
589	*pound = '\0';
590	bmark_name = pound + 1;
591	props = fnvlist_alloc();
592	err = lzc_get_bookmarks(fsname, props, &bmarks);
593	nvlist_free(props);
594	if (err != 0) {
595		nvlist_free(bmarks);
596		return (B_FALSE);
597	}
598
599	rv = nvlist_exists(bmarks, bmark_name);
600	nvlist_free(bmarks);
601	return (rv);
602}
603
604zfs_handle_t *
605make_bookmark_handle(zfs_handle_t *parent, const char *path,
606    nvlist_t *bmark_props)
607{
608	zfs_handle_t *zhp = calloc(sizeof (zfs_handle_t), 1);
609
610	if (zhp == NULL)
611		return (NULL);
612
613	/* Fill in the name. */
614	zhp->zfs_hdl = parent->zfs_hdl;
615	(void) strlcpy(zhp->zfs_name, path, sizeof (zhp->zfs_name));
616
617	/* Set the property lists. */
618	if (nvlist_dup(bmark_props, &zhp->zfs_props, 0) != 0) {
619		free(zhp);
620		return (NULL);
621	}
622
623	/* Set the types. */
624	zhp->zfs_head_type = parent->zfs_head_type;
625	zhp->zfs_type = ZFS_TYPE_BOOKMARK;
626
627	if ((zhp->zpool_hdl = zpool_handle(zhp)) == NULL) {
628		nvlist_free(zhp->zfs_props);
629		free(zhp);
630		return (NULL);
631	}
632
633	return (zhp);
634}
635
636struct zfs_open_bookmarks_cb_data {
637	const char *path;
638	zfs_handle_t *zhp;
639};
640
641static int
642zfs_open_bookmarks_cb(zfs_handle_t *zhp, void *data)
643{
644	struct zfs_open_bookmarks_cb_data *dp = data;
645
646	/*
647	 * Is it the one we are looking for?
648	 */
649	if (strcmp(dp->path, zfs_get_name(zhp)) == 0) {
650		/*
651		 * We found it.  Save it and let the caller know we are done.
652		 */
653		dp->zhp = zhp;
654		return (EEXIST);
655	}
656
657	/*
658	 * Not found.  Close the handle and ask for another one.
659	 */
660	zfs_close(zhp);
661	return (0);
662}
663
664/*
665 * Opens the given snapshot, bookmark, filesystem, or volume.   The 'types'
666 * argument is a mask of acceptable types.  The function will print an
667 * appropriate error message and return NULL if it can't be opened.
668 */
669zfs_handle_t *
670zfs_open(libzfs_handle_t *hdl, const char *path, int types)
671{
672	zfs_handle_t *zhp;
673	char errbuf[1024];
674	char *bookp;
675
676	(void) snprintf(errbuf, sizeof (errbuf),
677	    dgettext(TEXT_DOMAIN, "cannot open '%s'"), path);
678
679	/*
680	 * Validate the name before we even try to open it.
681	 */
682	if (!zfs_validate_name(hdl, path, types, B_FALSE)) {
683		(void) zfs_error(hdl, EZFS_INVALIDNAME, errbuf);
684		return (NULL);
685	}
686
687	/*
688	 * Bookmarks needs to be handled separately.
689	 */
690	bookp = strchr(path, '#');
691	if (bookp == NULL) {
692		/*
693		 * Try to get stats for the dataset, which will tell us if it
694		 * exists.
695		 */
696		errno = 0;
697		if ((zhp = make_dataset_handle(hdl, path)) == NULL) {
698			(void) zfs_standard_error(hdl, errno, errbuf);
699			return (NULL);
700		}
701	} else {
702		char dsname[ZFS_MAX_DATASET_NAME_LEN];
703		zfs_handle_t *pzhp;
704		struct zfs_open_bookmarks_cb_data cb_data = {path, NULL};
705
706		/*
707		 * We need to cut out '#' and everything after '#'
708		 * to get the parent dataset name only.
709		 */
710		assert(bookp - path < sizeof (dsname));
711		(void) strncpy(dsname, path, bookp - path);
712		dsname[bookp - path] = '\0';
713
714		/*
715		 * Create handle for the parent dataset.
716		 */
717		errno = 0;
718		if ((pzhp = make_dataset_handle(hdl, dsname)) == NULL) {
719			(void) zfs_standard_error(hdl, errno, errbuf);
720			return (NULL);
721		}
722
723		/*
724		 * Iterate bookmarks to find the right one.
725		 */
726		errno = 0;
727		if ((zfs_iter_bookmarks(pzhp, zfs_open_bookmarks_cb,
728		    &cb_data) == 0) && (cb_data.zhp == NULL)) {
729			(void) zfs_error(hdl, EZFS_NOENT, errbuf);
730			zfs_close(pzhp);
731			return (NULL);
732		}
733		if (cb_data.zhp == NULL) {
734			(void) zfs_standard_error(hdl, errno, errbuf);
735			zfs_close(pzhp);
736			return (NULL);
737		}
738		zhp = cb_data.zhp;
739
740		/*
741		 * Cleanup.
742		 */
743		zfs_close(pzhp);
744	}
745
746	if (zhp == NULL) {
747		char *at = strchr(path, '@');
748
749		if (at != NULL)
750			*at = '\0';
751		errno = 0;
752		if ((zhp = make_dataset_handle(hdl, path)) == NULL) {
753			(void) zfs_standard_error(hdl, errno, errbuf);
754			return (NULL);
755		}
756		if (at != NULL)
757			*at = '@';
758		(void) strlcpy(zhp->zfs_name, path, sizeof (zhp->zfs_name));
759		zhp->zfs_type = ZFS_TYPE_SNAPSHOT;
760	}
761
762	if (!(types & zhp->zfs_type)) {
763		(void) zfs_error(hdl, EZFS_BADTYPE, errbuf);
764		zfs_close(zhp);
765		return (NULL);
766	}
767
768	return (zhp);
769}
770
771/*
772 * Release a ZFS handle.  Nothing to do but free the associated memory.
773 */
774void
775zfs_close(zfs_handle_t *zhp)
776{
777	if (zhp->zfs_mntopts)
778		free(zhp->zfs_mntopts);
779	nvlist_free(zhp->zfs_props);
780	nvlist_free(zhp->zfs_user_props);
781	nvlist_free(zhp->zfs_recvd_props);
782	free(zhp);
783}
784
785typedef struct mnttab_node {
786	struct mnttab mtn_mt;
787	avl_node_t mtn_node;
788} mnttab_node_t;
789
790static int
791libzfs_mnttab_cache_compare(const void *arg1, const void *arg2)
792{
793	const mnttab_node_t *mtn1 = (const mnttab_node_t *)arg1;
794	const mnttab_node_t *mtn2 = (const mnttab_node_t *)arg2;
795	int rv;
796
797	rv = strcmp(mtn1->mtn_mt.mnt_special, mtn2->mtn_mt.mnt_special);
798
799	return (AVL_ISIGN(rv));
800}
801
802void
803libzfs_mnttab_init(libzfs_handle_t *hdl)
804{
805	pthread_mutex_init(&hdl->libzfs_mnttab_cache_lock, NULL);
806	assert(avl_numnodes(&hdl->libzfs_mnttab_cache) == 0);
807	avl_create(&hdl->libzfs_mnttab_cache, libzfs_mnttab_cache_compare,
808	    sizeof (mnttab_node_t), offsetof(mnttab_node_t, mtn_node));
809}
810
811void
812libzfs_mnttab_update(libzfs_handle_t *hdl)
813{
814	struct mnttab entry;
815
816	rewind(hdl->libzfs_mnttab);
817	while (getmntent(hdl->libzfs_mnttab, &entry) == 0) {
818		mnttab_node_t *mtn;
819
820		if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0)
821			continue;
822		mtn = zfs_alloc(hdl, sizeof (mnttab_node_t));
823		mtn->mtn_mt.mnt_special = zfs_strdup(hdl, entry.mnt_special);
824		mtn->mtn_mt.mnt_mountp = zfs_strdup(hdl, entry.mnt_mountp);
825		mtn->mtn_mt.mnt_fstype = zfs_strdup(hdl, entry.mnt_fstype);
826		mtn->mtn_mt.mnt_mntopts = zfs_strdup(hdl, entry.mnt_mntopts);
827		avl_add(&hdl->libzfs_mnttab_cache, mtn);
828	}
829}
830
831void
832libzfs_mnttab_fini(libzfs_handle_t *hdl)
833{
834	void *cookie = NULL;
835	mnttab_node_t *mtn;
836
837	while ((mtn = avl_destroy_nodes(&hdl->libzfs_mnttab_cache, &cookie))
838	    != NULL) {
839		free(mtn->mtn_mt.mnt_special);
840		free(mtn->mtn_mt.mnt_mountp);
841		free(mtn->mtn_mt.mnt_fstype);
842		free(mtn->mtn_mt.mnt_mntopts);
843		free(mtn);
844	}
845	avl_destroy(&hdl->libzfs_mnttab_cache);
846	(void) pthread_mutex_destroy(&hdl->libzfs_mnttab_cache_lock);
847}
848
849void
850libzfs_mnttab_cache(libzfs_handle_t *hdl, boolean_t enable)
851{
852	hdl->libzfs_mnttab_enable = enable;
853}
854
855int
856libzfs_mnttab_find(libzfs_handle_t *hdl, const char *fsname,
857    struct mnttab *entry)
858{
859	mnttab_node_t find;
860	mnttab_node_t *mtn;
861	int ret = ENOENT;
862
863	if (!hdl->libzfs_mnttab_enable) {
864		struct mnttab srch = { 0 };
865
866		if (avl_numnodes(&hdl->libzfs_mnttab_cache))
867			libzfs_mnttab_fini(hdl);
868		rewind(hdl->libzfs_mnttab);
869		srch.mnt_special = (char *)fsname;
870		srch.mnt_fstype = MNTTYPE_ZFS;
871		if (getmntany(hdl->libzfs_mnttab, entry, &srch) == 0)
872			return (0);
873		else
874			return (ENOENT);
875	}
876
877	pthread_mutex_lock(&hdl->libzfs_mnttab_cache_lock);
878	if (avl_numnodes(&hdl->libzfs_mnttab_cache) == 0)
879		libzfs_mnttab_update(hdl);
880
881	find.mtn_mt.mnt_special = (char *)fsname;
882	mtn = avl_find(&hdl->libzfs_mnttab_cache, &find, NULL);
883	if (mtn) {
884		*entry = mtn->mtn_mt;
885		ret = 0;
886	}
887	pthread_mutex_unlock(&hdl->libzfs_mnttab_cache_lock);
888	return (ret);
889}
890
891void
892libzfs_mnttab_add(libzfs_handle_t *hdl, const char *special,
893    const char *mountp, const char *mntopts)
894{
895	mnttab_node_t *mtn;
896
897	pthread_mutex_lock(&hdl->libzfs_mnttab_cache_lock);
898	if (avl_numnodes(&hdl->libzfs_mnttab_cache) == 0) {
899		mtn = zfs_alloc(hdl, sizeof (mnttab_node_t));
900		mtn->mtn_mt.mnt_special = zfs_strdup(hdl, special);
901		mtn->mtn_mt.mnt_mountp = zfs_strdup(hdl, mountp);
902		mtn->mtn_mt.mnt_fstype = zfs_strdup(hdl, MNTTYPE_ZFS);
903		mtn->mtn_mt.mnt_mntopts = zfs_strdup(hdl, mntopts);
904		avl_add(&hdl->libzfs_mnttab_cache, mtn);
905	}
906	pthread_mutex_unlock(&hdl->libzfs_mnttab_cache_lock);
907}
908
909void
910libzfs_mnttab_remove(libzfs_handle_t *hdl, const char *fsname)
911{
912	mnttab_node_t find;
913	mnttab_node_t *ret;
914
915	pthread_mutex_lock(&hdl->libzfs_mnttab_cache_lock);
916	find.mtn_mt.mnt_special = (char *)fsname;
917	if ((ret = avl_find(&hdl->libzfs_mnttab_cache, (void *)&find, NULL))
918	    != NULL) {
919		avl_remove(&hdl->libzfs_mnttab_cache, ret);
920		free(ret->mtn_mt.mnt_special);
921		free(ret->mtn_mt.mnt_mountp);
922		free(ret->mtn_mt.mnt_fstype);
923		free(ret->mtn_mt.mnt_mntopts);
924		free(ret);
925	}
926	pthread_mutex_unlock(&hdl->libzfs_mnttab_cache_lock);
927}
928
929int
930zfs_spa_version(zfs_handle_t *zhp, int *spa_version)
931{
932	zpool_handle_t *zpool_handle = zhp->zpool_hdl;
933
934	if (zpool_handle == NULL)
935		return (-1);
936
937	*spa_version = zpool_get_prop_int(zpool_handle,
938	    ZPOOL_PROP_VERSION, NULL);
939	return (0);
940}
941
942/*
943 * The choice of reservation property depends on the SPA version.
944 */
945static int
946zfs_which_resv_prop(zfs_handle_t *zhp, zfs_prop_t *resv_prop)
947{
948	int spa_version;
949
950	if (zfs_spa_version(zhp, &spa_version) < 0)
951		return (-1);
952
953	if (spa_version >= SPA_VERSION_REFRESERVATION)
954		*resv_prop = ZFS_PROP_REFRESERVATION;
955	else
956		*resv_prop = ZFS_PROP_RESERVATION;
957
958	return (0);
959}
960
961/*
962 * Given an nvlist of properties to set, validates that they are correct, and
963 * parses any numeric properties (index, boolean, etc) if they are specified as
964 * strings.
965 */
966nvlist_t *
967zfs_valid_proplist(libzfs_handle_t *hdl, zfs_type_t type, nvlist_t *nvl,
968    uint64_t zoned, zfs_handle_t *zhp, zpool_handle_t *zpool_hdl,
969    const char *errbuf)
970{
971	nvpair_t *elem;
972	uint64_t intval;
973	char *strval;
974	zfs_prop_t prop;
975	nvlist_t *ret;
976	int chosen_normal = -1;
977	int chosen_utf = -1;
978
979	if (nvlist_alloc(&ret, NV_UNIQUE_NAME, 0) != 0) {
980		(void) no_memory(hdl);
981		return (NULL);
982	}
983
984	/*
985	 * Make sure this property is valid and applies to this type.
986	 */
987
988	elem = NULL;
989	while ((elem = nvlist_next_nvpair(nvl, elem)) != NULL) {
990		const char *propname = nvpair_name(elem);
991
992		prop = zfs_name_to_prop(propname);
993		if (prop == ZPROP_INVAL && zfs_prop_user(propname)) {
994			/*
995			 * This is a user property: make sure it's a
996			 * string, and that it's less than ZAP_MAXNAMELEN.
997			 */
998			if (nvpair_type(elem) != DATA_TYPE_STRING) {
999				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1000				    "'%s' must be a string"), propname);
1001				(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
1002				goto error;
1003			}
1004
1005			if (strlen(nvpair_name(elem)) >= ZAP_MAXNAMELEN) {
1006				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1007				    "property name '%s' is too long"),
1008				    propname);
1009				(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
1010				goto error;
1011			}
1012
1013			(void) nvpair_value_string(elem, &strval);
1014			if (nvlist_add_string(ret, propname, strval) != 0) {
1015				(void) no_memory(hdl);
1016				goto error;
1017			}
1018			continue;
1019		}
1020
1021		/*
1022		 * Currently, only user properties can be modified on
1023		 * snapshots.
1024		 */
1025		if (type == ZFS_TYPE_SNAPSHOT) {
1026			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1027			    "this property can not be modified for snapshots"));
1028			(void) zfs_error(hdl, EZFS_PROPTYPE, errbuf);
1029			goto error;
1030		}
1031
1032		if (prop == ZPROP_INVAL && zfs_prop_userquota(propname)) {
1033			zfs_userquota_prop_t uqtype;
1034			char newpropname[128];
1035			char domain[128];
1036			uint64_t rid;
1037			uint64_t valary[3];
1038
1039			if (userquota_propname_decode(propname, zoned,
1040			    &uqtype, domain, sizeof (domain), &rid) != 0) {
1041				zfs_error_aux(hdl,
1042				    dgettext(TEXT_DOMAIN,
1043				    "'%s' has an invalid user/group name"),
1044				    propname);
1045				(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
1046				goto error;
1047			}
1048
1049			if (uqtype != ZFS_PROP_USERQUOTA &&
1050			    uqtype != ZFS_PROP_GROUPQUOTA) {
1051				zfs_error_aux(hdl,
1052				    dgettext(TEXT_DOMAIN, "'%s' is readonly"),
1053				    propname);
1054				(void) zfs_error(hdl, EZFS_PROPREADONLY,
1055				    errbuf);
1056				goto error;
1057			}
1058
1059			if (nvpair_type(elem) == DATA_TYPE_STRING) {
1060				(void) nvpair_value_string(elem, &strval);
1061				if (strcmp(strval, "none") == 0) {
1062					intval = 0;
1063				} else if (zfs_nicestrtonum(hdl,
1064				    strval, &intval) != 0) {
1065					(void) zfs_error(hdl,
1066					    EZFS_BADPROP, errbuf);
1067					goto error;
1068				}
1069			} else if (nvpair_type(elem) ==
1070			    DATA_TYPE_UINT64) {
1071				(void) nvpair_value_uint64(elem, &intval);
1072				if (intval == 0) {
1073					zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1074					    "use 'none' to disable "
1075					    "userquota/groupquota"));
1076					goto error;
1077				}
1078			} else {
1079				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1080				    "'%s' must be a number"), propname);
1081				(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
1082				goto error;
1083			}
1084
1085			/*
1086			 * Encode the prop name as
1087			 * userquota@<hex-rid>-domain, to make it easy
1088			 * for the kernel to decode.
1089			 */
1090			(void) snprintf(newpropname, sizeof (newpropname),
1091			    "%s%llx-%s", zfs_userquota_prop_prefixes[uqtype],
1092			    (longlong_t)rid, domain);
1093			valary[0] = uqtype;
1094			valary[1] = rid;
1095			valary[2] = intval;
1096			if (nvlist_add_uint64_array(ret, newpropname,
1097			    valary, 3) != 0) {
1098				(void) no_memory(hdl);
1099				goto error;
1100			}
1101			continue;
1102		} else if (prop == ZPROP_INVAL && zfs_prop_written(propname)) {
1103			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1104			    "'%s' is readonly"),
1105			    propname);
1106			(void) zfs_error(hdl, EZFS_PROPREADONLY, errbuf);
1107			goto error;
1108		}
1109
1110		if (prop == ZPROP_INVAL) {
1111			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1112			    "invalid property '%s'"), propname);
1113			(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
1114			goto error;
1115		}
1116
1117		if (!zfs_prop_valid_for_type(prop, type)) {
1118			zfs_error_aux(hdl,
1119			    dgettext(TEXT_DOMAIN, "'%s' does not "
1120			    "apply to datasets of this type"), propname);
1121			(void) zfs_error(hdl, EZFS_PROPTYPE, errbuf);
1122			goto error;
1123		}
1124
1125		if (zfs_prop_readonly(prop) &&
1126		    (!zfs_prop_setonce(prop) || zhp != NULL)) {
1127			zfs_error_aux(hdl,
1128			    dgettext(TEXT_DOMAIN, "'%s' is readonly"),
1129			    propname);
1130			(void) zfs_error(hdl, EZFS_PROPREADONLY, errbuf);
1131			goto error;
1132		}
1133
1134		if (zprop_parse_value(hdl, elem, prop, type, ret,
1135		    &strval, &intval, errbuf) != 0)
1136			goto error;
1137
1138		/*
1139		 * Perform some additional checks for specific properties.
1140		 */
1141		switch (prop) {
1142		case ZFS_PROP_VERSION:
1143		{
1144			int version;
1145
1146			if (zhp == NULL)
1147				break;
1148			version = zfs_prop_get_int(zhp, ZFS_PROP_VERSION);
1149			if (intval < version) {
1150				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1151				    "Can not downgrade; already at version %u"),
1152				    version);
1153				(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
1154				goto error;
1155			}
1156			break;
1157		}
1158
1159		case ZFS_PROP_VOLBLOCKSIZE:
1160		case ZFS_PROP_RECORDSIZE:
1161		{
1162			int maxbs = SPA_MAXBLOCKSIZE;
1163			if (zpool_hdl != NULL) {
1164				maxbs = zpool_get_prop_int(zpool_hdl,
1165				    ZPOOL_PROP_MAXBLOCKSIZE, NULL);
1166			}
1167			/*
1168			 * Volumes are limited to a volblocksize of 128KB,
1169			 * because they typically service workloads with
1170			 * small random writes, which incur a large performance
1171			 * penalty with large blocks.
1172			 */
1173			if (prop == ZFS_PROP_VOLBLOCKSIZE)
1174				maxbs = SPA_OLD_MAXBLOCKSIZE;
1175			/*
1176			 * The value must be a power of two between
1177			 * SPA_MINBLOCKSIZE and maxbs.
1178			 */
1179			if (intval < SPA_MINBLOCKSIZE ||
1180			    intval > maxbs || !ISP2(intval)) {
1181				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1182				    "'%s' must be power of 2 from 512B "
1183				    "to %uKB"), propname, maxbs >> 10);
1184				(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
1185				goto error;
1186			}
1187			break;
1188		}
1189
1190		case ZFS_PROP_SPECIAL_SMALL_BLOCKS:
1191			if (zpool_hdl != NULL) {
1192				char state[64] = "";
1193
1194				/*
1195				 * Issue a warning but do not fail so that
1196				 * tests for setable properties succeed.
1197				 */
1198				if (zpool_prop_get_feature(zpool_hdl,
1199				    "feature@allocation_classes", state,
1200				    sizeof (state)) != 0 ||
1201				    strcmp(state, ZFS_FEATURE_ACTIVE) != 0) {
1202					(void) fprintf(stderr, gettext(
1203					    "%s: property requires a special "
1204					    "device in the pool\n"), propname);
1205				}
1206			}
1207			if (intval != 0 &&
1208			    (intval < SPA_MINBLOCKSIZE ||
1209			    intval > SPA_OLD_MAXBLOCKSIZE || !ISP2(intval))) {
1210				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1211				    "invalid '%s=%d' property: must be zero or "
1212				    "a power of 2 from 512B to 128K"), propname,
1213				    intval);
1214				(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
1215				goto error;
1216			}
1217			break;
1218
1219		case ZFS_PROP_MLSLABEL:
1220		{
1221#ifdef illumos
1222			/*
1223			 * Verify the mlslabel string and convert to
1224			 * internal hex label string.
1225			 */
1226
1227			m_label_t *new_sl;
1228			char *hex = NULL;	/* internal label string */
1229
1230			/* Default value is already OK. */
1231			if (strcasecmp(strval, ZFS_MLSLABEL_DEFAULT) == 0)
1232				break;
1233
1234			/* Verify the label can be converted to binary form */
1235			if (((new_sl = m_label_alloc(MAC_LABEL)) == NULL) ||
1236			    (str_to_label(strval, &new_sl, MAC_LABEL,
1237			    L_NO_CORRECTION, NULL) == -1)) {
1238				goto badlabel;
1239			}
1240
1241			/* Now translate to hex internal label string */
1242			if (label_to_str(new_sl, &hex, M_INTERNAL,
1243			    DEF_NAMES) != 0) {
1244				if (hex)
1245					free(hex);
1246				goto badlabel;
1247			}
1248			m_label_free(new_sl);
1249
1250			/* If string is already in internal form, we're done. */
1251			if (strcmp(strval, hex) == 0) {
1252				free(hex);
1253				break;
1254			}
1255
1256			/* Replace the label string with the internal form. */
1257			(void) nvlist_remove(ret, zfs_prop_to_name(prop),
1258			    DATA_TYPE_STRING);
1259			verify(nvlist_add_string(ret, zfs_prop_to_name(prop),
1260			    hex) == 0);
1261			free(hex);
1262
1263			break;
1264
1265badlabel:
1266			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1267			    "invalid mlslabel '%s'"), strval);
1268			(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
1269			m_label_free(new_sl);	/* OK if null */
1270#else	/* !illumos */
1271			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1272			    "mlslabel is not supported on FreeBSD"));
1273			(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
1274#endif	/* illumos */
1275			goto error;
1276
1277		}
1278
1279		case ZFS_PROP_MOUNTPOINT:
1280		{
1281			namecheck_err_t why;
1282
1283			if (strcmp(strval, ZFS_MOUNTPOINT_NONE) == 0 ||
1284			    strcmp(strval, ZFS_MOUNTPOINT_LEGACY) == 0)
1285				break;
1286
1287			if (mountpoint_namecheck(strval, &why)) {
1288				switch (why) {
1289				case NAME_ERR_LEADING_SLASH:
1290					zfs_error_aux(hdl,
1291					    dgettext(TEXT_DOMAIN,
1292					    "'%s' must be an absolute path, "
1293					    "'none', or 'legacy'"), propname);
1294					break;
1295				case NAME_ERR_TOOLONG:
1296					zfs_error_aux(hdl,
1297					    dgettext(TEXT_DOMAIN,
1298					    "component of '%s' is too long"),
1299					    propname);
1300					break;
1301
1302				default:
1303					zfs_error_aux(hdl,
1304					    dgettext(TEXT_DOMAIN,
1305					    "(%d) not defined"),
1306					    why);
1307					break;
1308				}
1309				(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
1310				goto error;
1311			}
1312		}
1313
1314			/*FALLTHRU*/
1315
1316		case ZFS_PROP_SHARESMB:
1317		case ZFS_PROP_SHARENFS:
1318			/*
1319			 * For the mountpoint and sharenfs or sharesmb
1320			 * properties, check if it can be set in a
1321			 * global/non-global zone based on
1322			 * the zoned property value:
1323			 *
1324			 *		global zone	    non-global zone
1325			 * --------------------------------------------------
1326			 * zoned=on	mountpoint (no)	    mountpoint (yes)
1327			 *		sharenfs (no)	    sharenfs (no)
1328			 *		sharesmb (no)	    sharesmb (no)
1329			 *
1330			 * zoned=off	mountpoint (yes)	N/A
1331			 *		sharenfs (yes)
1332			 *		sharesmb (yes)
1333			 */
1334			if (zoned) {
1335				if (getzoneid() == GLOBAL_ZONEID) {
1336					zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1337					    "'%s' cannot be set on "
1338					    "dataset in a non-global zone"),
1339					    propname);
1340					(void) zfs_error(hdl, EZFS_ZONED,
1341					    errbuf);
1342					goto error;
1343				} else if (prop == ZFS_PROP_SHARENFS ||
1344				    prop == ZFS_PROP_SHARESMB) {
1345					zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1346					    "'%s' cannot be set in "
1347					    "a non-global zone"), propname);
1348					(void) zfs_error(hdl, EZFS_ZONED,
1349					    errbuf);
1350					goto error;
1351				}
1352			} else if (getzoneid() != GLOBAL_ZONEID) {
1353				/*
1354				 * If zoned property is 'off', this must be in
1355				 * a global zone. If not, something is wrong.
1356				 */
1357				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1358				    "'%s' cannot be set while dataset "
1359				    "'zoned' property is set"), propname);
1360				(void) zfs_error(hdl, EZFS_ZONED, errbuf);
1361				goto error;
1362			}
1363
1364			/*
1365			 * At this point, it is legitimate to set the
1366			 * property. Now we want to make sure that the
1367			 * property value is valid if it is sharenfs.
1368			 */
1369			if ((prop == ZFS_PROP_SHARENFS ||
1370			    prop == ZFS_PROP_SHARESMB) &&
1371			    strcmp(strval, "on") != 0 &&
1372			    strcmp(strval, "off") != 0) {
1373				zfs_share_proto_t proto;
1374
1375				if (prop == ZFS_PROP_SHARESMB)
1376					proto = PROTO_SMB;
1377				else
1378					proto = PROTO_NFS;
1379
1380				/*
1381				 * Must be an valid sharing protocol
1382				 * option string so init the libshare
1383				 * in order to enable the parser and
1384				 * then parse the options. We use the
1385				 * control API since we don't care about
1386				 * the current configuration and don't
1387				 * want the overhead of loading it
1388				 * until we actually do something.
1389				 */
1390
1391				if (zfs_init_libshare(hdl,
1392				    SA_INIT_CONTROL_API) != SA_OK) {
1393					/*
1394					 * An error occurred so we can't do
1395					 * anything
1396					 */
1397					zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1398					    "'%s' cannot be set: problem "
1399					    "in share initialization"),
1400					    propname);
1401					(void) zfs_error(hdl, EZFS_BADPROP,
1402					    errbuf);
1403					goto error;
1404				}
1405
1406				if (zfs_parse_options(strval, proto) != SA_OK) {
1407					/*
1408					 * There was an error in parsing so
1409					 * deal with it by issuing an error
1410					 * message and leaving after
1411					 * uninitializing the the libshare
1412					 * interface.
1413					 */
1414					zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1415					    "'%s' cannot be set to invalid "
1416					    "options"), propname);
1417					(void) zfs_error(hdl, EZFS_BADPROP,
1418					    errbuf);
1419					zfs_uninit_libshare(hdl);
1420					goto error;
1421				}
1422				zfs_uninit_libshare(hdl);
1423			}
1424
1425			break;
1426
1427		case ZFS_PROP_UTF8ONLY:
1428			chosen_utf = (int)intval;
1429			break;
1430
1431		case ZFS_PROP_NORMALIZE:
1432			chosen_normal = (int)intval;
1433			break;
1434
1435		default:
1436			break;
1437		}
1438
1439		/*
1440		 * For changes to existing volumes, we have some additional
1441		 * checks to enforce.
1442		 */
1443		if (type == ZFS_TYPE_VOLUME && zhp != NULL) {
1444			uint64_t volsize = zfs_prop_get_int(zhp,
1445			    ZFS_PROP_VOLSIZE);
1446			uint64_t blocksize = zfs_prop_get_int(zhp,
1447			    ZFS_PROP_VOLBLOCKSIZE);
1448			char buf[64];
1449
1450			switch (prop) {
1451			case ZFS_PROP_RESERVATION:
1452				if (intval > volsize) {
1453					zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1454					    "'%s' is greater than current "
1455					    "volume size"), propname);
1456					(void) zfs_error(hdl, EZFS_BADPROP,
1457					    errbuf);
1458					goto error;
1459				}
1460				break;
1461
1462			case ZFS_PROP_REFRESERVATION:
1463				if (intval > volsize && intval != UINT64_MAX) {
1464					zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1465					    "'%s' is greater than current "
1466					    "volume size"), propname);
1467					(void) zfs_error(hdl, EZFS_BADPROP,
1468					    errbuf);
1469					goto error;
1470				}
1471				break;
1472
1473			case ZFS_PROP_VOLSIZE:
1474				if (intval % blocksize != 0) {
1475					zfs_nicenum(blocksize, buf,
1476					    sizeof (buf));
1477					zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1478					    "'%s' must be a multiple of "
1479					    "volume block size (%s)"),
1480					    propname, buf);
1481					(void) zfs_error(hdl, EZFS_BADPROP,
1482					    errbuf);
1483					goto error;
1484				}
1485
1486				if (intval == 0) {
1487					zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1488					    "'%s' cannot be zero"),
1489					    propname);
1490					(void) zfs_error(hdl, EZFS_BADPROP,
1491					    errbuf);
1492					goto error;
1493				}
1494				break;
1495
1496			default:
1497				break;
1498			}
1499		}
1500	}
1501
1502	/*
1503	 * If normalization was chosen, but no UTF8 choice was made,
1504	 * enforce rejection of non-UTF8 names.
1505	 *
1506	 * If normalization was chosen, but rejecting non-UTF8 names
1507	 * was explicitly not chosen, it is an error.
1508	 */
1509	if (chosen_normal > 0 && chosen_utf < 0) {
1510		if (nvlist_add_uint64(ret,
1511		    zfs_prop_to_name(ZFS_PROP_UTF8ONLY), 1) != 0) {
1512			(void) no_memory(hdl);
1513			goto error;
1514		}
1515	} else if (chosen_normal > 0 && chosen_utf == 0) {
1516		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1517		    "'%s' must be set 'on' if normalization chosen"),
1518		    zfs_prop_to_name(ZFS_PROP_UTF8ONLY));
1519		(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
1520		goto error;
1521	}
1522	return (ret);
1523
1524error:
1525	nvlist_free(ret);
1526	return (NULL);
1527}
1528
1529int
1530zfs_add_synthetic_resv(zfs_handle_t *zhp, nvlist_t *nvl)
1531{
1532	uint64_t old_volsize;
1533	uint64_t new_volsize;
1534	uint64_t old_reservation;
1535	uint64_t new_reservation;
1536	zfs_prop_t resv_prop;
1537	nvlist_t *props;
1538
1539	/*
1540	 * If this is an existing volume, and someone is setting the volsize,
1541	 * make sure that it matches the reservation, or add it if necessary.
1542	 */
1543	old_volsize = zfs_prop_get_int(zhp, ZFS_PROP_VOLSIZE);
1544	if (zfs_which_resv_prop(zhp, &resv_prop) < 0)
1545		return (-1);
1546	old_reservation = zfs_prop_get_int(zhp, resv_prop);
1547
1548	props = fnvlist_alloc();
1549	fnvlist_add_uint64(props, zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE),
1550	    zfs_prop_get_int(zhp, ZFS_PROP_VOLBLOCKSIZE));
1551
1552	if ((zvol_volsize_to_reservation(old_volsize, props) !=
1553	    old_reservation) || nvlist_exists(nvl,
1554	    zfs_prop_to_name(resv_prop))) {
1555		fnvlist_free(props);
1556		return (0);
1557	}
1558	if (nvlist_lookup_uint64(nvl, zfs_prop_to_name(ZFS_PROP_VOLSIZE),
1559	    &new_volsize) != 0) {
1560		fnvlist_free(props);
1561		return (-1);
1562	}
1563	new_reservation = zvol_volsize_to_reservation(new_volsize, props);
1564	fnvlist_free(props);
1565
1566	if (nvlist_add_uint64(nvl, zfs_prop_to_name(resv_prop),
1567	    new_reservation) != 0) {
1568		(void) no_memory(zhp->zfs_hdl);
1569		return (-1);
1570	}
1571	return (1);
1572}
1573
1574/*
1575 * Helper for 'zfs {set|clone} refreservation=auto'.  Must be called after
1576 * zfs_valid_proplist(), as it is what sets the UINT64_MAX sentinal value.
1577 * Return codes must match zfs_add_synthetic_resv().
1578 */
1579static int
1580zfs_fix_auto_resv(zfs_handle_t *zhp, nvlist_t *nvl)
1581{
1582	uint64_t volsize;
1583	uint64_t resvsize;
1584	zfs_prop_t prop;
1585	nvlist_t *props;
1586
1587	if (!ZFS_IS_VOLUME(zhp)) {
1588		return (0);
1589	}
1590
1591	if (zfs_which_resv_prop(zhp, &prop) != 0) {
1592		return (-1);
1593	}
1594
1595	if (prop != ZFS_PROP_REFRESERVATION) {
1596		return (0);
1597	}
1598
1599	if (nvlist_lookup_uint64(nvl, zfs_prop_to_name(prop), &resvsize) != 0) {
1600		/* No value being set, so it can't be "auto" */
1601		return (0);
1602	}
1603	if (resvsize != UINT64_MAX) {
1604		/* Being set to a value other than "auto" */
1605		return (0);
1606	}
1607
1608	props = fnvlist_alloc();
1609
1610	fnvlist_add_uint64(props, zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE),
1611	    zfs_prop_get_int(zhp, ZFS_PROP_VOLBLOCKSIZE));
1612
1613	if (nvlist_lookup_uint64(nvl, zfs_prop_to_name(ZFS_PROP_VOLSIZE),
1614	    &volsize) != 0) {
1615		volsize = zfs_prop_get_int(zhp, ZFS_PROP_VOLSIZE);
1616	}
1617
1618	resvsize = zvol_volsize_to_reservation(volsize, props);
1619	fnvlist_free(props);
1620
1621	(void) nvlist_remove_all(nvl, zfs_prop_to_name(prop));
1622	if (nvlist_add_uint64(nvl, zfs_prop_to_name(prop), resvsize) != 0) {
1623		(void) no_memory(zhp->zfs_hdl);
1624		return (-1);
1625	}
1626	return (1);
1627}
1628
1629void
1630zfs_setprop_error(libzfs_handle_t *hdl, zfs_prop_t prop, int err,
1631    char *errbuf)
1632{
1633	switch (err) {
1634
1635	case ENOSPC:
1636		/*
1637		 * For quotas and reservations, ENOSPC indicates
1638		 * something different; setting a quota or reservation
1639		 * doesn't use any disk space.
1640		 */
1641		switch (prop) {
1642		case ZFS_PROP_QUOTA:
1643		case ZFS_PROP_REFQUOTA:
1644			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1645			    "size is less than current used or "
1646			    "reserved space"));
1647			(void) zfs_error(hdl, EZFS_PROPSPACE, errbuf);
1648			break;
1649
1650		case ZFS_PROP_RESERVATION:
1651		case ZFS_PROP_REFRESERVATION:
1652			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1653			    "size is greater than available space"));
1654			(void) zfs_error(hdl, EZFS_PROPSPACE, errbuf);
1655			break;
1656
1657		default:
1658			(void) zfs_standard_error(hdl, err, errbuf);
1659			break;
1660		}
1661		break;
1662
1663	case EBUSY:
1664		(void) zfs_standard_error(hdl, EBUSY, errbuf);
1665		break;
1666
1667	case EROFS:
1668		(void) zfs_error(hdl, EZFS_DSREADONLY, errbuf);
1669		break;
1670
1671	case E2BIG:
1672		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1673		    "property value too long"));
1674		(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
1675		break;
1676
1677	case ENOTSUP:
1678		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1679		    "pool and or dataset must be upgraded to set this "
1680		    "property or value"));
1681		(void) zfs_error(hdl, EZFS_BADVERSION, errbuf);
1682		break;
1683
1684	case ERANGE:
1685	case EDOM:
1686		if (prop == ZFS_PROP_COMPRESSION ||
1687		    prop == ZFS_PROP_RECORDSIZE) {
1688			(void) zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1689			    "property setting is not allowed on "
1690			    "bootable datasets"));
1691			(void) zfs_error(hdl, EZFS_NOTSUP, errbuf);
1692		} else if (prop == ZFS_PROP_CHECKSUM ||
1693		    prop == ZFS_PROP_DEDUP) {
1694			(void) zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1695			    "property setting is not allowed on "
1696			    "root pools"));
1697			(void) zfs_error(hdl, EZFS_NOTSUP, errbuf);
1698		} else {
1699			(void) zfs_standard_error(hdl, err, errbuf);
1700		}
1701		break;
1702
1703	case EINVAL:
1704		if (prop == ZPROP_INVAL) {
1705			(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
1706		} else {
1707			(void) zfs_standard_error(hdl, err, errbuf);
1708		}
1709		break;
1710
1711	case EOVERFLOW:
1712		/*
1713		 * This platform can't address a volume this big.
1714		 */
1715#ifdef _ILP32
1716		if (prop == ZFS_PROP_VOLSIZE) {
1717			(void) zfs_error(hdl, EZFS_VOLTOOBIG, errbuf);
1718			break;
1719		}
1720#endif
1721		/* FALLTHROUGH */
1722	default:
1723		(void) zfs_standard_error(hdl, err, errbuf);
1724	}
1725}
1726
1727/*
1728 * Given a property name and value, set the property for the given dataset.
1729 */
1730int
1731zfs_prop_set(zfs_handle_t *zhp, const char *propname, const char *propval)
1732{
1733	int ret = -1;
1734	char errbuf[1024];
1735	libzfs_handle_t *hdl = zhp->zfs_hdl;
1736	nvlist_t *nvl = NULL;
1737
1738	(void) snprintf(errbuf, sizeof (errbuf),
1739	    dgettext(TEXT_DOMAIN, "cannot set property for '%s'"),
1740	    zhp->zfs_name);
1741
1742	if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0 ||
1743	    nvlist_add_string(nvl, propname, propval) != 0) {
1744		(void) no_memory(hdl);
1745		goto error;
1746	}
1747
1748	ret = zfs_prop_set_list(zhp, nvl);
1749
1750error:
1751	nvlist_free(nvl);
1752	return (ret);
1753}
1754
1755
1756
1757/*
1758 * Given an nvlist of property names and values, set the properties for the
1759 * given dataset.
1760 */
1761int
1762zfs_prop_set_list(zfs_handle_t *zhp, nvlist_t *props)
1763{
1764	zfs_cmd_t zc = { 0 };
1765	int ret = -1;
1766	prop_changelist_t **cls = NULL;
1767	int cl_idx;
1768	char errbuf[1024];
1769	libzfs_handle_t *hdl = zhp->zfs_hdl;
1770	nvlist_t *nvl;
1771	int nvl_len;
1772	int added_resv = 0;
1773
1774	(void) snprintf(errbuf, sizeof (errbuf),
1775	    dgettext(TEXT_DOMAIN, "cannot set property for '%s'"),
1776	    zhp->zfs_name);
1777
1778	if ((nvl = zfs_valid_proplist(hdl, zhp->zfs_type, props,
1779	    zfs_prop_get_int(zhp, ZFS_PROP_ZONED), zhp, zhp->zpool_hdl,
1780	    errbuf)) == NULL)
1781		goto error;
1782
1783	/*
1784	 * We have to check for any extra properties which need to be added
1785	 * before computing the length of the nvlist.
1786	 */
1787	for (nvpair_t *elem = nvlist_next_nvpair(nvl, NULL);
1788	    elem != NULL;
1789	    elem = nvlist_next_nvpair(nvl, elem)) {
1790		if (zfs_name_to_prop(nvpair_name(elem)) == ZFS_PROP_VOLSIZE &&
1791		    (added_resv = zfs_add_synthetic_resv(zhp, nvl)) == -1) {
1792			goto error;
1793		}
1794	}
1795
1796	if (added_resv != 1 &&
1797	    (added_resv = zfs_fix_auto_resv(zhp, nvl)) == -1) {
1798		goto error;
1799	}
1800
1801	/*
1802	 * Check how many properties we're setting and allocate an array to
1803	 * store changelist pointers for postfix().
1804	 */
1805	nvl_len = 0;
1806	for (nvpair_t *elem = nvlist_next_nvpair(nvl, NULL);
1807	    elem != NULL;
1808	    elem = nvlist_next_nvpair(nvl, elem))
1809		nvl_len++;
1810	if ((cls = calloc(nvl_len, sizeof (prop_changelist_t *))) == NULL)
1811		goto error;
1812
1813	cl_idx = 0;
1814	for (nvpair_t *elem = nvlist_next_nvpair(nvl, NULL);
1815	    elem != NULL;
1816	    elem = nvlist_next_nvpair(nvl, elem)) {
1817
1818		zfs_prop_t prop = zfs_name_to_prop(nvpair_name(elem));
1819
1820		assert(cl_idx < nvl_len);
1821		/*
1822		 * We don't want to unmount & remount the dataset when changing
1823		 * its canmount property to 'on' or 'noauto'.  We only use
1824		 * the changelist logic to unmount when setting canmount=off.
1825		 */
1826		if (prop != ZFS_PROP_CANMOUNT ||
1827		    (fnvpair_value_uint64(elem) == ZFS_CANMOUNT_OFF &&
1828		    zfs_is_mounted(zhp, NULL))) {
1829			cls[cl_idx] = changelist_gather(zhp, prop, 0, 0);
1830			if (cls[cl_idx] == NULL)
1831				goto error;
1832		}
1833
1834		if (prop == ZFS_PROP_MOUNTPOINT &&
1835		    changelist_haszonedchild(cls[cl_idx])) {
1836			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1837			    "child dataset with inherited mountpoint is used "
1838			    "in a non-global zone"));
1839			ret = zfs_error(hdl, EZFS_ZONED, errbuf);
1840			goto error;
1841		}
1842
1843		/* We don't support those properties on FreeBSD. */
1844		switch (prop) {
1845		case ZFS_PROP_DEVICES:
1846		case ZFS_PROP_ISCSIOPTIONS:
1847		case ZFS_PROP_XATTR:
1848		case ZFS_PROP_VSCAN:
1849		case ZFS_PROP_NBMAND:
1850		case ZFS_PROP_MLSLABEL:
1851			(void) snprintf(errbuf, sizeof (errbuf),
1852			    "property '%s' not supported on FreeBSD",
1853			    nvpair_name(elem));
1854			ret = zfs_error(hdl, EZFS_PERM, errbuf);
1855			goto error;
1856		}
1857
1858		if (cls[cl_idx] != NULL &&
1859		    (ret = changelist_prefix(cls[cl_idx])) != 0)
1860			goto error;
1861
1862		cl_idx++;
1863	}
1864	assert(cl_idx == nvl_len);
1865
1866	/*
1867	 * Execute the corresponding ioctl() to set this list of properties.
1868	 */
1869	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
1870
1871	if ((ret = zcmd_write_src_nvlist(hdl, &zc, nvl)) != 0 ||
1872	    (ret = zcmd_alloc_dst_nvlist(hdl, &zc, 0)) != 0)
1873		goto error;
1874
1875	ret = zfs_ioctl(hdl, ZFS_IOC_SET_PROP, &zc);
1876
1877	if (ret != 0) {
1878		if (zc.zc_nvlist_dst_filled == B_FALSE) {
1879			(void) zfs_standard_error(hdl, errno, errbuf);
1880			goto error;
1881		}
1882
1883		/* Get the list of unset properties back and report them. */
1884		nvlist_t *errorprops = NULL;
1885		if (zcmd_read_dst_nvlist(hdl, &zc, &errorprops) != 0)
1886			goto error;
1887		for (nvpair_t *elem = nvlist_next_nvpair(errorprops, NULL);
1888		    elem != NULL;
1889		    elem = nvlist_next_nvpair(errorprops, elem)) {
1890			zfs_prop_t prop = zfs_name_to_prop(nvpair_name(elem));
1891			zfs_setprop_error(hdl, prop, errno, errbuf);
1892		}
1893		nvlist_free(errorprops);
1894
1895		if (added_resv && errno == ENOSPC) {
1896			/* clean up the volsize property we tried to set */
1897			uint64_t old_volsize = zfs_prop_get_int(zhp,
1898			    ZFS_PROP_VOLSIZE);
1899			nvlist_free(nvl);
1900			nvl = NULL;
1901			zcmd_free_nvlists(&zc);
1902
1903			if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0)
1904				goto error;
1905			if (nvlist_add_uint64(nvl,
1906			    zfs_prop_to_name(ZFS_PROP_VOLSIZE),
1907			    old_volsize) != 0)
1908				goto error;
1909			if (zcmd_write_src_nvlist(hdl, &zc, nvl) != 0)
1910				goto error;
1911			(void) zfs_ioctl(hdl, ZFS_IOC_SET_PROP, &zc);
1912		}
1913	} else {
1914		for (cl_idx = 0; cl_idx < nvl_len; cl_idx++) {
1915			if (cls[cl_idx] != NULL) {
1916				int clp_err = changelist_postfix(cls[cl_idx]);
1917				if (clp_err != 0)
1918					ret = clp_err;
1919			}
1920		}
1921
1922		/*
1923		 * Refresh the statistics so the new property value
1924		 * is reflected.
1925		 */
1926		if (ret == 0)
1927			(void) get_stats(zhp);
1928	}
1929
1930error:
1931	nvlist_free(nvl);
1932	zcmd_free_nvlists(&zc);
1933	if (cls != NULL) {
1934		for (cl_idx = 0; cl_idx < nvl_len; cl_idx++) {
1935			if (cls[cl_idx] != NULL)
1936				changelist_free(cls[cl_idx]);
1937		}
1938		free(cls);
1939	}
1940	return (ret);
1941}
1942
1943/*
1944 * Given a property, inherit the value from the parent dataset, or if received
1945 * is TRUE, revert to the received value, if any.
1946 */
1947int
1948zfs_prop_inherit(zfs_handle_t *zhp, const char *propname, boolean_t received)
1949{
1950	zfs_cmd_t zc = { 0 };
1951	int ret;
1952	prop_changelist_t *cl;
1953	libzfs_handle_t *hdl = zhp->zfs_hdl;
1954	char errbuf[1024];
1955	zfs_prop_t prop;
1956
1957	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
1958	    "cannot inherit %s for '%s'"), propname, zhp->zfs_name);
1959
1960	zc.zc_cookie = received;
1961	if ((prop = zfs_name_to_prop(propname)) == ZPROP_INVAL) {
1962		/*
1963		 * For user properties, the amount of work we have to do is very
1964		 * small, so just do it here.
1965		 */
1966		if (!zfs_prop_user(propname)) {
1967			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
1968			    "invalid property"));
1969			return (zfs_error(hdl, EZFS_BADPROP, errbuf));
1970		}
1971
1972		(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
1973		(void) strlcpy(zc.zc_value, propname, sizeof (zc.zc_value));
1974
1975		if (zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_INHERIT_PROP, &zc) != 0)
1976			return (zfs_standard_error(hdl, errno, errbuf));
1977
1978		return (0);
1979	}
1980
1981	/*
1982	 * Verify that this property is inheritable.
1983	 */
1984	if (zfs_prop_readonly(prop))
1985		return (zfs_error(hdl, EZFS_PROPREADONLY, errbuf));
1986
1987	if (!zfs_prop_inheritable(prop) && !received)
1988		return (zfs_error(hdl, EZFS_PROPNONINHERIT, errbuf));
1989
1990	/*
1991	 * Check to see if the value applies to this type
1992	 */
1993	if (!zfs_prop_valid_for_type(prop, zhp->zfs_type))
1994		return (zfs_error(hdl, EZFS_PROPTYPE, errbuf));
1995
1996	/*
1997	 * Normalize the name, to get rid of shorthand abbreviations.
1998	 */
1999	propname = zfs_prop_to_name(prop);
2000	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
2001	(void) strlcpy(zc.zc_value, propname, sizeof (zc.zc_value));
2002
2003	if (prop == ZFS_PROP_MOUNTPOINT && getzoneid() == GLOBAL_ZONEID &&
2004	    zfs_prop_get_int(zhp, ZFS_PROP_ZONED)) {
2005		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2006		    "dataset is used in a non-global zone"));
2007		return (zfs_error(hdl, EZFS_ZONED, errbuf));
2008	}
2009
2010	/*
2011	 * Determine datasets which will be affected by this change, if any.
2012	 */
2013	if ((cl = changelist_gather(zhp, prop, 0, 0)) == NULL)
2014		return (-1);
2015
2016	if (prop == ZFS_PROP_MOUNTPOINT && changelist_haszonedchild(cl)) {
2017		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
2018		    "child dataset with inherited mountpoint is used "
2019		    "in a non-global zone"));
2020		ret = zfs_error(hdl, EZFS_ZONED, errbuf);
2021		goto error;
2022	}
2023
2024	if ((ret = changelist_prefix(cl)) != 0)
2025		goto error;
2026
2027	if ((ret = zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_INHERIT_PROP, &zc)) != 0) {
2028		return (zfs_standard_error(hdl, errno, errbuf));
2029	} else {
2030
2031		if ((ret = changelist_postfix(cl)) != 0)
2032			goto error;
2033
2034		/*
2035		 * Refresh the statistics so the new property is reflected.
2036		 */
2037		(void) get_stats(zhp);
2038	}
2039
2040error:
2041	changelist_free(cl);
2042	return (ret);
2043}
2044
2045/*
2046 * True DSL properties are stored in an nvlist.  The following two functions
2047 * extract them appropriately.
2048 */
2049static uint64_t
2050getprop_uint64(zfs_handle_t *zhp, zfs_prop_t prop, char **source)
2051{
2052	nvlist_t *nv;
2053	uint64_t value;
2054
2055	*source = NULL;
2056	if (nvlist_lookup_nvlist(zhp->zfs_props,
2057	    zfs_prop_to_name(prop), &nv) == 0) {
2058		verify(nvlist_lookup_uint64(nv, ZPROP_VALUE, &value) == 0);
2059		(void) nvlist_lookup_string(nv, ZPROP_SOURCE, source);
2060	} else {
2061		verify(!zhp->zfs_props_table ||
2062		    zhp->zfs_props_table[prop] == B_TRUE);
2063		value = zfs_prop_default_numeric(prop);
2064		*source = "";
2065	}
2066
2067	return (value);
2068}
2069
2070static const char *
2071getprop_string(zfs_handle_t *zhp, zfs_prop_t prop, char **source)
2072{
2073	nvlist_t *nv;
2074	const char *value;
2075
2076	*source = NULL;
2077	if (nvlist_lookup_nvlist(zhp->zfs_props,
2078	    zfs_prop_to_name(prop), &nv) == 0) {
2079		value = fnvlist_lookup_string(nv, ZPROP_VALUE);
2080		(void) nvlist_lookup_string(nv, ZPROP_SOURCE, source);
2081	} else {
2082		verify(!zhp->zfs_props_table ||
2083		    zhp->zfs_props_table[prop] == B_TRUE);
2084		value = zfs_prop_default_string(prop);
2085		*source = "";
2086	}
2087
2088	return (value);
2089}
2090
2091static boolean_t
2092zfs_is_recvd_props_mode(zfs_handle_t *zhp)
2093{
2094	return (zhp->zfs_props == zhp->zfs_recvd_props);
2095}
2096
2097static void
2098zfs_set_recvd_props_mode(zfs_handle_t *zhp, uint64_t *cookie)
2099{
2100	*cookie = (uint64_t)(uintptr_t)zhp->zfs_props;
2101	zhp->zfs_props = zhp->zfs_recvd_props;
2102}
2103
2104static void
2105zfs_unset_recvd_props_mode(zfs_handle_t *zhp, uint64_t *cookie)
2106{
2107	zhp->zfs_props = (nvlist_t *)(uintptr_t)*cookie;
2108	*cookie = 0;
2109}
2110
2111/*
2112 * Internal function for getting a numeric property.  Both zfs_prop_get() and
2113 * zfs_prop_get_int() are built using this interface.
2114 *
2115 * Certain properties can be overridden using 'mount -o'.  In this case, scan
2116 * the contents of the /etc/mnttab entry, searching for the appropriate options.
2117 * If they differ from the on-disk values, report the current values and mark
2118 * the source "temporary".
2119 */
2120static int
2121get_numeric_property(zfs_handle_t *zhp, zfs_prop_t prop, zprop_source_t *src,
2122    char **source, uint64_t *val)
2123{
2124	zfs_cmd_t zc = { 0 };
2125	nvlist_t *zplprops = NULL;
2126	struct mnttab mnt;
2127	char *mntopt_on = NULL;
2128	char *mntopt_off = NULL;
2129	boolean_t received = zfs_is_recvd_props_mode(zhp);
2130
2131	*source = NULL;
2132
2133	switch (prop) {
2134	case ZFS_PROP_ATIME:
2135		mntopt_on = MNTOPT_ATIME;
2136		mntopt_off = MNTOPT_NOATIME;
2137		break;
2138
2139	case ZFS_PROP_DEVICES:
2140		mntopt_on = MNTOPT_DEVICES;
2141		mntopt_off = MNTOPT_NODEVICES;
2142		break;
2143
2144	case ZFS_PROP_EXEC:
2145		mntopt_on = MNTOPT_EXEC;
2146		mntopt_off = MNTOPT_NOEXEC;
2147		break;
2148
2149	case ZFS_PROP_READONLY:
2150		mntopt_on = MNTOPT_RO;
2151		mntopt_off = MNTOPT_RW;
2152		break;
2153
2154	case ZFS_PROP_SETUID:
2155		mntopt_on = MNTOPT_SETUID;
2156		mntopt_off = MNTOPT_NOSETUID;
2157		break;
2158
2159	case ZFS_PROP_XATTR:
2160		mntopt_on = MNTOPT_XATTR;
2161		mntopt_off = MNTOPT_NOXATTR;
2162		break;
2163
2164	case ZFS_PROP_NBMAND:
2165		mntopt_on = MNTOPT_NBMAND;
2166		mntopt_off = MNTOPT_NONBMAND;
2167		break;
2168
2169	default:
2170		break;
2171	}
2172
2173	/*
2174	 * Because looking up the mount options is potentially expensive
2175	 * (iterating over all of /etc/mnttab), we defer its calculation until
2176	 * we're looking up a property which requires its presence.
2177	 */
2178	if (!zhp->zfs_mntcheck &&
2179	    (mntopt_on != NULL || prop == ZFS_PROP_MOUNTED)) {
2180		libzfs_handle_t *hdl = zhp->zfs_hdl;
2181		struct mnttab entry;
2182
2183		if (libzfs_mnttab_find(hdl, zhp->zfs_name, &entry) == 0) {
2184			zhp->zfs_mntopts = zfs_strdup(hdl,
2185			    entry.mnt_mntopts);
2186			if (zhp->zfs_mntopts == NULL)
2187				return (-1);
2188		}
2189
2190		zhp->zfs_mntcheck = B_TRUE;
2191	}
2192
2193	if (zhp->zfs_mntopts == NULL)
2194		mnt.mnt_mntopts = "";
2195	else
2196		mnt.mnt_mntopts = zhp->zfs_mntopts;
2197
2198	switch (prop) {
2199	case ZFS_PROP_ATIME:
2200	case ZFS_PROP_DEVICES:
2201	case ZFS_PROP_EXEC:
2202	case ZFS_PROP_READONLY:
2203	case ZFS_PROP_SETUID:
2204	case ZFS_PROP_XATTR:
2205	case ZFS_PROP_NBMAND:
2206		*val = getprop_uint64(zhp, prop, source);
2207
2208		if (received)
2209			break;
2210
2211		if (hasmntopt(&mnt, mntopt_on) && !*val) {
2212			*val = B_TRUE;
2213			if (src)
2214				*src = ZPROP_SRC_TEMPORARY;
2215		} else if (hasmntopt(&mnt, mntopt_off) && *val) {
2216			*val = B_FALSE;
2217			if (src)
2218				*src = ZPROP_SRC_TEMPORARY;
2219		}
2220		break;
2221
2222	case ZFS_PROP_CANMOUNT:
2223	case ZFS_PROP_VOLSIZE:
2224	case ZFS_PROP_QUOTA:
2225	case ZFS_PROP_REFQUOTA:
2226	case ZFS_PROP_RESERVATION:
2227	case ZFS_PROP_REFRESERVATION:
2228	case ZFS_PROP_FILESYSTEM_LIMIT:
2229	case ZFS_PROP_SNAPSHOT_LIMIT:
2230	case ZFS_PROP_FILESYSTEM_COUNT:
2231	case ZFS_PROP_SNAPSHOT_COUNT:
2232		*val = getprop_uint64(zhp, prop, source);
2233
2234		if (*source == NULL) {
2235			/* not default, must be local */
2236			*source = zhp->zfs_name;
2237		}
2238		break;
2239
2240	case ZFS_PROP_MOUNTED:
2241		*val = (zhp->zfs_mntopts != NULL);
2242		break;
2243
2244	case ZFS_PROP_NUMCLONES:
2245		*val = zhp->zfs_dmustats.dds_num_clones;
2246		break;
2247
2248	case ZFS_PROP_VERSION:
2249	case ZFS_PROP_NORMALIZE:
2250	case ZFS_PROP_UTF8ONLY:
2251	case ZFS_PROP_CASE:
2252		if (!zfs_prop_valid_for_type(prop, zhp->zfs_head_type) ||
2253		    zcmd_alloc_dst_nvlist(zhp->zfs_hdl, &zc, 0) != 0)
2254			return (-1);
2255		(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
2256		if (zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_OBJSET_ZPLPROPS, &zc)) {
2257			zcmd_free_nvlists(&zc);
2258			return (-1);
2259		}
2260		if (zcmd_read_dst_nvlist(zhp->zfs_hdl, &zc, &zplprops) != 0 ||
2261		    nvlist_lookup_uint64(zplprops, zfs_prop_to_name(prop),
2262		    val) != 0) {
2263			zcmd_free_nvlists(&zc);
2264			return (-1);
2265		}
2266		nvlist_free(zplprops);
2267		zcmd_free_nvlists(&zc);
2268		break;
2269
2270	case ZFS_PROP_INCONSISTENT:
2271		*val = zhp->zfs_dmustats.dds_inconsistent;
2272		break;
2273
2274	default:
2275		switch (zfs_prop_get_type(prop)) {
2276		case PROP_TYPE_NUMBER:
2277		case PROP_TYPE_INDEX:
2278			*val = getprop_uint64(zhp, prop, source);
2279			/*
2280			 * If we tried to use a default value for a
2281			 * readonly property, it means that it was not
2282			 * present.  Note this only applies to "truly"
2283			 * readonly properties, not set-once properties
2284			 * like volblocksize.
2285			 */
2286			if (zfs_prop_readonly(prop) &&
2287			    !zfs_prop_setonce(prop) &&
2288			    *source != NULL && (*source)[0] == '\0') {
2289				*source = NULL;
2290				return (-1);
2291			}
2292			break;
2293
2294		case PROP_TYPE_STRING:
2295		default:
2296			zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
2297			    "cannot get non-numeric property"));
2298			return (zfs_error(zhp->zfs_hdl, EZFS_BADPROP,
2299			    dgettext(TEXT_DOMAIN, "internal error")));
2300		}
2301	}
2302
2303	return (0);
2304}
2305
2306/*
2307 * Calculate the source type, given the raw source string.
2308 */
2309static void
2310get_source(zfs_handle_t *zhp, zprop_source_t *srctype, char *source,
2311    char *statbuf, size_t statlen)
2312{
2313	if (statbuf == NULL || *srctype == ZPROP_SRC_TEMPORARY)
2314		return;
2315
2316	if (source == NULL) {
2317		*srctype = ZPROP_SRC_NONE;
2318	} else if (source[0] == '\0') {
2319		*srctype = ZPROP_SRC_DEFAULT;
2320	} else if (strstr(source, ZPROP_SOURCE_VAL_RECVD) != NULL) {
2321		*srctype = ZPROP_SRC_RECEIVED;
2322	} else {
2323		if (strcmp(source, zhp->zfs_name) == 0) {
2324			*srctype = ZPROP_SRC_LOCAL;
2325		} else {
2326			(void) strlcpy(statbuf, source, statlen);
2327			*srctype = ZPROP_SRC_INHERITED;
2328		}
2329	}
2330
2331}
2332
2333int
2334zfs_prop_get_recvd(zfs_handle_t *zhp, const char *propname, char *propbuf,
2335    size_t proplen, boolean_t literal)
2336{
2337	zfs_prop_t prop;
2338	int err = 0;
2339
2340	if (zhp->zfs_recvd_props == NULL)
2341		if (get_recvd_props_ioctl(zhp) != 0)
2342			return (-1);
2343
2344	prop = zfs_name_to_prop(propname);
2345
2346	if (prop != ZPROP_INVAL) {
2347		uint64_t cookie;
2348		if (!nvlist_exists(zhp->zfs_recvd_props, propname))
2349			return (-1);
2350		zfs_set_recvd_props_mode(zhp, &cookie);
2351		err = zfs_prop_get(zhp, prop, propbuf, proplen,
2352		    NULL, NULL, 0, literal);
2353		zfs_unset_recvd_props_mode(zhp, &cookie);
2354	} else {
2355		nvlist_t *propval;
2356		char *recvdval;
2357		if (nvlist_lookup_nvlist(zhp->zfs_recvd_props,
2358		    propname, &propval) != 0)
2359			return (-1);
2360		verify(nvlist_lookup_string(propval, ZPROP_VALUE,
2361		    &recvdval) == 0);
2362		(void) strlcpy(propbuf, recvdval, proplen);
2363	}
2364
2365	return (err == 0 ? 0 : -1);
2366}
2367
2368static int
2369get_clones_string(zfs_handle_t *zhp, char *propbuf, size_t proplen)
2370{
2371	nvlist_t *value;
2372	nvpair_t *pair;
2373
2374	value = zfs_get_clones_nvl(zhp);
2375	if (value == NULL)
2376		return (-1);
2377
2378	propbuf[0] = '\0';
2379	for (pair = nvlist_next_nvpair(value, NULL); pair != NULL;
2380	    pair = nvlist_next_nvpair(value, pair)) {
2381		if (propbuf[0] != '\0')
2382			(void) strlcat(propbuf, ",", proplen);
2383		(void) strlcat(propbuf, nvpair_name(pair), proplen);
2384	}
2385
2386	return (0);
2387}
2388
2389struct get_clones_arg {
2390	uint64_t numclones;
2391	nvlist_t *value;
2392	const char *origin;
2393	char buf[ZFS_MAX_DATASET_NAME_LEN];
2394};
2395
2396int
2397get_clones_cb(zfs_handle_t *zhp, void *arg)
2398{
2399	struct get_clones_arg *gca = arg;
2400
2401	if (gca->numclones == 0) {
2402		zfs_close(zhp);
2403		return (0);
2404	}
2405
2406	if (zfs_prop_get(zhp, ZFS_PROP_ORIGIN, gca->buf, sizeof (gca->buf),
2407	    NULL, NULL, 0, B_TRUE) != 0)
2408		goto out;
2409	if (strcmp(gca->buf, gca->origin) == 0) {
2410		fnvlist_add_boolean(gca->value, zfs_get_name(zhp));
2411		gca->numclones--;
2412	}
2413
2414out:
2415	(void) zfs_iter_children(zhp, get_clones_cb, gca);
2416	zfs_close(zhp);
2417	return (0);
2418}
2419
2420nvlist_t *
2421zfs_get_clones_nvl(zfs_handle_t *zhp)
2422{
2423	nvlist_t *nv, *value;
2424
2425	if (nvlist_lookup_nvlist(zhp->zfs_props,
2426	    zfs_prop_to_name(ZFS_PROP_CLONES), &nv) != 0) {
2427		struct get_clones_arg gca;
2428
2429		/*
2430		 * if this is a snapshot, then the kernel wasn't able
2431		 * to get the clones.  Do it by slowly iterating.
2432		 */
2433		if (zhp->zfs_type != ZFS_TYPE_SNAPSHOT)
2434			return (NULL);
2435		if (nvlist_alloc(&nv, NV_UNIQUE_NAME, 0) != 0)
2436			return (NULL);
2437		if (nvlist_alloc(&value, NV_UNIQUE_NAME, 0) != 0) {
2438			nvlist_free(nv);
2439			return (NULL);
2440		}
2441
2442		gca.numclones = zfs_prop_get_int(zhp, ZFS_PROP_NUMCLONES);
2443		gca.value = value;
2444		gca.origin = zhp->zfs_name;
2445
2446		if (gca.numclones != 0) {
2447			zfs_handle_t *root;
2448			char pool[ZFS_MAX_DATASET_NAME_LEN];
2449			char *cp = pool;
2450
2451			/* get the pool name */
2452			(void) strlcpy(pool, zhp->zfs_name, sizeof (pool));
2453			(void) strsep(&cp, "/@");
2454			root = zfs_open(zhp->zfs_hdl, pool,
2455			    ZFS_TYPE_FILESYSTEM);
2456
2457			(void) get_clones_cb(root, &gca);
2458		}
2459
2460		if (gca.numclones != 0 ||
2461		    nvlist_add_nvlist(nv, ZPROP_VALUE, value) != 0 ||
2462		    nvlist_add_nvlist(zhp->zfs_props,
2463		    zfs_prop_to_name(ZFS_PROP_CLONES), nv) != 0) {
2464			nvlist_free(nv);
2465			nvlist_free(value);
2466			return (NULL);
2467		}
2468		nvlist_free(nv);
2469		nvlist_free(value);
2470		verify(0 == nvlist_lookup_nvlist(zhp->zfs_props,
2471		    zfs_prop_to_name(ZFS_PROP_CLONES), &nv));
2472	}
2473
2474	verify(nvlist_lookup_nvlist(nv, ZPROP_VALUE, &value) == 0);
2475
2476	return (value);
2477}
2478
2479/*
2480 * Accepts a property and value and checks that the value
2481 * matches the one found by the channel program. If they are
2482 * not equal, print both of them.
2483 */
2484void
2485zcp_check(zfs_handle_t *zhp, zfs_prop_t prop, uint64_t intval,
2486    const char *strval)
2487{
2488	if (!zhp->zfs_hdl->libzfs_prop_debug)
2489		return;
2490	int error;
2491	char *poolname = zhp->zpool_hdl->zpool_name;
2492	const char *program =
2493	    "args = ...\n"
2494	    "ds = args['dataset']\n"
2495	    "prop = args['property']\n"
2496	    "value, setpoint = zfs.get_prop(ds, prop)\n"
2497	    "return {value=value, setpoint=setpoint}\n";
2498	nvlist_t *outnvl;
2499	nvlist_t *retnvl;
2500	nvlist_t *argnvl = fnvlist_alloc();
2501
2502	fnvlist_add_string(argnvl, "dataset", zhp->zfs_name);
2503	fnvlist_add_string(argnvl, "property", zfs_prop_to_name(prop));
2504
2505	error = lzc_channel_program_nosync(poolname, program,
2506	    10 * 1000 * 1000, 10 * 1024 * 1024, argnvl, &outnvl);
2507
2508	if (error == 0) {
2509		retnvl = fnvlist_lookup_nvlist(outnvl, "return");
2510		if (zfs_prop_get_type(prop) == PROP_TYPE_NUMBER) {
2511			int64_t ans;
2512			error = nvlist_lookup_int64(retnvl, "value", &ans);
2513			if (error != 0) {
2514				(void) fprintf(stderr, "zcp check error: %u\n",
2515				    error);
2516				return;
2517			}
2518			if (ans != intval) {
2519				(void) fprintf(stderr,
2520				    "%s: zfs found %lld, but zcp found %lld\n",
2521				    zfs_prop_to_name(prop),
2522				    (longlong_t)intval, (longlong_t)ans);
2523			}
2524		} else {
2525			char *str_ans;
2526			error = nvlist_lookup_string(retnvl, "value", &str_ans);
2527			if (error != 0) {
2528				(void) fprintf(stderr, "zcp check error: %u\n",
2529				    error);
2530				return;
2531			}
2532			if (strcmp(strval, str_ans) != 0) {
2533				(void) fprintf(stderr,
2534				    "%s: zfs found %s, but zcp found %s\n",
2535				    zfs_prop_to_name(prop),
2536				    strval, str_ans);
2537			}
2538		}
2539	} else {
2540		(void) fprintf(stderr,
2541		    "zcp check failed, channel program error: %u\n", error);
2542	}
2543	nvlist_free(argnvl);
2544	nvlist_free(outnvl);
2545}
2546
2547/*
2548 * Retrieve a property from the given object.  If 'literal' is specified, then
2549 * numbers are left as exact values.  Otherwise, numbers are converted to a
2550 * human-readable form.
2551 *
2552 * Returns 0 on success, or -1 on error.
2553 */
2554int
2555zfs_prop_get(zfs_handle_t *zhp, zfs_prop_t prop, char *propbuf, size_t proplen,
2556    zprop_source_t *src, char *statbuf, size_t statlen, boolean_t literal)
2557{
2558	char *source = NULL;
2559	uint64_t val;
2560	const char *str;
2561	const char *strval;
2562	boolean_t received = zfs_is_recvd_props_mode(zhp);
2563
2564	/*
2565	 * Check to see if this property applies to our object
2566	 */
2567	if (!zfs_prop_valid_for_type(prop, zhp->zfs_type))
2568		return (-1);
2569
2570	if (received && zfs_prop_readonly(prop))
2571		return (-1);
2572
2573	if (src)
2574		*src = ZPROP_SRC_NONE;
2575
2576	switch (prop) {
2577	case ZFS_PROP_CREATION:
2578		/*
2579		 * 'creation' is a time_t stored in the statistics.  We convert
2580		 * this into a string unless 'literal' is specified.
2581		 */
2582		{
2583			val = getprop_uint64(zhp, prop, &source);
2584			time_t time = (time_t)val;
2585			struct tm t;
2586
2587			if (literal ||
2588			    localtime_r(&time, &t) == NULL ||
2589			    strftime(propbuf, proplen, "%a %b %e %k:%M %Y",
2590			    &t) == 0)
2591				(void) snprintf(propbuf, proplen, "%llu", val);
2592		}
2593		zcp_check(zhp, prop, val, NULL);
2594		break;
2595
2596	case ZFS_PROP_MOUNTPOINT:
2597		/*
2598		 * Getting the precise mountpoint can be tricky.
2599		 *
2600		 *  - for 'none' or 'legacy', return those values.
2601		 *  - for inherited mountpoints, we want to take everything
2602		 *    after our ancestor and append it to the inherited value.
2603		 *
2604		 * If the pool has an alternate root, we want to prepend that
2605		 * root to any values we return.
2606		 */
2607
2608		str = getprop_string(zhp, prop, &source);
2609
2610		if (str[0] == '/') {
2611			char buf[MAXPATHLEN];
2612			char *root = buf;
2613			const char *relpath;
2614
2615			/*
2616			 * If we inherit the mountpoint, even from a dataset
2617			 * with a received value, the source will be the path of
2618			 * the dataset we inherit from. If source is
2619			 * ZPROP_SOURCE_VAL_RECVD, the received value is not
2620			 * inherited.
2621			 */
2622			if (strcmp(source, ZPROP_SOURCE_VAL_RECVD) == 0) {
2623				relpath = "";
2624			} else {
2625				relpath = zhp->zfs_name + strlen(source);
2626				if (relpath[0] == '/')
2627					relpath++;
2628			}
2629
2630			if ((zpool_get_prop(zhp->zpool_hdl,
2631			    ZPOOL_PROP_ALTROOT, buf, MAXPATHLEN, NULL,
2632			    B_FALSE)) || (strcmp(root, "-") == 0))
2633				root[0] = '\0';
2634			/*
2635			 * Special case an alternate root of '/'. This will
2636			 * avoid having multiple leading slashes in the
2637			 * mountpoint path.
2638			 */
2639			if (strcmp(root, "/") == 0)
2640				root++;
2641
2642			/*
2643			 * If the mountpoint is '/' then skip over this
2644			 * if we are obtaining either an alternate root or
2645			 * an inherited mountpoint.
2646			 */
2647			if (str[1] == '\0' && (root[0] != '\0' ||
2648			    relpath[0] != '\0'))
2649				str++;
2650
2651			if (relpath[0] == '\0')
2652				(void) snprintf(propbuf, proplen, "%s%s",
2653				    root, str);
2654			else
2655				(void) snprintf(propbuf, proplen, "%s%s%s%s",
2656				    root, str, relpath[0] == '@' ? "" : "/",
2657				    relpath);
2658		} else {
2659			/* 'legacy' or 'none' */
2660			(void) strlcpy(propbuf, str, proplen);
2661		}
2662		zcp_check(zhp, prop, NULL, propbuf);
2663		break;
2664
2665	case ZFS_PROP_ORIGIN:
2666		str = getprop_string(zhp, prop, &source);
2667		if (str == NULL)
2668			return (-1);
2669		(void) strlcpy(propbuf, str, proplen);
2670		zcp_check(zhp, prop, NULL, str);
2671		break;
2672
2673	case ZFS_PROP_CLONES:
2674		if (get_clones_string(zhp, propbuf, proplen) != 0)
2675			return (-1);
2676		break;
2677
2678	case ZFS_PROP_QUOTA:
2679	case ZFS_PROP_REFQUOTA:
2680	case ZFS_PROP_RESERVATION:
2681	case ZFS_PROP_REFRESERVATION:
2682
2683		if (get_numeric_property(zhp, prop, src, &source, &val) != 0)
2684			return (-1);
2685		/*
2686		 * If quota or reservation is 0, we translate this into 'none'
2687		 * (unless literal is set), and indicate that it's the default
2688		 * value.  Otherwise, we print the number nicely and indicate
2689		 * that its set locally.
2690		 */
2691		if (val == 0) {
2692			if (literal)
2693				(void) strlcpy(propbuf, "0", proplen);
2694			else
2695				(void) strlcpy(propbuf, "none", proplen);
2696		} else {
2697			if (literal)
2698				(void) snprintf(propbuf, proplen, "%llu",
2699				    (u_longlong_t)val);
2700			else
2701				zfs_nicenum(val, propbuf, proplen);
2702		}
2703		zcp_check(zhp, prop, val, NULL);
2704		break;
2705
2706	case ZFS_PROP_FILESYSTEM_LIMIT:
2707	case ZFS_PROP_SNAPSHOT_LIMIT:
2708	case ZFS_PROP_FILESYSTEM_COUNT:
2709	case ZFS_PROP_SNAPSHOT_COUNT:
2710
2711		if (get_numeric_property(zhp, prop, src, &source, &val) != 0)
2712			return (-1);
2713
2714		/*
2715		 * If limit is UINT64_MAX, we translate this into 'none' (unless
2716		 * literal is set), and indicate that it's the default value.
2717		 * Otherwise, we print the number nicely and indicate that it's
2718		 * set locally.
2719		 */
2720		if (literal) {
2721			(void) snprintf(propbuf, proplen, "%llu",
2722			    (u_longlong_t)val);
2723		} else if (val == UINT64_MAX) {
2724			(void) strlcpy(propbuf, "none", proplen);
2725		} else {
2726			zfs_nicenum(val, propbuf, proplen);
2727		}
2728
2729		zcp_check(zhp, prop, val, NULL);
2730		break;
2731
2732	case ZFS_PROP_REFRATIO:
2733	case ZFS_PROP_COMPRESSRATIO:
2734		if (get_numeric_property(zhp, prop, src, &source, &val) != 0)
2735			return (-1);
2736		(void) snprintf(propbuf, proplen, "%llu.%02llux",
2737		    (u_longlong_t)(val / 100),
2738		    (u_longlong_t)(val % 100));
2739		zcp_check(zhp, prop, val, NULL);
2740		break;
2741
2742	case ZFS_PROP_TYPE:
2743		switch (zhp->zfs_type) {
2744		case ZFS_TYPE_FILESYSTEM:
2745			str = "filesystem";
2746			break;
2747		case ZFS_TYPE_VOLUME:
2748			str = "volume";
2749			break;
2750		case ZFS_TYPE_SNAPSHOT:
2751			str = "snapshot";
2752			break;
2753		case ZFS_TYPE_BOOKMARK:
2754			str = "bookmark";
2755			break;
2756		default:
2757			abort();
2758		}
2759		(void) snprintf(propbuf, proplen, "%s", str);
2760		zcp_check(zhp, prop, NULL, propbuf);
2761		break;
2762
2763	case ZFS_PROP_MOUNTED:
2764		/*
2765		 * The 'mounted' property is a pseudo-property that described
2766		 * whether the filesystem is currently mounted.  Even though
2767		 * it's a boolean value, the typical values of "on" and "off"
2768		 * don't make sense, so we translate to "yes" and "no".
2769		 */
2770		if (get_numeric_property(zhp, ZFS_PROP_MOUNTED,
2771		    src, &source, &val) != 0)
2772			return (-1);
2773		if (val)
2774			(void) strlcpy(propbuf, "yes", proplen);
2775		else
2776			(void) strlcpy(propbuf, "no", proplen);
2777		break;
2778
2779	case ZFS_PROP_NAME:
2780		/*
2781		 * The 'name' property is a pseudo-property derived from the
2782		 * dataset name.  It is presented as a real property to simplify
2783		 * consumers.
2784		 */
2785		(void) strlcpy(propbuf, zhp->zfs_name, proplen);
2786		zcp_check(zhp, prop, NULL, propbuf);
2787		break;
2788
2789	case ZFS_PROP_MLSLABEL:
2790		{
2791#ifdef illumos
2792			m_label_t *new_sl = NULL;
2793			char *ascii = NULL;	/* human readable label */
2794
2795			(void) strlcpy(propbuf,
2796			    getprop_string(zhp, prop, &source), proplen);
2797
2798			if (literal || (strcasecmp(propbuf,
2799			    ZFS_MLSLABEL_DEFAULT) == 0))
2800				break;
2801
2802			/*
2803			 * Try to translate the internal hex string to
2804			 * human-readable output.  If there are any
2805			 * problems just use the hex string.
2806			 */
2807
2808			if (str_to_label(propbuf, &new_sl, MAC_LABEL,
2809			    L_NO_CORRECTION, NULL) == -1) {
2810				m_label_free(new_sl);
2811				break;
2812			}
2813
2814			if (label_to_str(new_sl, &ascii, M_LABEL,
2815			    DEF_NAMES) != 0) {
2816				if (ascii)
2817					free(ascii);
2818				m_label_free(new_sl);
2819				break;
2820			}
2821			m_label_free(new_sl);
2822
2823			(void) strlcpy(propbuf, ascii, proplen);
2824			free(ascii);
2825#else	/* !illumos */
2826			propbuf[0] = '\0';
2827#endif	/* illumos */
2828		}
2829		break;
2830
2831	case ZFS_PROP_GUID:
2832	case ZFS_PROP_CREATETXG:
2833		/*
2834		 * GUIDs are stored as numbers, but they are identifiers.
2835		 * We don't want them to be pretty printed, because pretty
2836		 * printing mangles the ID into a truncated and useless value.
2837		 */
2838		if (get_numeric_property(zhp, prop, src, &source, &val) != 0)
2839			return (-1);
2840		(void) snprintf(propbuf, proplen, "%llu", (u_longlong_t)val);
2841		zcp_check(zhp, prop, val, NULL);
2842		break;
2843
2844	default:
2845		switch (zfs_prop_get_type(prop)) {
2846		case PROP_TYPE_NUMBER:
2847			if (get_numeric_property(zhp, prop, src,
2848			    &source, &val) != 0) {
2849				return (-1);
2850			}
2851
2852			if (literal) {
2853				(void) snprintf(propbuf, proplen, "%llu",
2854				    (u_longlong_t)val);
2855			} else {
2856				zfs_nicenum(val, propbuf, proplen);
2857			}
2858			zcp_check(zhp, prop, val, NULL);
2859			break;
2860
2861		case PROP_TYPE_STRING:
2862			str = getprop_string(zhp, prop, &source);
2863			if (str == NULL)
2864				return (-1);
2865
2866			(void) strlcpy(propbuf, str, proplen);
2867			zcp_check(zhp, prop, NULL, str);
2868			break;
2869
2870		case PROP_TYPE_INDEX:
2871			if (get_numeric_property(zhp, prop, src,
2872			    &source, &val) != 0)
2873				return (-1);
2874			if (zfs_prop_index_to_string(prop, val, &strval) != 0)
2875				return (-1);
2876
2877			(void) strlcpy(propbuf, strval, proplen);
2878			zcp_check(zhp, prop, NULL, strval);
2879			break;
2880
2881		default:
2882			abort();
2883		}
2884	}
2885
2886	get_source(zhp, src, source, statbuf, statlen);
2887
2888	return (0);
2889}
2890
2891/*
2892 * Utility function to get the given numeric property.  Does no validation that
2893 * the given property is the appropriate type; should only be used with
2894 * hard-coded property types.
2895 */
2896uint64_t
2897zfs_prop_get_int(zfs_handle_t *zhp, zfs_prop_t prop)
2898{
2899	char *source;
2900	uint64_t val;
2901
2902	(void) get_numeric_property(zhp, prop, NULL, &source, &val);
2903
2904	return (val);
2905}
2906
2907int
2908zfs_prop_set_int(zfs_handle_t *zhp, zfs_prop_t prop, uint64_t val)
2909{
2910	char buf[64];
2911
2912	(void) snprintf(buf, sizeof (buf), "%llu", (longlong_t)val);
2913	return (zfs_prop_set(zhp, zfs_prop_to_name(prop), buf));
2914}
2915
2916/*
2917 * Similar to zfs_prop_get(), but returns the value as an integer.
2918 */
2919int
2920zfs_prop_get_numeric(zfs_handle_t *zhp, zfs_prop_t prop, uint64_t *value,
2921    zprop_source_t *src, char *statbuf, size_t statlen)
2922{
2923	char *source;
2924
2925	/*
2926	 * Check to see if this property applies to our object
2927	 */
2928	if (!zfs_prop_valid_for_type(prop, zhp->zfs_type)) {
2929		return (zfs_error_fmt(zhp->zfs_hdl, EZFS_PROPTYPE,
2930		    dgettext(TEXT_DOMAIN, "cannot get property '%s'"),
2931		    zfs_prop_to_name(prop)));
2932	}
2933
2934	if (src)
2935		*src = ZPROP_SRC_NONE;
2936
2937	if (get_numeric_property(zhp, prop, src, &source, value) != 0)
2938		return (-1);
2939
2940	get_source(zhp, src, source, statbuf, statlen);
2941
2942	return (0);
2943}
2944
2945static int
2946idmap_id_to_numeric_domain_rid(uid_t id, boolean_t isuser,
2947    char **domainp, idmap_rid_t *ridp)
2948{
2949#ifdef illumos
2950	idmap_get_handle_t *get_hdl = NULL;
2951	idmap_stat status;
2952	int err = EINVAL;
2953
2954	if (idmap_get_create(&get_hdl) != IDMAP_SUCCESS)
2955		goto out;
2956
2957	if (isuser) {
2958		err = idmap_get_sidbyuid(get_hdl, id,
2959		    IDMAP_REQ_FLG_USE_CACHE, domainp, ridp, &status);
2960	} else {
2961		err = idmap_get_sidbygid(get_hdl, id,
2962		    IDMAP_REQ_FLG_USE_CACHE, domainp, ridp, &status);
2963	}
2964	if (err == IDMAP_SUCCESS &&
2965	    idmap_get_mappings(get_hdl) == IDMAP_SUCCESS &&
2966	    status == IDMAP_SUCCESS)
2967		err = 0;
2968	else
2969		err = EINVAL;
2970out:
2971	if (get_hdl)
2972		idmap_get_destroy(get_hdl);
2973	return (err);
2974#else	/* !illumos */
2975	assert(!"invalid code path");
2976	return (EINVAL); // silence compiler warning
2977#endif	/* illumos */
2978}
2979
2980/*
2981 * convert the propname into parameters needed by kernel
2982 * Eg: userquota@ahrens -> ZFS_PROP_USERQUOTA, "", 126829
2983 * Eg: userused@matt@domain -> ZFS_PROP_USERUSED, "S-1-123-456", 789
2984 */
2985static int
2986userquota_propname_decode(const char *propname, boolean_t zoned,
2987    zfs_userquota_prop_t *typep, char *domain, int domainlen, uint64_t *ridp)
2988{
2989	zfs_userquota_prop_t type;
2990	char *cp, *end;
2991	char *numericsid = NULL;
2992	boolean_t isuser;
2993
2994	domain[0] = '\0';
2995	*ridp = 0;
2996	/* Figure out the property type ({user|group}{quota|space}) */
2997	for (type = 0; type < ZFS_NUM_USERQUOTA_PROPS; type++) {
2998		if (strncmp(propname, zfs_userquota_prop_prefixes[type],
2999		    strlen(zfs_userquota_prop_prefixes[type])) == 0)
3000			break;
3001	}
3002	if (type == ZFS_NUM_USERQUOTA_PROPS)
3003		return (EINVAL);
3004	*typep = type;
3005
3006	isuser = (type == ZFS_PROP_USERQUOTA ||
3007	    type == ZFS_PROP_USERUSED);
3008
3009	cp = strchr(propname, '@') + 1;
3010
3011	if (strchr(cp, '@')) {
3012#ifdef illumos
3013		/*
3014		 * It's a SID name (eg "user@domain") that needs to be
3015		 * turned into S-1-domainID-RID.
3016		 */
3017		int flag = 0;
3018		idmap_stat stat, map_stat;
3019		uid_t pid;
3020		idmap_rid_t rid;
3021		idmap_get_handle_t *gh = NULL;
3022
3023		stat = idmap_get_create(&gh);
3024		if (stat != IDMAP_SUCCESS) {
3025			idmap_get_destroy(gh);
3026			return (ENOMEM);
3027		}
3028		if (zoned && getzoneid() == GLOBAL_ZONEID)
3029			return (ENOENT);
3030		if (isuser) {
3031			stat = idmap_getuidbywinname(cp, NULL, flag, &pid);
3032			if (stat < 0)
3033				return (ENOENT);
3034			stat = idmap_get_sidbyuid(gh, pid, flag, &numericsid,
3035			    &rid, &map_stat);
3036		} else {
3037			stat = idmap_getgidbywinname(cp, NULL, flag, &pid);
3038			if (stat < 0)
3039				return (ENOENT);
3040			stat = idmap_get_sidbygid(gh, pid, flag, &numericsid,
3041			    &rid, &map_stat);
3042		}
3043		if (stat < 0) {
3044			idmap_get_destroy(gh);
3045			return (ENOENT);
3046		}
3047		stat = idmap_get_mappings(gh);
3048		idmap_get_destroy(gh);
3049
3050		if (stat < 0) {
3051			return (ENOENT);
3052		}
3053		if (numericsid == NULL)
3054			return (ENOENT);
3055		cp = numericsid;
3056		*ridp = rid;
3057		/* will be further decoded below */
3058#else	/* !illumos */
3059		return (ENOENT);
3060#endif	/* illumos */
3061	}
3062
3063	if (strncmp(cp, "S-1-", 4) == 0) {
3064		/* It's a numeric SID (eg "S-1-234-567-89") */
3065		(void) strlcpy(domain, cp, domainlen);
3066		errno = 0;
3067		if (*ridp == 0) {
3068			cp = strrchr(domain, '-');
3069			*cp = '\0';
3070			cp++;
3071			*ridp = strtoull(cp, &end, 10);
3072		} else {
3073			end = "";
3074		}
3075		if (numericsid) {
3076			free(numericsid);
3077			numericsid = NULL;
3078		}
3079		if (errno != 0 || *end != '\0')
3080			return (EINVAL);
3081	} else if (!isdigit(*cp)) {
3082		/*
3083		 * It's a user/group name (eg "user") that needs to be
3084		 * turned into a uid/gid
3085		 */
3086		if (zoned && getzoneid() == GLOBAL_ZONEID)
3087			return (ENOENT);
3088		if (isuser) {
3089			struct passwd *pw;
3090			pw = getpwnam(cp);
3091			if (pw == NULL)
3092				return (ENOENT);
3093			*ridp = pw->pw_uid;
3094		} else {
3095			struct group *gr;
3096			gr = getgrnam(cp);
3097			if (gr == NULL)
3098				return (ENOENT);
3099			*ridp = gr->gr_gid;
3100		}
3101	} else {
3102		/* It's a user/group ID (eg "12345"). */
3103		uid_t id = strtoul(cp, &end, 10);
3104		idmap_rid_t rid;
3105		char *mapdomain;
3106
3107		if (*end != '\0')
3108			return (EINVAL);
3109		if (id > MAXUID) {
3110			/* It's an ephemeral ID. */
3111			if (idmap_id_to_numeric_domain_rid(id, isuser,
3112			    &mapdomain, &rid) != 0)
3113				return (ENOENT);
3114			(void) strlcpy(domain, mapdomain, domainlen);
3115			*ridp = rid;
3116		} else {
3117			*ridp = id;
3118		}
3119	}
3120
3121	ASSERT3P(numericsid, ==, NULL);
3122	return (0);
3123}
3124
3125static int
3126zfs_prop_get_userquota_common(zfs_handle_t *zhp, const char *propname,
3127    uint64_t *propvalue, zfs_userquota_prop_t *typep)
3128{
3129	int err;
3130	zfs_cmd_t zc = { 0 };
3131
3132	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
3133
3134	err = userquota_propname_decode(propname,
3135	    zfs_prop_get_int(zhp, ZFS_PROP_ZONED),
3136	    typep, zc.zc_value, sizeof (zc.zc_value), &zc.zc_guid);
3137	zc.zc_objset_type = *typep;
3138	if (err)
3139		return (err);
3140
3141	err = ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_USERSPACE_ONE, &zc);
3142	if (err)
3143		return (err);
3144
3145	*propvalue = zc.zc_cookie;
3146	return (0);
3147}
3148
3149int
3150zfs_prop_get_userquota_int(zfs_handle_t *zhp, const char *propname,
3151    uint64_t *propvalue)
3152{
3153	zfs_userquota_prop_t type;
3154
3155	return (zfs_prop_get_userquota_common(zhp, propname, propvalue,
3156	    &type));
3157}
3158
3159int
3160zfs_prop_get_userquota(zfs_handle_t *zhp, const char *propname,
3161    char *propbuf, int proplen, boolean_t literal)
3162{
3163	int err;
3164	uint64_t propvalue;
3165	zfs_userquota_prop_t type;
3166
3167	err = zfs_prop_get_userquota_common(zhp, propname, &propvalue,
3168	    &type);
3169
3170	if (err)
3171		return (err);
3172
3173	if (literal) {
3174		(void) snprintf(propbuf, proplen, "%llu", propvalue);
3175	} else if (propvalue == 0 &&
3176	    (type == ZFS_PROP_USERQUOTA || type == ZFS_PROP_GROUPQUOTA)) {
3177		(void) strlcpy(propbuf, "none", proplen);
3178	} else {
3179		zfs_nicenum(propvalue, propbuf, proplen);
3180	}
3181	return (0);
3182}
3183
3184int
3185zfs_prop_get_written_int(zfs_handle_t *zhp, const char *propname,
3186    uint64_t *propvalue)
3187{
3188	int err;
3189	zfs_cmd_t zc = { 0 };
3190	const char *snapname;
3191
3192	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
3193
3194	snapname = strchr(propname, '@') + 1;
3195	if (strchr(snapname, '@')) {
3196		(void) strlcpy(zc.zc_value, snapname, sizeof (zc.zc_value));
3197	} else {
3198		/* snapname is the short name, append it to zhp's fsname */
3199		char *cp;
3200
3201		(void) strlcpy(zc.zc_value, zhp->zfs_name,
3202		    sizeof (zc.zc_value));
3203		cp = strchr(zc.zc_value, '@');
3204		if (cp != NULL)
3205			*cp = '\0';
3206		(void) strlcat(zc.zc_value, "@", sizeof (zc.zc_value));
3207		(void) strlcat(zc.zc_value, snapname, sizeof (zc.zc_value));
3208	}
3209
3210	err = ioctl(zhp->zfs_hdl->libzfs_fd, ZFS_IOC_SPACE_WRITTEN, &zc);
3211	if (err)
3212		return (err);
3213
3214	*propvalue = zc.zc_cookie;
3215	return (0);
3216}
3217
3218int
3219zfs_prop_get_written(zfs_handle_t *zhp, const char *propname,
3220    char *propbuf, int proplen, boolean_t literal)
3221{
3222	int err;
3223	uint64_t propvalue;
3224
3225	err = zfs_prop_get_written_int(zhp, propname, &propvalue);
3226
3227	if (err)
3228		return (err);
3229
3230	if (literal) {
3231		(void) snprintf(propbuf, proplen, "%llu", propvalue);
3232	} else {
3233		zfs_nicenum(propvalue, propbuf, proplen);
3234	}
3235	return (0);
3236}
3237
3238/*
3239 * Returns the name of the given zfs handle.
3240 */
3241const char *
3242zfs_get_name(const zfs_handle_t *zhp)
3243{
3244	return (zhp->zfs_name);
3245}
3246
3247/*
3248 * Returns the name of the parent pool for the given zfs handle.
3249 */
3250const char *
3251zfs_get_pool_name(const zfs_handle_t *zhp)
3252{
3253	return (zhp->zpool_hdl->zpool_name);
3254}
3255
3256/*
3257 * Returns the type of the given zfs handle.
3258 */
3259zfs_type_t
3260zfs_get_type(const zfs_handle_t *zhp)
3261{
3262	return (zhp->zfs_type);
3263}
3264
3265/*
3266 * Is one dataset name a child dataset of another?
3267 *
3268 * Needs to handle these cases:
3269 * Dataset 1	"a/foo"		"a/foo"		"a/foo"		"a/foo"
3270 * Dataset 2	"a/fo"		"a/foobar"	"a/bar/baz"	"a/foo/bar"
3271 * Descendant?	No.		No.		No.		Yes.
3272 */
3273static boolean_t
3274is_descendant(const char *ds1, const char *ds2)
3275{
3276	size_t d1len = strlen(ds1);
3277
3278	/* ds2 can't be a descendant if it's smaller */
3279	if (strlen(ds2) < d1len)
3280		return (B_FALSE);
3281
3282	/* otherwise, compare strings and verify that there's a '/' char */
3283	return (ds2[d1len] == '/' && (strncmp(ds1, ds2, d1len) == 0));
3284}
3285
3286/*
3287 * Given a complete name, return just the portion that refers to the parent.
3288 * Will return -1 if there is no parent (path is just the name of the
3289 * pool).
3290 */
3291static int
3292parent_name(const char *path, char *buf, size_t buflen)
3293{
3294	char *slashp;
3295
3296	(void) strlcpy(buf, path, buflen);
3297
3298	if ((slashp = strrchr(buf, '/')) == NULL)
3299		return (-1);
3300	*slashp = '\0';
3301
3302	return (0);
3303}
3304
3305/*
3306 * If accept_ancestor is false, then check to make sure that the given path has
3307 * a parent, and that it exists.  If accept_ancestor is true, then find the
3308 * closest existing ancestor for the given path.  In prefixlen return the
3309 * length of already existing prefix of the given path.  We also fetch the
3310 * 'zoned' property, which is used to validate property settings when creating
3311 * new datasets.
3312 */
3313static int
3314check_parents(libzfs_handle_t *hdl, const char *path, uint64_t *zoned,
3315    boolean_t accept_ancestor, int *prefixlen)
3316{
3317	zfs_cmd_t zc = { 0 };
3318	char parent[ZFS_MAX_DATASET_NAME_LEN];
3319	char *slash;
3320	zfs_handle_t *zhp;
3321	char errbuf[1024];
3322	uint64_t is_zoned;
3323
3324	(void) snprintf(errbuf, sizeof (errbuf),
3325	    dgettext(TEXT_DOMAIN, "cannot create '%s'"), path);
3326
3327	/* get parent, and check to see if this is just a pool */
3328	if (parent_name(path, parent, sizeof (parent)) != 0) {
3329		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3330		    "missing dataset name"));
3331		return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
3332	}
3333
3334	/* check to see if the pool exists */
3335	if ((slash = strchr(parent, '/')) == NULL)
3336		slash = parent + strlen(parent);
3337	(void) strncpy(zc.zc_name, parent, slash - parent);
3338	zc.zc_name[slash - parent] = '\0';
3339	if (ioctl(hdl->libzfs_fd, ZFS_IOC_OBJSET_STATS, &zc) != 0 &&
3340	    errno == ENOENT) {
3341		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3342		    "no such pool '%s'"), zc.zc_name);
3343		return (zfs_error(hdl, EZFS_NOENT, errbuf));
3344	}
3345
3346	/* check to see if the parent dataset exists */
3347	while ((zhp = make_dataset_handle(hdl, parent)) == NULL) {
3348		if (errno == ENOENT && accept_ancestor) {
3349			/*
3350			 * Go deeper to find an ancestor, give up on top level.
3351			 */
3352			if (parent_name(parent, parent, sizeof (parent)) != 0) {
3353				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3354				    "no such pool '%s'"), zc.zc_name);
3355				return (zfs_error(hdl, EZFS_NOENT, errbuf));
3356			}
3357		} else if (errno == ENOENT) {
3358			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3359			    "parent does not exist"));
3360			return (zfs_error(hdl, EZFS_NOENT, errbuf));
3361		} else
3362			return (zfs_standard_error(hdl, errno, errbuf));
3363	}
3364
3365	is_zoned = zfs_prop_get_int(zhp, ZFS_PROP_ZONED);
3366	if (zoned != NULL)
3367		*zoned = is_zoned;
3368
3369	/* we are in a non-global zone, but parent is in the global zone */
3370	if (getzoneid() != GLOBAL_ZONEID && !is_zoned) {
3371		(void) zfs_standard_error(hdl, EPERM, errbuf);
3372		zfs_close(zhp);
3373		return (-1);
3374	}
3375
3376	/* make sure parent is a filesystem */
3377	if (zfs_get_type(zhp) != ZFS_TYPE_FILESYSTEM) {
3378		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3379		    "parent is not a filesystem"));
3380		(void) zfs_error(hdl, EZFS_BADTYPE, errbuf);
3381		zfs_close(zhp);
3382		return (-1);
3383	}
3384
3385	zfs_close(zhp);
3386	if (prefixlen != NULL)
3387		*prefixlen = strlen(parent);
3388	return (0);
3389}
3390
3391/*
3392 * Finds whether the dataset of the given type(s) exists.
3393 */
3394boolean_t
3395zfs_dataset_exists(libzfs_handle_t *hdl, const char *path, zfs_type_t types)
3396{
3397	zfs_handle_t *zhp;
3398
3399	if (!zfs_validate_name(hdl, path, types, B_FALSE))
3400		return (B_FALSE);
3401
3402	/*
3403	 * Try to get stats for the dataset, which will tell us if it exists.
3404	 */
3405	if ((zhp = make_dataset_handle(hdl, path)) != NULL) {
3406		int ds_type = zhp->zfs_type;
3407
3408		zfs_close(zhp);
3409		if (types & ds_type)
3410			return (B_TRUE);
3411	}
3412	return (B_FALSE);
3413}
3414
3415/*
3416 * Given a path to 'target', create all the ancestors between
3417 * the prefixlen portion of the path, and the target itself.
3418 * Fail if the initial prefixlen-ancestor does not already exist.
3419 */
3420int
3421create_parents(libzfs_handle_t *hdl, char *target, int prefixlen)
3422{
3423	zfs_handle_t *h;
3424	char *cp;
3425	const char *opname;
3426
3427	/* make sure prefix exists */
3428	cp = target + prefixlen;
3429	if (*cp != '/') {
3430		assert(strchr(cp, '/') == NULL);
3431		h = zfs_open(hdl, target, ZFS_TYPE_FILESYSTEM);
3432	} else {
3433		*cp = '\0';
3434		h = zfs_open(hdl, target, ZFS_TYPE_FILESYSTEM);
3435		*cp = '/';
3436	}
3437	if (h == NULL)
3438		return (-1);
3439	zfs_close(h);
3440
3441	/*
3442	 * Attempt to create, mount, and share any ancestor filesystems,
3443	 * up to the prefixlen-long one.
3444	 */
3445	for (cp = target + prefixlen + 1;
3446	    (cp = strchr(cp, '/')) != NULL; *cp = '/', cp++) {
3447
3448		*cp = '\0';
3449
3450		h = make_dataset_handle(hdl, target);
3451		if (h) {
3452			/* it already exists, nothing to do here */
3453			zfs_close(h);
3454			continue;
3455		}
3456
3457		if (zfs_create(hdl, target, ZFS_TYPE_FILESYSTEM,
3458		    NULL) != 0) {
3459			opname = dgettext(TEXT_DOMAIN, "create");
3460			goto ancestorerr;
3461		}
3462
3463		h = zfs_open(hdl, target, ZFS_TYPE_FILESYSTEM);
3464		if (h == NULL) {
3465			opname = dgettext(TEXT_DOMAIN, "open");
3466			goto ancestorerr;
3467		}
3468
3469		if (zfs_mount(h, NULL, 0) != 0) {
3470			opname = dgettext(TEXT_DOMAIN, "mount");
3471			goto ancestorerr;
3472		}
3473
3474		if (zfs_share(h) != 0) {
3475			opname = dgettext(TEXT_DOMAIN, "share");
3476			goto ancestorerr;
3477		}
3478
3479		zfs_close(h);
3480	}
3481
3482	return (0);
3483
3484ancestorerr:
3485	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3486	    "failed to %s ancestor '%s'"), opname, target);
3487	return (-1);
3488}
3489
3490/*
3491 * Creates non-existing ancestors of the given path.
3492 */
3493int
3494zfs_create_ancestors(libzfs_handle_t *hdl, const char *path)
3495{
3496	int prefix;
3497	char *path_copy;
3498	char errbuf[1024];
3499	int rc = 0;
3500
3501	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
3502	    "cannot create '%s'"), path);
3503
3504	/*
3505	 * Check that we are not passing the nesting limit
3506	 * before we start creating any ancestors.
3507	 */
3508	if (dataset_nestcheck(path) != 0) {
3509		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3510		    "maximum name nesting depth exceeded"));
3511		return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
3512	}
3513
3514	if (check_parents(hdl, path, NULL, B_TRUE, &prefix) != 0)
3515		return (-1);
3516
3517	if ((path_copy = strdup(path)) != NULL) {
3518		rc = create_parents(hdl, path_copy, prefix);
3519		free(path_copy);
3520	}
3521	if (path_copy == NULL || rc != 0)
3522		return (-1);
3523
3524	return (0);
3525}
3526
3527/*
3528 * Create a new filesystem or volume.
3529 */
3530int
3531zfs_create(libzfs_handle_t *hdl, const char *path, zfs_type_t type,
3532    nvlist_t *props)
3533{
3534	int ret;
3535	uint64_t size = 0;
3536	uint64_t blocksize = zfs_prop_default_numeric(ZFS_PROP_VOLBLOCKSIZE);
3537	char errbuf[1024];
3538	uint64_t zoned;
3539	enum lzc_dataset_type ost;
3540	zpool_handle_t *zpool_handle;
3541
3542	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
3543	    "cannot create '%s'"), path);
3544
3545	/* validate the path, taking care to note the extended error message */
3546	if (!zfs_validate_name(hdl, path, type, B_TRUE))
3547		return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
3548
3549	if (dataset_nestcheck(path) != 0) {
3550		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3551		    "maximum name nesting depth exceeded"));
3552		return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
3553	}
3554
3555	/* validate parents exist */
3556	if (check_parents(hdl, path, &zoned, B_FALSE, NULL) != 0)
3557		return (-1);
3558
3559	/*
3560	 * The failure modes when creating a dataset of a different type over
3561	 * one that already exists is a little strange.  In particular, if you
3562	 * try to create a dataset on top of an existing dataset, the ioctl()
3563	 * will return ENOENT, not EEXIST.  To prevent this from happening, we
3564	 * first try to see if the dataset exists.
3565	 */
3566	if (zfs_dataset_exists(hdl, path, ZFS_TYPE_DATASET)) {
3567		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3568		    "dataset already exists"));
3569		return (zfs_error(hdl, EZFS_EXISTS, errbuf));
3570	}
3571
3572	if (type == ZFS_TYPE_VOLUME)
3573		ost = LZC_DATSET_TYPE_ZVOL;
3574	else
3575		ost = LZC_DATSET_TYPE_ZFS;
3576
3577	/* open zpool handle for prop validation */
3578	char pool_path[ZFS_MAX_DATASET_NAME_LEN];
3579	(void) strlcpy(pool_path, path, sizeof (pool_path));
3580
3581	/* truncate pool_path at first slash */
3582	char *p = strchr(pool_path, '/');
3583	if (p != NULL)
3584		*p = '\0';
3585
3586	if ((zpool_handle = zpool_open(hdl, pool_path)) == NULL)
3587		return (-1);
3588
3589	if (props && (props = zfs_valid_proplist(hdl, type, props,
3590	    zoned, NULL, zpool_handle, errbuf)) == 0) {
3591		zpool_close(zpool_handle);
3592		return (-1);
3593	}
3594	zpool_close(zpool_handle);
3595
3596	if (type == ZFS_TYPE_VOLUME) {
3597		/*
3598		 * If we are creating a volume, the size and block size must
3599		 * satisfy a few restraints.  First, the blocksize must be a
3600		 * valid block size between SPA_{MIN,MAX}BLOCKSIZE.  Second, the
3601		 * volsize must be a multiple of the block size, and cannot be
3602		 * zero.
3603		 */
3604		if (props == NULL || nvlist_lookup_uint64(props,
3605		    zfs_prop_to_name(ZFS_PROP_VOLSIZE), &size) != 0) {
3606			nvlist_free(props);
3607			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3608			    "missing volume size"));
3609			return (zfs_error(hdl, EZFS_BADPROP, errbuf));
3610		}
3611
3612		if ((ret = nvlist_lookup_uint64(props,
3613		    zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE),
3614		    &blocksize)) != 0) {
3615			if (ret == ENOENT) {
3616				blocksize = zfs_prop_default_numeric(
3617				    ZFS_PROP_VOLBLOCKSIZE);
3618			} else {
3619				nvlist_free(props);
3620				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3621				    "missing volume block size"));
3622				return (zfs_error(hdl, EZFS_BADPROP, errbuf));
3623			}
3624		}
3625
3626		if (size == 0) {
3627			nvlist_free(props);
3628			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3629			    "volume size cannot be zero"));
3630			return (zfs_error(hdl, EZFS_BADPROP, errbuf));
3631		}
3632
3633		if (size % blocksize != 0) {
3634			nvlist_free(props);
3635			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3636			    "volume size must be a multiple of volume block "
3637			    "size"));
3638			return (zfs_error(hdl, EZFS_BADPROP, errbuf));
3639		}
3640	}
3641
3642	/* create the dataset */
3643	ret = lzc_create(path, ost, props);
3644	nvlist_free(props);
3645
3646	/* check for failure */
3647	if (ret != 0) {
3648		char parent[ZFS_MAX_DATASET_NAME_LEN];
3649		(void) parent_name(path, parent, sizeof (parent));
3650
3651		switch (errno) {
3652		case ENOENT:
3653			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3654			    "no such parent '%s'"), parent);
3655			return (zfs_error(hdl, EZFS_NOENT, errbuf));
3656
3657		case ENOTSUP:
3658			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3659			    "pool must be upgraded to set this "
3660			    "property or value"));
3661			return (zfs_error(hdl, EZFS_BADVERSION, errbuf));
3662		case ERANGE:
3663			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3664			    "invalid property value(s) specified"));
3665			return (zfs_error(hdl, EZFS_BADPROP, errbuf));
3666#ifdef _ILP32
3667		case EOVERFLOW:
3668			/*
3669			 * This platform can't address a volume this big.
3670			 */
3671			if (type == ZFS_TYPE_VOLUME)
3672				return (zfs_error(hdl, EZFS_VOLTOOBIG,
3673				    errbuf));
3674#endif
3675			/* FALLTHROUGH */
3676		default:
3677			return (zfs_standard_error(hdl, errno, errbuf));
3678		}
3679	}
3680
3681	return (0);
3682}
3683
3684/*
3685 * Destroys the given dataset.  The caller must make sure that the filesystem
3686 * isn't mounted, and that there are no active dependents. If the file system
3687 * does not exist this function does nothing.
3688 */
3689int
3690zfs_destroy(zfs_handle_t *zhp, boolean_t defer)
3691{
3692	int error;
3693
3694	if (zhp->zfs_type != ZFS_TYPE_SNAPSHOT && defer)
3695		return (EINVAL);
3696
3697	if (zhp->zfs_type == ZFS_TYPE_BOOKMARK) {
3698		nvlist_t *nv = fnvlist_alloc();
3699		fnvlist_add_boolean(nv, zhp->zfs_name);
3700		error = lzc_destroy_bookmarks(nv, NULL);
3701		fnvlist_free(nv);
3702		if (error != 0) {
3703			return (zfs_standard_error_fmt(zhp->zfs_hdl, error,
3704			    dgettext(TEXT_DOMAIN, "cannot destroy '%s'"),
3705			    zhp->zfs_name));
3706		}
3707		return (0);
3708	}
3709
3710	if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT) {
3711		nvlist_t *nv = fnvlist_alloc();
3712		fnvlist_add_boolean(nv, zhp->zfs_name);
3713		error = lzc_destroy_snaps(nv, defer, NULL);
3714		fnvlist_free(nv);
3715	} else {
3716		error = lzc_destroy(zhp->zfs_name);
3717	}
3718
3719	if (error != 0 && error != ENOENT) {
3720		return (zfs_standard_error_fmt(zhp->zfs_hdl, errno,
3721		    dgettext(TEXT_DOMAIN, "cannot destroy '%s'"),
3722		    zhp->zfs_name));
3723	}
3724
3725	remove_mountpoint(zhp);
3726
3727	return (0);
3728}
3729
3730struct destroydata {
3731	nvlist_t *nvl;
3732	const char *snapname;
3733};
3734
3735static int
3736zfs_check_snap_cb(zfs_handle_t *zhp, void *arg)
3737{
3738	struct destroydata *dd = arg;
3739	char name[ZFS_MAX_DATASET_NAME_LEN];
3740	int rv = 0;
3741
3742	(void) snprintf(name, sizeof (name),
3743	    "%s@%s", zhp->zfs_name, dd->snapname);
3744
3745	if (lzc_exists(name))
3746		verify(nvlist_add_boolean(dd->nvl, name) == 0);
3747
3748	rv = zfs_iter_filesystems(zhp, zfs_check_snap_cb, dd);
3749	zfs_close(zhp);
3750	return (rv);
3751}
3752
3753/*
3754 * Destroys all snapshots with the given name in zhp & descendants.
3755 */
3756int
3757zfs_destroy_snaps(zfs_handle_t *zhp, char *snapname, boolean_t defer)
3758{
3759	int ret;
3760	struct destroydata dd = { 0 };
3761
3762	dd.snapname = snapname;
3763	verify(nvlist_alloc(&dd.nvl, NV_UNIQUE_NAME, 0) == 0);
3764	(void) zfs_check_snap_cb(zfs_handle_dup(zhp), &dd);
3765
3766	if (nvlist_empty(dd.nvl)) {
3767		ret = zfs_standard_error_fmt(zhp->zfs_hdl, ENOENT,
3768		    dgettext(TEXT_DOMAIN, "cannot destroy '%s@%s'"),
3769		    zhp->zfs_name, snapname);
3770	} else {
3771		ret = zfs_destroy_snaps_nvl(zhp->zfs_hdl, dd.nvl, defer);
3772	}
3773	nvlist_free(dd.nvl);
3774	return (ret);
3775}
3776
3777/*
3778 * Destroys all the snapshots named in the nvlist.
3779 */
3780int
3781zfs_destroy_snaps_nvl(libzfs_handle_t *hdl, nvlist_t *snaps, boolean_t defer)
3782{
3783	int ret;
3784	nvlist_t *errlist = NULL;
3785
3786	ret = lzc_destroy_snaps(snaps, defer, &errlist);
3787
3788	if (ret == 0) {
3789		nvlist_free(errlist);
3790		return (0);
3791	}
3792
3793	if (nvlist_empty(errlist)) {
3794		char errbuf[1024];
3795		(void) snprintf(errbuf, sizeof (errbuf),
3796		    dgettext(TEXT_DOMAIN, "cannot destroy snapshots"));
3797
3798		ret = zfs_standard_error(hdl, ret, errbuf);
3799	}
3800	for (nvpair_t *pair = nvlist_next_nvpair(errlist, NULL);
3801	    pair != NULL; pair = nvlist_next_nvpair(errlist, pair)) {
3802		char errbuf[1024];
3803		(void) snprintf(errbuf, sizeof (errbuf),
3804		    dgettext(TEXT_DOMAIN, "cannot destroy snapshot %s"),
3805		    nvpair_name(pair));
3806
3807		switch (fnvpair_value_int32(pair)) {
3808		case EEXIST:
3809			zfs_error_aux(hdl,
3810			    dgettext(TEXT_DOMAIN, "snapshot is cloned"));
3811			ret = zfs_error(hdl, EZFS_EXISTS, errbuf);
3812			break;
3813		default:
3814			ret = zfs_standard_error(hdl, errno, errbuf);
3815			break;
3816		}
3817	}
3818
3819	nvlist_free(errlist);
3820	return (ret);
3821}
3822
3823/*
3824 * Clones the given dataset.  The target must be of the same type as the source.
3825 */
3826int
3827zfs_clone(zfs_handle_t *zhp, const char *target, nvlist_t *props)
3828{
3829	char parent[ZFS_MAX_DATASET_NAME_LEN];
3830	int ret;
3831	char errbuf[1024];
3832	libzfs_handle_t *hdl = zhp->zfs_hdl;
3833	uint64_t zoned;
3834
3835	assert(zhp->zfs_type == ZFS_TYPE_SNAPSHOT);
3836
3837	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
3838	    "cannot create '%s'"), target);
3839
3840	/* validate the target/clone name */
3841	if (!zfs_validate_name(hdl, target, ZFS_TYPE_FILESYSTEM, B_TRUE))
3842		return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
3843
3844	/* validate parents exist */
3845	if (check_parents(hdl, target, &zoned, B_FALSE, NULL) != 0)
3846		return (-1);
3847
3848	(void) parent_name(target, parent, sizeof (parent));
3849
3850	/* do the clone */
3851
3852	if (props) {
3853		zfs_type_t type;
3854
3855		if (ZFS_IS_VOLUME(zhp)) {
3856			type = ZFS_TYPE_VOLUME;
3857		} else {
3858			type = ZFS_TYPE_FILESYSTEM;
3859		}
3860		if ((props = zfs_valid_proplist(hdl, type, props, zoned,
3861		    zhp, zhp->zpool_hdl, errbuf)) == NULL)
3862			return (-1);
3863		if (zfs_fix_auto_resv(zhp, props) == -1) {
3864			nvlist_free(props);
3865			return (-1);
3866		}
3867	}
3868
3869	ret = lzc_clone(target, zhp->zfs_name, props);
3870	nvlist_free(props);
3871
3872	if (ret != 0) {
3873		switch (errno) {
3874
3875		case ENOENT:
3876			/*
3877			 * The parent doesn't exist.  We should have caught this
3878			 * above, but there may a race condition that has since
3879			 * destroyed the parent.
3880			 *
3881			 * At this point, we don't know whether it's the source
3882			 * that doesn't exist anymore, or whether the target
3883			 * dataset doesn't exist.
3884			 */
3885			zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
3886			    "no such parent '%s'"), parent);
3887			return (zfs_error(zhp->zfs_hdl, EZFS_NOENT, errbuf));
3888
3889		case EXDEV:
3890			zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
3891			    "source and target pools differ"));
3892			return (zfs_error(zhp->zfs_hdl, EZFS_CROSSTARGET,
3893			    errbuf));
3894
3895		default:
3896			return (zfs_standard_error(zhp->zfs_hdl, errno,
3897			    errbuf));
3898		}
3899	}
3900
3901	return (ret);
3902}
3903
3904/*
3905 * Promotes the given clone fs to be the clone parent.
3906 */
3907int
3908zfs_promote(zfs_handle_t *zhp)
3909{
3910	libzfs_handle_t *hdl = zhp->zfs_hdl;
3911	char snapname[ZFS_MAX_DATASET_NAME_LEN];
3912	int ret;
3913	char errbuf[1024];
3914
3915	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
3916	    "cannot promote '%s'"), zhp->zfs_name);
3917
3918	if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT) {
3919		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3920		    "snapshots can not be promoted"));
3921		return (zfs_error(hdl, EZFS_BADTYPE, errbuf));
3922	}
3923
3924	if (zhp->zfs_dmustats.dds_origin[0] == '\0') {
3925		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3926		    "not a cloned filesystem"));
3927		return (zfs_error(hdl, EZFS_BADTYPE, errbuf));
3928	}
3929
3930	if (!zfs_validate_name(hdl, zhp->zfs_name, zhp->zfs_type, B_TRUE))
3931		return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
3932
3933	ret = lzc_promote(zhp->zfs_name, snapname, sizeof (snapname));
3934
3935	if (ret != 0) {
3936		switch (ret) {
3937		case EEXIST:
3938			/* There is a conflicting snapshot name. */
3939			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3940			    "conflicting snapshot '%s' from parent '%s'"),
3941			    snapname, zhp->zfs_dmustats.dds_origin);
3942			return (zfs_error(hdl, EZFS_EXISTS, errbuf));
3943
3944		default:
3945			return (zfs_standard_error(hdl, ret, errbuf));
3946		}
3947	}
3948	return (ret);
3949}
3950
3951typedef struct snapdata {
3952	nvlist_t *sd_nvl;
3953	const char *sd_snapname;
3954} snapdata_t;
3955
3956static int
3957zfs_snapshot_cb(zfs_handle_t *zhp, void *arg)
3958{
3959	snapdata_t *sd = arg;
3960	char name[ZFS_MAX_DATASET_NAME_LEN];
3961	int rv = 0;
3962
3963	if (zfs_prop_get_int(zhp, ZFS_PROP_INCONSISTENT) == 0) {
3964		(void) snprintf(name, sizeof (name),
3965		    "%s@%s", zfs_get_name(zhp), sd->sd_snapname);
3966
3967		fnvlist_add_boolean(sd->sd_nvl, name);
3968
3969		rv = zfs_iter_filesystems(zhp, zfs_snapshot_cb, sd);
3970	}
3971	zfs_close(zhp);
3972
3973	return (rv);
3974}
3975
3976int
3977zfs_remap_indirects(libzfs_handle_t *hdl, const char *fs)
3978{
3979	int err;
3980	char errbuf[1024];
3981
3982	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
3983	    "cannot remap dataset '%s'"), fs);
3984
3985	err = lzc_remap(fs);
3986
3987	if (err != 0) {
3988		switch (err) {
3989		case ENOTSUP:
3990			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
3991			    "pool must be upgraded"));
3992			(void) zfs_error(hdl, EZFS_BADVERSION, errbuf);
3993			break;
3994		case EINVAL:
3995			(void) zfs_error(hdl, EZFS_BADTYPE, errbuf);
3996			break;
3997		default:
3998			(void) zfs_standard_error(hdl, err, errbuf);
3999			break;
4000		}
4001	}
4002
4003	return (err);
4004}
4005
4006/*
4007 * Creates snapshots.  The keys in the snaps nvlist are the snapshots to be
4008 * created.
4009 */
4010int
4011zfs_snapshot_nvl(libzfs_handle_t *hdl, nvlist_t *snaps, nvlist_t *props)
4012{
4013	int ret;
4014	char errbuf[1024];
4015	nvpair_t *elem;
4016	nvlist_t *errors;
4017
4018	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
4019	    "cannot create snapshots "));
4020
4021	elem = NULL;
4022	while ((elem = nvlist_next_nvpair(snaps, elem)) != NULL) {
4023		const char *snapname = nvpair_name(elem);
4024
4025		/* validate the target name */
4026		if (!zfs_validate_name(hdl, snapname, ZFS_TYPE_SNAPSHOT,
4027		    B_TRUE)) {
4028			(void) snprintf(errbuf, sizeof (errbuf),
4029			    dgettext(TEXT_DOMAIN,
4030			    "cannot create snapshot '%s'"), snapname);
4031			return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
4032		}
4033	}
4034
4035	/*
4036	 * get pool handle for prop validation. assumes all snaps are in the
4037	 * same pool, as does lzc_snapshot (below).
4038	 */
4039	char pool[ZFS_MAX_DATASET_NAME_LEN];
4040	elem = nvlist_next_nvpair(snaps, NULL);
4041	(void) strlcpy(pool, nvpair_name(elem), sizeof (pool));
4042	pool[strcspn(pool, "/@")] = '\0';
4043	zpool_handle_t *zpool_hdl = zpool_open(hdl, pool);
4044
4045	if (props != NULL &&
4046	    (props = zfs_valid_proplist(hdl, ZFS_TYPE_SNAPSHOT,
4047	    props, B_FALSE, NULL, zpool_hdl, errbuf)) == NULL) {
4048		zpool_close(zpool_hdl);
4049		return (-1);
4050	}
4051	zpool_close(zpool_hdl);
4052
4053	ret = lzc_snapshot(snaps, props, &errors);
4054
4055	if (ret != 0) {
4056		boolean_t printed = B_FALSE;
4057		for (elem = nvlist_next_nvpair(errors, NULL);
4058		    elem != NULL;
4059		    elem = nvlist_next_nvpair(errors, elem)) {
4060			(void) snprintf(errbuf, sizeof (errbuf),
4061			    dgettext(TEXT_DOMAIN,
4062			    "cannot create snapshot '%s'"), nvpair_name(elem));
4063			(void) zfs_standard_error(hdl,
4064			    fnvpair_value_int32(elem), errbuf);
4065			printed = B_TRUE;
4066		}
4067		if (!printed) {
4068			switch (ret) {
4069			case EXDEV:
4070				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
4071				    "multiple snapshots of same "
4072				    "fs not allowed"));
4073				(void) zfs_error(hdl, EZFS_EXISTS, errbuf);
4074
4075				break;
4076			default:
4077				(void) zfs_standard_error(hdl, ret, errbuf);
4078			}
4079		}
4080	}
4081
4082	nvlist_free(props);
4083	nvlist_free(errors);
4084	return (ret);
4085}
4086
4087int
4088zfs_snapshot(libzfs_handle_t *hdl, const char *path, boolean_t recursive,
4089    nvlist_t *props)
4090{
4091	int ret;
4092	snapdata_t sd = { 0 };
4093	char fsname[ZFS_MAX_DATASET_NAME_LEN];
4094	char *cp;
4095	zfs_handle_t *zhp;
4096	char errbuf[1024];
4097
4098	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
4099	    "cannot snapshot %s"), path);
4100
4101	if (!zfs_validate_name(hdl, path, ZFS_TYPE_SNAPSHOT, B_TRUE))
4102		return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
4103
4104	(void) strlcpy(fsname, path, sizeof (fsname));
4105	cp = strchr(fsname, '@');
4106	*cp = '\0';
4107	sd.sd_snapname = cp + 1;
4108
4109	if ((zhp = zfs_open(hdl, fsname, ZFS_TYPE_FILESYSTEM |
4110	    ZFS_TYPE_VOLUME)) == NULL) {
4111		return (-1);
4112	}
4113
4114	verify(nvlist_alloc(&sd.sd_nvl, NV_UNIQUE_NAME, 0) == 0);
4115	if (recursive) {
4116		(void) zfs_snapshot_cb(zfs_handle_dup(zhp), &sd);
4117	} else {
4118		fnvlist_add_boolean(sd.sd_nvl, path);
4119	}
4120
4121	ret = zfs_snapshot_nvl(hdl, sd.sd_nvl, props);
4122	nvlist_free(sd.sd_nvl);
4123	zfs_close(zhp);
4124	return (ret);
4125}
4126
4127/*
4128 * Destroy any more recent snapshots.  We invoke this callback on any dependents
4129 * of the snapshot first.  If the 'cb_dependent' member is non-zero, then this
4130 * is a dependent and we should just destroy it without checking the transaction
4131 * group.
4132 */
4133typedef struct rollback_data {
4134	const char	*cb_target;		/* the snapshot */
4135	uint64_t	cb_create;		/* creation time reference */
4136	boolean_t	cb_error;
4137	boolean_t	cb_force;
4138} rollback_data_t;
4139
4140static int
4141rollback_destroy_dependent(zfs_handle_t *zhp, void *data)
4142{
4143	rollback_data_t *cbp = data;
4144	prop_changelist_t *clp;
4145
4146	/* We must destroy this clone; first unmount it */
4147	clp = changelist_gather(zhp, ZFS_PROP_NAME, 0,
4148	    cbp->cb_force ? MS_FORCE: 0);
4149	if (clp == NULL || changelist_prefix(clp) != 0) {
4150		cbp->cb_error = B_TRUE;
4151		zfs_close(zhp);
4152		return (0);
4153	}
4154	if (zfs_destroy(zhp, B_FALSE) != 0)
4155		cbp->cb_error = B_TRUE;
4156	else
4157		changelist_remove(clp, zhp->zfs_name);
4158	(void) changelist_postfix(clp);
4159	changelist_free(clp);
4160
4161	zfs_close(zhp);
4162	return (0);
4163}
4164
4165static int
4166rollback_destroy(zfs_handle_t *zhp, void *data)
4167{
4168	rollback_data_t *cbp = data;
4169
4170	if (zfs_prop_get_int(zhp, ZFS_PROP_CREATETXG) > cbp->cb_create) {
4171		cbp->cb_error |= zfs_iter_dependents(zhp, B_FALSE,
4172		    rollback_destroy_dependent, cbp);
4173
4174		cbp->cb_error |= zfs_destroy(zhp, B_FALSE);
4175	}
4176
4177	zfs_close(zhp);
4178	return (0);
4179}
4180
4181/*
4182 * Given a dataset, rollback to a specific snapshot, discarding any
4183 * data changes since then and making it the active dataset.
4184 *
4185 * Any snapshots and bookmarks more recent than the target are
4186 * destroyed, along with their dependents (i.e. clones).
4187 */
4188int
4189zfs_rollback(zfs_handle_t *zhp, zfs_handle_t *snap, boolean_t force)
4190{
4191	rollback_data_t cb = { 0 };
4192	int err;
4193	boolean_t restore_resv = 0;
4194	uint64_t min_txg = 0, old_volsize = 0, new_volsize;
4195	zfs_prop_t resv_prop;
4196
4197	assert(zhp->zfs_type == ZFS_TYPE_FILESYSTEM ||
4198	    zhp->zfs_type == ZFS_TYPE_VOLUME);
4199
4200	/*
4201	 * Destroy all recent snapshots and their dependents.
4202	 */
4203	cb.cb_force = force;
4204	cb.cb_target = snap->zfs_name;
4205	cb.cb_create = zfs_prop_get_int(snap, ZFS_PROP_CREATETXG);
4206
4207	if (cb.cb_create > 0)
4208		min_txg = cb.cb_create;
4209
4210	(void) zfs_iter_snapshots(zhp, B_FALSE, rollback_destroy, &cb,
4211	    min_txg, 0);
4212
4213	(void) zfs_iter_bookmarks(zhp, rollback_destroy, &cb);
4214
4215	if (cb.cb_error)
4216		return (-1);
4217
4218	/*
4219	 * Now that we have verified that the snapshot is the latest,
4220	 * rollback to the given snapshot.
4221	 */
4222
4223	if (zhp->zfs_type == ZFS_TYPE_VOLUME) {
4224		if (zfs_which_resv_prop(zhp, &resv_prop) < 0)
4225			return (-1);
4226		old_volsize = zfs_prop_get_int(zhp, ZFS_PROP_VOLSIZE);
4227		restore_resv =
4228		    (old_volsize == zfs_prop_get_int(zhp, resv_prop));
4229	}
4230
4231	/*
4232	 * Pass both the filesystem and the wanted snapshot names,
4233	 * we would get an error back if the snapshot is destroyed or
4234	 * a new snapshot is created before this request is processed.
4235	 */
4236	err = lzc_rollback_to(zhp->zfs_name, snap->zfs_name);
4237	if (err != 0) {
4238		char errbuf[1024];
4239
4240		(void) snprintf(errbuf, sizeof (errbuf),
4241		    dgettext(TEXT_DOMAIN, "cannot rollback '%s'"),
4242		    zhp->zfs_name);
4243		switch (err) {
4244		case EEXIST:
4245			zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
4246			    "there is a snapshot or bookmark more recent "
4247			    "than '%s'"), snap->zfs_name);
4248			(void) zfs_error(zhp->zfs_hdl, EZFS_EXISTS, errbuf);
4249			break;
4250		case ESRCH:
4251			zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
4252			    "'%s' is not found among snapshots of '%s'"),
4253			    snap->zfs_name, zhp->zfs_name);
4254			(void) zfs_error(zhp->zfs_hdl, EZFS_NOENT, errbuf);
4255			break;
4256		case EINVAL:
4257			(void) zfs_error(zhp->zfs_hdl, EZFS_BADTYPE, errbuf);
4258			break;
4259		default:
4260			(void) zfs_standard_error(zhp->zfs_hdl, err, errbuf);
4261		}
4262		return (err);
4263	}
4264
4265	/*
4266	 * For volumes, if the pre-rollback volsize matched the pre-
4267	 * rollback reservation and the volsize has changed then set
4268	 * the reservation property to the post-rollback volsize.
4269	 * Make a new handle since the rollback closed the dataset.
4270	 */
4271	if ((zhp->zfs_type == ZFS_TYPE_VOLUME) &&
4272	    (zhp = make_dataset_handle(zhp->zfs_hdl, zhp->zfs_name))) {
4273		if (restore_resv) {
4274			new_volsize = zfs_prop_get_int(zhp, ZFS_PROP_VOLSIZE);
4275			if (old_volsize != new_volsize)
4276				err = zfs_prop_set_int(zhp, resv_prop,
4277				    new_volsize);
4278		}
4279		zfs_close(zhp);
4280	}
4281	return (err);
4282}
4283
4284/*
4285 * Renames the given dataset.
4286 */
4287int
4288zfs_rename(zfs_handle_t *zhp, const char *source, const char *target,
4289    renameflags_t flags)
4290{
4291	int ret = 0;
4292	zfs_cmd_t zc = { 0 };
4293	char *delim;
4294	prop_changelist_t *cl = NULL;
4295	zfs_handle_t *zhrp = NULL;
4296	char *parentname = NULL;
4297	char parent[ZFS_MAX_DATASET_NAME_LEN];
4298	char property[ZFS_MAXPROPLEN];
4299	libzfs_handle_t *hdl = zhp->zfs_hdl;
4300	char errbuf[1024];
4301
4302	/* if we have the same exact name, just return success */
4303	if (strcmp(zhp->zfs_name, target) == 0)
4304		return (0);
4305
4306	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
4307	    "cannot rename to '%s'"), target);
4308
4309	if (source != NULL) {
4310		/*
4311		 * This is recursive snapshots rename, put snapshot name
4312		 * (that might not exist) into zfs_name.
4313		 */
4314		assert(flags.recurse);
4315
4316		(void) strlcat(zhp->zfs_name, "@", sizeof(zhp->zfs_name));
4317		(void) strlcat(zhp->zfs_name, source, sizeof(zhp->zfs_name));
4318		zhp->zfs_type = ZFS_TYPE_SNAPSHOT;
4319	}
4320
4321	/* make sure source name is valid */
4322	if (!zfs_validate_name(hdl, zhp->zfs_name, zhp->zfs_type, B_TRUE))
4323		return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
4324
4325	/*
4326	 * Make sure the target name is valid
4327	 */
4328	if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT ||
4329	    zhp->zfs_type == ZFS_TYPE_BOOKMARK) {
4330		const char sep = zhp->zfs_type == ZFS_TYPE_SNAPSHOT ? '@' : '#';
4331
4332		if ((strchr(target, sep) == NULL) || *target == sep) {
4333			/*
4334			 * Snapshot target name is abbreviated,
4335			 * reconstruct full dataset name
4336			 */
4337			(void) strlcpy(parent, zhp->zfs_name, sizeof (parent));
4338			delim = strchr(parent, sep);
4339			if (strchr(target, sep) == NULL)
4340				*(++delim) = '\0';
4341			else
4342				*delim = '\0';
4343			(void) strlcat(parent, target, sizeof (parent));
4344			target = parent;
4345		} else {
4346			/*
4347			 * Make sure we're renaming within the same dataset.
4348			 */
4349			delim = strchr(target, sep);
4350			if (strncmp(zhp->zfs_name, target, delim - target)
4351			    != 0 || zhp->zfs_name[delim - target] != sep) {
4352				zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
4353				    "%s must be part of same dataset"),
4354				    zhp->zfs_type == ZFS_TYPE_SNAPSHOT ?
4355				    "snapshots" : "bookmarks");
4356				return (zfs_error(hdl, EZFS_CROSSTARGET,
4357				    errbuf));
4358			}
4359		}
4360
4361		if (!zfs_validate_name(hdl, target, zhp->zfs_type, B_TRUE))
4362			return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
4363	} else {
4364		if (flags.recurse) {
4365			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
4366			    "recursive rename must be a snapshot"));
4367			return (zfs_error(hdl, EZFS_BADTYPE, errbuf));
4368		}
4369
4370		if (!zfs_validate_name(hdl, target, zhp->zfs_type, B_TRUE))
4371			return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
4372
4373		/* validate parents */
4374		if (check_parents(hdl, target, NULL, B_FALSE, NULL) != 0)
4375			return (-1);
4376
4377		/* make sure we're in the same pool */
4378		verify((delim = strchr(target, '/')) != NULL);
4379		if (strncmp(zhp->zfs_name, target, delim - target) != 0 ||
4380		    zhp->zfs_name[delim - target] != '/') {
4381			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
4382			    "datasets must be within same pool"));
4383			return (zfs_error(hdl, EZFS_CROSSTARGET, errbuf));
4384		}
4385
4386		/* new name cannot be a child of the current dataset name */
4387		if (is_descendant(zhp->zfs_name, target)) {
4388			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
4389			    "New dataset name cannot be a descendant of "
4390			    "current dataset name"));
4391			return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
4392		}
4393	}
4394
4395	(void) snprintf(errbuf, sizeof (errbuf),
4396	    dgettext(TEXT_DOMAIN, "cannot rename '%s'"), zhp->zfs_name);
4397
4398	if (getzoneid() == GLOBAL_ZONEID &&
4399	    zfs_prop_get_int(zhp, ZFS_PROP_ZONED)) {
4400		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
4401		    "dataset is used in a non-global zone"));
4402		return (zfs_error(hdl, EZFS_ZONED, errbuf));
4403	}
4404
4405	/*
4406	 * Avoid unmounting file systems with mountpoint property set to
4407	 * 'legacy' or 'none' even if -u option is not given.
4408	 */
4409	if (zhp->zfs_type == ZFS_TYPE_FILESYSTEM &&
4410	    !flags.recurse && !flags.nounmount &&
4411	    zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, property,
4412	    sizeof (property), NULL, NULL, 0, B_FALSE) == 0 &&
4413	    (strcmp(property, "legacy") == 0 ||
4414	     strcmp(property, "none") == 0)) {
4415		flags.nounmount = B_TRUE;
4416	}
4417	if (flags.recurse) {
4418		parentname = zfs_strdup(zhp->zfs_hdl, zhp->zfs_name);
4419		if (parentname == NULL) {
4420			ret = -1;
4421			goto error;
4422		}
4423		delim = strchr(parentname, '@');
4424		*delim = '\0';
4425		zhrp = zfs_open(zhp->zfs_hdl, parentname, ZFS_TYPE_DATASET);
4426		if (zhrp == NULL) {
4427			ret = -1;
4428			goto error;
4429		}
4430	} else if (zhp->zfs_type != ZFS_TYPE_SNAPSHOT &&
4431	    zhp->zfs_type != ZFS_TYPE_BOOKMARK) {
4432		if ((cl = changelist_gather(zhp, ZFS_PROP_NAME,
4433		    flags.nounmount ? CL_GATHER_DONT_UNMOUNT : 0,
4434		    flags.forceunmount ? MS_FORCE : 0)) == NULL) {
4435			return (-1);
4436		}
4437
4438		if (changelist_haszonedchild(cl)) {
4439			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
4440			    "child dataset with inherited mountpoint is used "
4441			    "in a non-global zone"));
4442			(void) zfs_error(hdl, EZFS_ZONED, errbuf);
4443			ret = -1;
4444			goto error;
4445		}
4446
4447		if ((ret = changelist_prefix(cl)) != 0)
4448			goto error;
4449	}
4450
4451	if (ZFS_IS_VOLUME(zhp))
4452		zc.zc_objset_type = DMU_OST_ZVOL;
4453	else
4454		zc.zc_objset_type = DMU_OST_ZFS;
4455
4456	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
4457	(void) strlcpy(zc.zc_value, target, sizeof (zc.zc_value));
4458
4459	zc.zc_cookie = flags.recurse ? 1 : 0;
4460	if (flags.nounmount)
4461		zc.zc_cookie |= 2;
4462
4463	if ((ret = zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_RENAME, &zc)) != 0) {
4464		/*
4465		 * if it was recursive, the one that actually failed will
4466		 * be in zc.zc_name
4467		 */
4468		(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
4469		    "cannot rename '%s'"), zc.zc_name);
4470
4471		if (flags.recurse && errno == EEXIST) {
4472			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
4473			    "a child dataset already has a snapshot "
4474			    "with the new name"));
4475			(void) zfs_error(hdl, EZFS_EXISTS, errbuf);
4476		} else if (errno == EINVAL) {
4477			(void) zfs_error(hdl, EZFS_INVALIDNAME, errbuf);
4478		} else {
4479			(void) zfs_standard_error(zhp->zfs_hdl, errno, errbuf);
4480		}
4481
4482		/*
4483		 * On failure, we still want to remount any filesystems that
4484		 * were previously mounted, so we don't alter the system state.
4485		 */
4486		if (cl != NULL)
4487			(void) changelist_postfix(cl);
4488	} else {
4489		if (cl != NULL) {
4490			changelist_rename(cl, zfs_get_name(zhp), target);
4491			ret = changelist_postfix(cl);
4492		}
4493	}
4494
4495error:
4496	if (parentname != NULL) {
4497		free(parentname);
4498	}
4499	if (zhrp != NULL) {
4500		zfs_close(zhrp);
4501	}
4502	if (cl != NULL) {
4503		changelist_free(cl);
4504	}
4505	return (ret);
4506}
4507
4508nvlist_t *
4509zfs_get_user_props(zfs_handle_t *zhp)
4510{
4511	return (zhp->zfs_user_props);
4512}
4513
4514nvlist_t *
4515zfs_get_recvd_props(zfs_handle_t *zhp)
4516{
4517	if (zhp->zfs_recvd_props == NULL)
4518		if (get_recvd_props_ioctl(zhp) != 0)
4519			return (NULL);
4520	return (zhp->zfs_recvd_props);
4521}
4522
4523/*
4524 * This function is used by 'zfs list' to determine the exact set of columns to
4525 * display, and their maximum widths.  This does two main things:
4526 *
4527 *      - If this is a list of all properties, then expand the list to include
4528 *        all native properties, and set a flag so that for each dataset we look
4529 *        for new unique user properties and add them to the list.
4530 *
4531 *      - For non fixed-width properties, keep track of the maximum width seen
4532 *        so that we can size the column appropriately. If the user has
4533 *        requested received property values, we also need to compute the width
4534 *        of the RECEIVED column.
4535 */
4536int
4537zfs_expand_proplist(zfs_handle_t *zhp, zprop_list_t **plp, boolean_t received,
4538    boolean_t literal)
4539{
4540	libzfs_handle_t *hdl = zhp->zfs_hdl;
4541	zprop_list_t *entry;
4542	zprop_list_t **last, **start;
4543	nvlist_t *userprops, *propval;
4544	nvpair_t *elem;
4545	char *strval;
4546	char buf[ZFS_MAXPROPLEN];
4547
4548	if (zprop_expand_list(hdl, plp, ZFS_TYPE_DATASET) != 0)
4549		return (-1);
4550
4551	userprops = zfs_get_user_props(zhp);
4552
4553	entry = *plp;
4554	if (entry->pl_all && nvlist_next_nvpair(userprops, NULL) != NULL) {
4555		/*
4556		 * Go through and add any user properties as necessary.  We
4557		 * start by incrementing our list pointer to the first
4558		 * non-native property.
4559		 */
4560		start = plp;
4561		while (*start != NULL) {
4562			if ((*start)->pl_prop == ZPROP_INVAL)
4563				break;
4564			start = &(*start)->pl_next;
4565		}
4566
4567		elem = NULL;
4568		while ((elem = nvlist_next_nvpair(userprops, elem)) != NULL) {
4569			/*
4570			 * See if we've already found this property in our list.
4571			 */
4572			for (last = start; *last != NULL;
4573			    last = &(*last)->pl_next) {
4574				if (strcmp((*last)->pl_user_prop,
4575				    nvpair_name(elem)) == 0)
4576					break;
4577			}
4578
4579			if (*last == NULL) {
4580				if ((entry = zfs_alloc(hdl,
4581				    sizeof (zprop_list_t))) == NULL ||
4582				    ((entry->pl_user_prop = zfs_strdup(hdl,
4583				    nvpair_name(elem)))) == NULL) {
4584					free(entry);
4585					return (-1);
4586				}
4587
4588				entry->pl_prop = ZPROP_INVAL;
4589				entry->pl_width = strlen(nvpair_name(elem));
4590				entry->pl_all = B_TRUE;
4591				*last = entry;
4592			}
4593		}
4594	}
4595
4596	/*
4597	 * Now go through and check the width of any non-fixed columns
4598	 */
4599	for (entry = *plp; entry != NULL; entry = entry->pl_next) {
4600		if (entry->pl_fixed && !literal)
4601			continue;
4602
4603		if (entry->pl_prop != ZPROP_INVAL) {
4604			if (zfs_prop_get(zhp, entry->pl_prop,
4605			    buf, sizeof (buf), NULL, NULL, 0, literal) == 0) {
4606				if (strlen(buf) > entry->pl_width)
4607					entry->pl_width = strlen(buf);
4608			}
4609			if (received && zfs_prop_get_recvd(zhp,
4610			    zfs_prop_to_name(entry->pl_prop),
4611			    buf, sizeof (buf), literal) == 0)
4612				if (strlen(buf) > entry->pl_recvd_width)
4613					entry->pl_recvd_width = strlen(buf);
4614		} else {
4615			if (nvlist_lookup_nvlist(userprops, entry->pl_user_prop,
4616			    &propval) == 0) {
4617				verify(nvlist_lookup_string(propval,
4618				    ZPROP_VALUE, &strval) == 0);
4619				if (strlen(strval) > entry->pl_width)
4620					entry->pl_width = strlen(strval);
4621			}
4622			if (received && zfs_prop_get_recvd(zhp,
4623			    entry->pl_user_prop,
4624			    buf, sizeof (buf), literal) == 0)
4625				if (strlen(buf) > entry->pl_recvd_width)
4626					entry->pl_recvd_width = strlen(buf);
4627		}
4628	}
4629
4630	return (0);
4631}
4632
4633int
4634zfs_deleg_share_nfs(libzfs_handle_t *hdl, char *dataset, char *path,
4635    char *resource, void *export, void *sharetab,
4636    int sharemax, zfs_share_op_t operation)
4637{
4638	zfs_cmd_t zc = { 0 };
4639	int error;
4640
4641	(void) strlcpy(zc.zc_name, dataset, sizeof (zc.zc_name));
4642	(void) strlcpy(zc.zc_value, path, sizeof (zc.zc_value));
4643	if (resource)
4644		(void) strlcpy(zc.zc_string, resource, sizeof (zc.zc_string));
4645	zc.zc_share.z_sharedata = (uint64_t)(uintptr_t)sharetab;
4646	zc.zc_share.z_exportdata = (uint64_t)(uintptr_t)export;
4647	zc.zc_share.z_sharetype = operation;
4648	zc.zc_share.z_sharemax = sharemax;
4649	error = ioctl(hdl->libzfs_fd, ZFS_IOC_SHARE, &zc);
4650	return (error);
4651}
4652
4653void
4654zfs_prune_proplist(zfs_handle_t *zhp, uint8_t *props)
4655{
4656	nvpair_t *curr;
4657
4658	/*
4659	 * Keep a reference to the props-table against which we prune the
4660	 * properties.
4661	 */
4662	zhp->zfs_props_table = props;
4663
4664	curr = nvlist_next_nvpair(zhp->zfs_props, NULL);
4665
4666	while (curr) {
4667		zfs_prop_t zfs_prop = zfs_name_to_prop(nvpair_name(curr));
4668		nvpair_t *next = nvlist_next_nvpair(zhp->zfs_props, curr);
4669
4670		/*
4671		 * User properties will result in ZPROP_INVAL, and since we
4672		 * only know how to prune standard ZFS properties, we always
4673		 * leave these in the list.  This can also happen if we
4674		 * encounter an unknown DSL property (when running older
4675		 * software, for example).
4676		 */
4677		if (zfs_prop != ZPROP_INVAL && props[zfs_prop] == B_FALSE)
4678			(void) nvlist_remove(zhp->zfs_props,
4679			    nvpair_name(curr), nvpair_type(curr));
4680		curr = next;
4681	}
4682}
4683
4684#ifdef illumos
4685static int
4686zfs_smb_acl_mgmt(libzfs_handle_t *hdl, char *dataset, char *path,
4687    zfs_smb_acl_op_t cmd, char *resource1, char *resource2)
4688{
4689	zfs_cmd_t zc = { 0 };
4690	nvlist_t *nvlist = NULL;
4691	int error;
4692
4693	(void) strlcpy(zc.zc_name, dataset, sizeof (zc.zc_name));
4694	(void) strlcpy(zc.zc_value, path, sizeof (zc.zc_value));
4695	zc.zc_cookie = (uint64_t)cmd;
4696
4697	if (cmd == ZFS_SMB_ACL_RENAME) {
4698		if (nvlist_alloc(&nvlist, NV_UNIQUE_NAME, 0) != 0) {
4699			(void) no_memory(hdl);
4700			return (0);
4701		}
4702	}
4703
4704	switch (cmd) {
4705	case ZFS_SMB_ACL_ADD:
4706	case ZFS_SMB_ACL_REMOVE:
4707		(void) strlcpy(zc.zc_string, resource1, sizeof (zc.zc_string));
4708		break;
4709	case ZFS_SMB_ACL_RENAME:
4710		if (nvlist_add_string(nvlist, ZFS_SMB_ACL_SRC,
4711		    resource1) != 0) {
4712				(void) no_memory(hdl);
4713				return (-1);
4714		}
4715		if (nvlist_add_string(nvlist, ZFS_SMB_ACL_TARGET,
4716		    resource2) != 0) {
4717				(void) no_memory(hdl);
4718				return (-1);
4719		}
4720		if (zcmd_write_src_nvlist(hdl, &zc, nvlist) != 0) {
4721			nvlist_free(nvlist);
4722			return (-1);
4723		}
4724		break;
4725	case ZFS_SMB_ACL_PURGE:
4726		break;
4727	default:
4728		return (-1);
4729	}
4730	error = ioctl(hdl->libzfs_fd, ZFS_IOC_SMB_ACL, &zc);
4731	nvlist_free(nvlist);
4732	return (error);
4733}
4734
4735int
4736zfs_smb_acl_add(libzfs_handle_t *hdl, char *dataset,
4737    char *path, char *resource)
4738{
4739	return (zfs_smb_acl_mgmt(hdl, dataset, path, ZFS_SMB_ACL_ADD,
4740	    resource, NULL));
4741}
4742
4743int
4744zfs_smb_acl_remove(libzfs_handle_t *hdl, char *dataset,
4745    char *path, char *resource)
4746{
4747	return (zfs_smb_acl_mgmt(hdl, dataset, path, ZFS_SMB_ACL_REMOVE,
4748	    resource, NULL));
4749}
4750
4751int
4752zfs_smb_acl_purge(libzfs_handle_t *hdl, char *dataset, char *path)
4753{
4754	return (zfs_smb_acl_mgmt(hdl, dataset, path, ZFS_SMB_ACL_PURGE,
4755	    NULL, NULL));
4756}
4757
4758int
4759zfs_smb_acl_rename(libzfs_handle_t *hdl, char *dataset, char *path,
4760    char *oldname, char *newname)
4761{
4762	return (zfs_smb_acl_mgmt(hdl, dataset, path, ZFS_SMB_ACL_RENAME,
4763	    oldname, newname));
4764}
4765#endif	/* illumos */
4766
4767int
4768zfs_userspace(zfs_handle_t *zhp, zfs_userquota_prop_t type,
4769    zfs_userspace_cb_t func, void *arg)
4770{
4771	zfs_cmd_t zc = { 0 };
4772	zfs_useracct_t buf[100];
4773	libzfs_handle_t *hdl = zhp->zfs_hdl;
4774	int ret;
4775
4776	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
4777
4778	zc.zc_objset_type = type;
4779	zc.zc_nvlist_dst = (uintptr_t)buf;
4780
4781	for (;;) {
4782		zfs_useracct_t *zua = buf;
4783
4784		zc.zc_nvlist_dst_size = sizeof (buf);
4785		if (zfs_ioctl(hdl, ZFS_IOC_USERSPACE_MANY, &zc) != 0) {
4786			char errbuf[1024];
4787
4788			(void) snprintf(errbuf, sizeof (errbuf),
4789			    dgettext(TEXT_DOMAIN,
4790			    "cannot get used/quota for %s"), zc.zc_name);
4791			return (zfs_standard_error_fmt(hdl, errno, errbuf));
4792		}
4793		if (zc.zc_nvlist_dst_size == 0)
4794			break;
4795
4796		while (zc.zc_nvlist_dst_size > 0) {
4797			if ((ret = func(arg, zua->zu_domain, zua->zu_rid,
4798			    zua->zu_space)) != 0)
4799				return (ret);
4800			zua++;
4801			zc.zc_nvlist_dst_size -= sizeof (zfs_useracct_t);
4802		}
4803	}
4804
4805	return (0);
4806}
4807
4808struct holdarg {
4809	nvlist_t *nvl;
4810	const char *snapname;
4811	const char *tag;
4812	boolean_t recursive;
4813	int error;
4814};
4815
4816static int
4817zfs_hold_one(zfs_handle_t *zhp, void *arg)
4818{
4819	struct holdarg *ha = arg;
4820	char name[ZFS_MAX_DATASET_NAME_LEN];
4821	int rv = 0;
4822
4823	(void) snprintf(name, sizeof (name),
4824	    "%s@%s", zhp->zfs_name, ha->snapname);
4825
4826	if (lzc_exists(name))
4827		fnvlist_add_string(ha->nvl, name, ha->tag);
4828
4829	if (ha->recursive)
4830		rv = zfs_iter_filesystems(zhp, zfs_hold_one, ha);
4831	zfs_close(zhp);
4832	return (rv);
4833}
4834
4835int
4836zfs_hold(zfs_handle_t *zhp, const char *snapname, const char *tag,
4837    boolean_t recursive, int cleanup_fd)
4838{
4839	int ret;
4840	struct holdarg ha;
4841
4842	ha.nvl = fnvlist_alloc();
4843	ha.snapname = snapname;
4844	ha.tag = tag;
4845	ha.recursive = recursive;
4846	(void) zfs_hold_one(zfs_handle_dup(zhp), &ha);
4847
4848	if (nvlist_empty(ha.nvl)) {
4849		char errbuf[1024];
4850
4851		fnvlist_free(ha.nvl);
4852		ret = ENOENT;
4853		(void) snprintf(errbuf, sizeof (errbuf),
4854		    dgettext(TEXT_DOMAIN,
4855		    "cannot hold snapshot '%s@%s'"),
4856		    zhp->zfs_name, snapname);
4857		(void) zfs_standard_error(zhp->zfs_hdl, ret, errbuf);
4858		return (ret);
4859	}
4860
4861	ret = zfs_hold_nvl(zhp, cleanup_fd, ha.nvl);
4862	fnvlist_free(ha.nvl);
4863
4864	return (ret);
4865}
4866
4867int
4868zfs_hold_nvl(zfs_handle_t *zhp, int cleanup_fd, nvlist_t *holds)
4869{
4870	int ret;
4871	nvlist_t *errors;
4872	libzfs_handle_t *hdl = zhp->zfs_hdl;
4873	char errbuf[1024];
4874	nvpair_t *elem;
4875
4876	errors = NULL;
4877	ret = lzc_hold(holds, cleanup_fd, &errors);
4878
4879	if (ret == 0) {
4880		/* There may be errors even in the success case. */
4881		fnvlist_free(errors);
4882		return (0);
4883	}
4884
4885	if (nvlist_empty(errors)) {
4886		/* no hold-specific errors */
4887		(void) snprintf(errbuf, sizeof (errbuf),
4888		    dgettext(TEXT_DOMAIN, "cannot hold"));
4889		switch (ret) {
4890		case ENOTSUP:
4891			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
4892			    "pool must be upgraded"));
4893			(void) zfs_error(hdl, EZFS_BADVERSION, errbuf);
4894			break;
4895		case EINVAL:
4896			(void) zfs_error(hdl, EZFS_BADTYPE, errbuf);
4897			break;
4898		default:
4899			(void) zfs_standard_error(hdl, ret, errbuf);
4900		}
4901	}
4902
4903	for (elem = nvlist_next_nvpair(errors, NULL);
4904	    elem != NULL;
4905	    elem = nvlist_next_nvpair(errors, elem)) {
4906		(void) snprintf(errbuf, sizeof (errbuf),
4907		    dgettext(TEXT_DOMAIN,
4908		    "cannot hold snapshot '%s'"), nvpair_name(elem));
4909		switch (fnvpair_value_int32(elem)) {
4910		case E2BIG:
4911			/*
4912			 * Temporary tags wind up having the ds object id
4913			 * prepended. So even if we passed the length check
4914			 * above, it's still possible for the tag to wind
4915			 * up being slightly too long.
4916			 */
4917			(void) zfs_error(hdl, EZFS_TAGTOOLONG, errbuf);
4918			break;
4919		case EINVAL:
4920			(void) zfs_error(hdl, EZFS_BADTYPE, errbuf);
4921			break;
4922		case EEXIST:
4923			(void) zfs_error(hdl, EZFS_REFTAG_HOLD, errbuf);
4924			break;
4925		default:
4926			(void) zfs_standard_error(hdl,
4927			    fnvpair_value_int32(elem), errbuf);
4928		}
4929	}
4930
4931	fnvlist_free(errors);
4932	return (ret);
4933}
4934
4935static int
4936zfs_release_one(zfs_handle_t *zhp, void *arg)
4937{
4938	struct holdarg *ha = arg;
4939	char name[ZFS_MAX_DATASET_NAME_LEN];
4940	int rv = 0;
4941	nvlist_t *existing_holds;
4942
4943	(void) snprintf(name, sizeof (name),
4944	    "%s@%s", zhp->zfs_name, ha->snapname);
4945
4946	if (lzc_get_holds(name, &existing_holds) != 0) {
4947		ha->error = ENOENT;
4948	} else if (!nvlist_exists(existing_holds, ha->tag)) {
4949		ha->error = ESRCH;
4950	} else {
4951		nvlist_t *torelease = fnvlist_alloc();
4952		fnvlist_add_boolean(torelease, ha->tag);
4953		fnvlist_add_nvlist(ha->nvl, name, torelease);
4954		fnvlist_free(torelease);
4955	}
4956
4957	if (ha->recursive)
4958		rv = zfs_iter_filesystems(zhp, zfs_release_one, ha);
4959	zfs_close(zhp);
4960	return (rv);
4961}
4962
4963int
4964zfs_release(zfs_handle_t *zhp, const char *snapname, const char *tag,
4965    boolean_t recursive)
4966{
4967	int ret;
4968	struct holdarg ha;
4969	nvlist_t *errors = NULL;
4970	nvpair_t *elem;
4971	libzfs_handle_t *hdl = zhp->zfs_hdl;
4972	char errbuf[1024];
4973
4974	ha.nvl = fnvlist_alloc();
4975	ha.snapname = snapname;
4976	ha.tag = tag;
4977	ha.recursive = recursive;
4978	ha.error = 0;
4979	(void) zfs_release_one(zfs_handle_dup(zhp), &ha);
4980
4981	if (nvlist_empty(ha.nvl)) {
4982		fnvlist_free(ha.nvl);
4983		ret = ha.error;
4984		(void) snprintf(errbuf, sizeof (errbuf),
4985		    dgettext(TEXT_DOMAIN,
4986		    "cannot release hold from snapshot '%s@%s'"),
4987		    zhp->zfs_name, snapname);
4988		if (ret == ESRCH) {
4989			(void) zfs_error(hdl, EZFS_REFTAG_RELE, errbuf);
4990		} else {
4991			(void) zfs_standard_error(hdl, ret, errbuf);
4992		}
4993		return (ret);
4994	}
4995
4996	ret = lzc_release(ha.nvl, &errors);
4997	fnvlist_free(ha.nvl);
4998
4999	if (ret == 0) {
5000		/* There may be errors even in the success case. */
5001		fnvlist_free(errors);
5002		return (0);
5003	}
5004
5005	if (nvlist_empty(errors)) {
5006		/* no hold-specific errors */
5007		(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
5008		    "cannot release"));
5009		switch (errno) {
5010		case ENOTSUP:
5011			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
5012			    "pool must be upgraded"));
5013			(void) zfs_error(hdl, EZFS_BADVERSION, errbuf);
5014			break;
5015		default:
5016			(void) zfs_standard_error_fmt(hdl, errno, errbuf);
5017		}
5018	}
5019
5020	for (elem = nvlist_next_nvpair(errors, NULL);
5021	    elem != NULL;
5022	    elem = nvlist_next_nvpair(errors, elem)) {
5023		(void) snprintf(errbuf, sizeof (errbuf),
5024		    dgettext(TEXT_DOMAIN,
5025		    "cannot release hold from snapshot '%s'"),
5026		    nvpair_name(elem));
5027		switch (fnvpair_value_int32(elem)) {
5028		case ESRCH:
5029			(void) zfs_error(hdl, EZFS_REFTAG_RELE, errbuf);
5030			break;
5031		case EINVAL:
5032			(void) zfs_error(hdl, EZFS_BADTYPE, errbuf);
5033			break;
5034		default:
5035			(void) zfs_standard_error_fmt(hdl,
5036			    fnvpair_value_int32(elem), errbuf);
5037		}
5038	}
5039
5040	fnvlist_free(errors);
5041	return (ret);
5042}
5043
5044int
5045zfs_get_fsacl(zfs_handle_t *zhp, nvlist_t **nvl)
5046{
5047	zfs_cmd_t zc = { 0 };
5048	libzfs_handle_t *hdl = zhp->zfs_hdl;
5049	int nvsz = 2048;
5050	void *nvbuf;
5051	int err = 0;
5052	char errbuf[1024];
5053
5054	assert(zhp->zfs_type == ZFS_TYPE_VOLUME ||
5055	    zhp->zfs_type == ZFS_TYPE_FILESYSTEM);
5056
5057tryagain:
5058
5059	nvbuf = malloc(nvsz);
5060	if (nvbuf == NULL) {
5061		err = (zfs_error(hdl, EZFS_NOMEM, strerror(errno)));
5062		goto out;
5063	}
5064
5065	zc.zc_nvlist_dst_size = nvsz;
5066	zc.zc_nvlist_dst = (uintptr_t)nvbuf;
5067
5068	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
5069
5070	if (ioctl(hdl->libzfs_fd, ZFS_IOC_GET_FSACL, &zc) != 0) {
5071		(void) snprintf(errbuf, sizeof (errbuf),
5072		    dgettext(TEXT_DOMAIN, "cannot get permissions on '%s'"),
5073		    zc.zc_name);
5074		switch (errno) {
5075		case ENOMEM:
5076			free(nvbuf);
5077			nvsz = zc.zc_nvlist_dst_size;
5078			goto tryagain;
5079
5080		case ENOTSUP:
5081			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
5082			    "pool must be upgraded"));
5083			err = zfs_error(hdl, EZFS_BADVERSION, errbuf);
5084			break;
5085		case EINVAL:
5086			err = zfs_error(hdl, EZFS_BADTYPE, errbuf);
5087			break;
5088		case ENOENT:
5089			err = zfs_error(hdl, EZFS_NOENT, errbuf);
5090			break;
5091		default:
5092			err = zfs_standard_error_fmt(hdl, errno, errbuf);
5093			break;
5094		}
5095	} else {
5096		/* success */
5097		int rc = nvlist_unpack(nvbuf, zc.zc_nvlist_dst_size, nvl, 0);
5098		if (rc) {
5099			(void) snprintf(errbuf, sizeof (errbuf), dgettext(
5100			    TEXT_DOMAIN, "cannot get permissions on '%s'"),
5101			    zc.zc_name);
5102			err = zfs_standard_error_fmt(hdl, rc, errbuf);
5103		}
5104	}
5105
5106	free(nvbuf);
5107out:
5108	return (err);
5109}
5110
5111int
5112zfs_set_fsacl(zfs_handle_t *zhp, boolean_t un, nvlist_t *nvl)
5113{
5114	zfs_cmd_t zc = { 0 };
5115	libzfs_handle_t *hdl = zhp->zfs_hdl;
5116	char *nvbuf;
5117	char errbuf[1024];
5118	size_t nvsz;
5119	int err;
5120
5121	assert(zhp->zfs_type == ZFS_TYPE_VOLUME ||
5122	    zhp->zfs_type == ZFS_TYPE_FILESYSTEM);
5123
5124	err = nvlist_size(nvl, &nvsz, NV_ENCODE_NATIVE);
5125	assert(err == 0);
5126
5127	nvbuf = malloc(nvsz);
5128
5129	err = nvlist_pack(nvl, &nvbuf, &nvsz, NV_ENCODE_NATIVE, 0);
5130	assert(err == 0);
5131
5132	zc.zc_nvlist_src_size = nvsz;
5133	zc.zc_nvlist_src = (uintptr_t)nvbuf;
5134	zc.zc_perm_action = un;
5135
5136	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
5137
5138	if (zfs_ioctl(hdl, ZFS_IOC_SET_FSACL, &zc) != 0) {
5139		(void) snprintf(errbuf, sizeof (errbuf),
5140		    dgettext(TEXT_DOMAIN, "cannot set permissions on '%s'"),
5141		    zc.zc_name);
5142		switch (errno) {
5143		case ENOTSUP:
5144			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
5145			    "pool must be upgraded"));
5146			err = zfs_error(hdl, EZFS_BADVERSION, errbuf);
5147			break;
5148		case EINVAL:
5149			err = zfs_error(hdl, EZFS_BADTYPE, errbuf);
5150			break;
5151		case ENOENT:
5152			err = zfs_error(hdl, EZFS_NOENT, errbuf);
5153			break;
5154		default:
5155			err = zfs_standard_error_fmt(hdl, errno, errbuf);
5156			break;
5157		}
5158	}
5159
5160	free(nvbuf);
5161
5162	return (err);
5163}
5164
5165int
5166zfs_get_holds(zfs_handle_t *zhp, nvlist_t **nvl)
5167{
5168	int err;
5169	char errbuf[1024];
5170
5171	err = lzc_get_holds(zhp->zfs_name, nvl);
5172
5173	if (err != 0) {
5174		libzfs_handle_t *hdl = zhp->zfs_hdl;
5175
5176		(void) snprintf(errbuf, sizeof (errbuf),
5177		    dgettext(TEXT_DOMAIN, "cannot get holds for '%s'"),
5178		    zhp->zfs_name);
5179		switch (err) {
5180		case ENOTSUP:
5181			zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
5182			    "pool must be upgraded"));
5183			err = zfs_error(hdl, EZFS_BADVERSION, errbuf);
5184			break;
5185		case EINVAL:
5186			err = zfs_error(hdl, EZFS_BADTYPE, errbuf);
5187			break;
5188		case ENOENT:
5189			err = zfs_error(hdl, EZFS_NOENT, errbuf);
5190			break;
5191		default:
5192			err = zfs_standard_error_fmt(hdl, errno, errbuf);
5193			break;
5194		}
5195	}
5196
5197	return (err);
5198}
5199
5200/*
5201 * Convert the zvol's volume size to an appropriate reservation.
5202 * Note: If this routine is updated, it is necessary to update the ZFS test
5203 * suite's shell version in reservation.kshlib.
5204 */
5205uint64_t
5206zvol_volsize_to_reservation(uint64_t volsize, nvlist_t *props)
5207{
5208	uint64_t numdb;
5209	uint64_t nblocks, volblocksize;
5210	int ncopies;
5211	char *strval;
5212
5213	if (nvlist_lookup_string(props,
5214	    zfs_prop_to_name(ZFS_PROP_COPIES), &strval) == 0)
5215		ncopies = atoi(strval);
5216	else
5217		ncopies = 1;
5218	if (nvlist_lookup_uint64(props,
5219	    zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE),
5220	    &volblocksize) != 0)
5221		volblocksize = ZVOL_DEFAULT_BLOCKSIZE;
5222	nblocks = volsize/volblocksize;
5223	/* start with metadnode L0-L6 */
5224	numdb = 7;
5225	/* calculate number of indirects */
5226	while (nblocks > 1) {
5227		nblocks += DNODES_PER_LEVEL - 1;
5228		nblocks /= DNODES_PER_LEVEL;
5229		numdb += nblocks;
5230	}
5231	numdb *= MIN(SPA_DVAS_PER_BP, ncopies + 1);
5232	volsize *= ncopies;
5233	/*
5234	 * this is exactly DN_MAX_INDBLKSHIFT when metadata isn't
5235	 * compressed, but in practice they compress down to about
5236	 * 1100 bytes
5237	 */
5238	numdb *= 1ULL << DN_MAX_INDBLKSHIFT;
5239	volsize += numdb;
5240	return (volsize);
5241}
5242
5243/*
5244 * Attach/detach the given filesystem to/from the given jail.
5245 */
5246int
5247zfs_jail(zfs_handle_t *zhp, int jailid, int attach)
5248{
5249	libzfs_handle_t *hdl = zhp->zfs_hdl;
5250	zfs_cmd_t zc = { 0 };
5251	char errbuf[1024];
5252	unsigned long cmd;
5253	int ret;
5254
5255	if (attach) {
5256		(void) snprintf(errbuf, sizeof (errbuf),
5257		    dgettext(TEXT_DOMAIN, "cannot jail '%s'"), zhp->zfs_name);
5258	} else {
5259		(void) snprintf(errbuf, sizeof (errbuf),
5260		    dgettext(TEXT_DOMAIN, "cannot unjail '%s'"), zhp->zfs_name);
5261	}
5262
5263	switch (zhp->zfs_type) {
5264	case ZFS_TYPE_VOLUME:
5265		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
5266		    "volumes can not be jailed"));
5267		return (zfs_error(hdl, EZFS_BADTYPE, errbuf));
5268	case ZFS_TYPE_SNAPSHOT:
5269		zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
5270		    "snapshots can not be jailed"));
5271		return (zfs_error(hdl, EZFS_BADTYPE, errbuf));
5272	}
5273	assert(zhp->zfs_type == ZFS_TYPE_FILESYSTEM);
5274
5275	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
5276	zc.zc_objset_type = DMU_OST_ZFS;
5277	zc.zc_jailid = jailid;
5278
5279	cmd = attach ? ZFS_IOC_JAIL : ZFS_IOC_UNJAIL;
5280	if ((ret = ioctl(hdl->libzfs_fd, cmd, &zc)) != 0)
5281		zfs_standard_error(hdl, errno, errbuf);
5282
5283	return (ret);
5284}
5285