xref: /titanic_52/usr/src/cmd/zfs/zfs_main.c (revision c61ea5668634a215fd1c9000beb7f6d2853b3468)
1fa9e4066Sahrens /*
2fa9e4066Sahrens  * CDDL HEADER START
3fa9e4066Sahrens  *
4fa9e4066Sahrens  * The contents of this file are subject to the terms of the
5ea8dc4b6Seschrock  * Common Development and Distribution License (the "License").
6ea8dc4b6Seschrock  * You may not use this file except in compliance with the License.
7fa9e4066Sahrens  *
8fa9e4066Sahrens  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9fa9e4066Sahrens  * or http://www.opensolaris.org/os/licensing.
10fa9e4066Sahrens  * See the License for the specific language governing permissions
11fa9e4066Sahrens  * and limitations under the License.
12fa9e4066Sahrens  *
13fa9e4066Sahrens  * When distributing Covered Code, include this CDDL HEADER in each
14fa9e4066Sahrens  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15fa9e4066Sahrens  * If applicable, add the following below this CDDL HEADER, with the
16fa9e4066Sahrens  * fields enclosed by brackets "[]" replaced with your own identifying
17fa9e4066Sahrens  * information: Portions Copyright [yyyy] [name of copyright owner]
18fa9e4066Sahrens  *
19fa9e4066Sahrens  * CDDL HEADER END
20fa9e4066Sahrens  */
21f3861e1aSahl 
22fa9e4066Sahrens /*
233f9d6ad7SLin Ling  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
24c560ed2bSAlexander Eremin  * Copyright 2012 Nexenta Systems, Inc. All rights reserved.
256a9cb0eaSEric Schrock  * Copyright (c) 2012 by Delphix. All rights reserved.
2633f5ff17SMilan Jurik  * Copyright 2012 Milan Jurik. All rights reserved.
274e3c9f44SBill Pijewski  * Copyright (c) 2012, Joyent, Inc. All rights reserved.
28fa9e4066Sahrens  */
29fa9e4066Sahrens 
30fa9e4066Sahrens #include <assert.h>
31e9dbad6fSeschrock #include <ctype.h>
32fa9e4066Sahrens #include <errno.h>
33fa9e4066Sahrens #include <libgen.h>
34fa9e4066Sahrens #include <libintl.h>
35fa9e4066Sahrens #include <libuutil.h>
36ecd6cf80Smarks #include <libnvpair.h>
37fa9e4066Sahrens #include <locale.h>
38fa9e4066Sahrens #include <stddef.h>
39fa9e4066Sahrens #include <stdio.h>
40fa9e4066Sahrens #include <stdlib.h>
41fa9e4066Sahrens #include <strings.h>
42fa9e4066Sahrens #include <unistd.h>
43fa9e4066Sahrens #include <fcntl.h>
44fa9e4066Sahrens #include <zone.h>
4514843421SMatthew Ahrens #include <grp.h>
4614843421SMatthew Ahrens #include <pwd.h>
4799d5e173STim Haley #include <signal.h>
481af68beaSAlexander Stetsenko #include <sys/list.h>
49fa9e4066Sahrens #include <sys/mkdev.h>
50fa9e4066Sahrens #include <sys/mntent.h>
51fa9e4066Sahrens #include <sys/mnttab.h>
52fa9e4066Sahrens #include <sys/mount.h>
53fa9e4066Sahrens #include <sys/stat.h>
5414843421SMatthew Ahrens #include <sys/fs/zfs.h>
55a8b6ddafSMark J Musante #include <sys/types.h>
56a8b6ddafSMark J Musante #include <time.h>
57fa9e4066Sahrens 
58fa9e4066Sahrens #include <libzfs.h>
594445fffbSMatthew Ahrens #include <libzfs_core.h>
601af68beaSAlexander Stetsenko #include <zfs_prop.h>
611af68beaSAlexander Stetsenko #include <zfs_deleg.h>
62ecd6cf80Smarks #include <libuutil.h>
631af68beaSAlexander Stetsenko #include <aclutils.h>
641af68beaSAlexander Stetsenko #include <directory.h>
65fa9e4066Sahrens 
66fa9e4066Sahrens #include "zfs_iter.h"
6799653d4eSeschrock #include "zfs_util.h"
680a586ceaSMark Shellenbaum #include "zfs_comutil.h"
6999653d4eSeschrock 
7099653d4eSeschrock libzfs_handle_t *g_zfs;
71fa9e4066Sahrens 
72fa9e4066Sahrens static FILE *mnttab_file;
732a6b87f0Sek110237 static char history_str[HIS_MAX_RECORD_LEN];
744445fffbSMatthew Ahrens static boolean_t log_history = B_TRUE;
75fa9e4066Sahrens 
76fa9e4066Sahrens static int zfs_do_clone(int argc, char **argv);
77fa9e4066Sahrens static int zfs_do_create(int argc, char **argv);
78fa9e4066Sahrens static int zfs_do_destroy(int argc, char **argv);
79fa9e4066Sahrens static int zfs_do_get(int argc, char **argv);
80fa9e4066Sahrens static int zfs_do_inherit(int argc, char **argv);
81fa9e4066Sahrens static int zfs_do_list(int argc, char **argv);
82fa9e4066Sahrens static int zfs_do_mount(int argc, char **argv);
83fa9e4066Sahrens static int zfs_do_rename(int argc, char **argv);
84fa9e4066Sahrens static int zfs_do_rollback(int argc, char **argv);
85fa9e4066Sahrens static int zfs_do_set(int argc, char **argv);
86e7437265Sahrens static int zfs_do_upgrade(int argc, char **argv);
87fa9e4066Sahrens static int zfs_do_snapshot(int argc, char **argv);
88fa9e4066Sahrens static int zfs_do_unmount(int argc, char **argv);
89fa9e4066Sahrens static int zfs_do_share(int argc, char **argv);
90fa9e4066Sahrens static int zfs_do_unshare(int argc, char **argv);
91f2a3c691Sahrens static int zfs_do_send(int argc, char **argv);
92f2a3c691Sahrens static int zfs_do_receive(int argc, char **argv);
9399653d4eSeschrock static int zfs_do_promote(int argc, char **argv);
9414843421SMatthew Ahrens static int zfs_do_userspace(int argc, char **argv);
951af68beaSAlexander Stetsenko static int zfs_do_allow(int argc, char **argv);
961af68beaSAlexander Stetsenko static int zfs_do_unallow(int argc, char **argv);
97842727c2SChris Kirby static int zfs_do_hold(int argc, char **argv);
981af68beaSAlexander Stetsenko static int zfs_do_holds(int argc, char **argv);
99842727c2SChris Kirby static int zfs_do_release(int argc, char **argv);
10099d5e173STim Haley static int zfs_do_diff(int argc, char **argv);
101fa9e4066Sahrens 
102fa9e4066Sahrens /*
10329ab75c9Srm160521  * Enable a reasonable set of defaults for libumem debugging on DEBUG builds.
104fa9e4066Sahrens  */
10529ab75c9Srm160521 
10629ab75c9Srm160521 #ifdef DEBUG
107fa9e4066Sahrens const char *
108f3861e1aSahl _umem_debug_init(void)
109fa9e4066Sahrens {
110fa9e4066Sahrens 	return ("default,verbose"); /* $UMEM_DEBUG setting */
111fa9e4066Sahrens }
112fa9e4066Sahrens 
113fa9e4066Sahrens const char *
114fa9e4066Sahrens _umem_logging_init(void)
115fa9e4066Sahrens {
116fa9e4066Sahrens 	return ("fail,contents"); /* $UMEM_LOGGING setting */
117fa9e4066Sahrens }
11829ab75c9Srm160521 #endif
119fa9e4066Sahrens 
12065cd9f28Seschrock typedef enum {
12165cd9f28Seschrock 	HELP_CLONE,
12265cd9f28Seschrock 	HELP_CREATE,
12365cd9f28Seschrock 	HELP_DESTROY,
12465cd9f28Seschrock 	HELP_GET,
12565cd9f28Seschrock 	HELP_INHERIT,
126e7437265Sahrens 	HELP_UPGRADE,
12765cd9f28Seschrock 	HELP_LIST,
12865cd9f28Seschrock 	HELP_MOUNT,
12999653d4eSeschrock 	HELP_PROMOTE,
130f2a3c691Sahrens 	HELP_RECEIVE,
13165cd9f28Seschrock 	HELP_RENAME,
13265cd9f28Seschrock 	HELP_ROLLBACK,
133f2a3c691Sahrens 	HELP_SEND,
13465cd9f28Seschrock 	HELP_SET,
13565cd9f28Seschrock 	HELP_SHARE,
13665cd9f28Seschrock 	HELP_SNAPSHOT,
13765cd9f28Seschrock 	HELP_UNMOUNT,
138ecd6cf80Smarks 	HELP_UNSHARE,
139ecd6cf80Smarks 	HELP_ALLOW,
14014843421SMatthew Ahrens 	HELP_UNALLOW,
14114843421SMatthew Ahrens 	HELP_USERSPACE,
142842727c2SChris Kirby 	HELP_GROUPSPACE,
143842727c2SChris Kirby 	HELP_HOLD,
144842727c2SChris Kirby 	HELP_HOLDS,
14599d5e173STim Haley 	HELP_RELEASE,
14619b94df9SMatthew Ahrens 	HELP_DIFF,
14765cd9f28Seschrock } zfs_help_t;
14865cd9f28Seschrock 
149fa9e4066Sahrens typedef struct zfs_command {
150fa9e4066Sahrens 	const char	*name;
151fa9e4066Sahrens 	int		(*func)(int argc, char **argv);
15265cd9f28Seschrock 	zfs_help_t	usage;
153fa9e4066Sahrens } zfs_command_t;
154fa9e4066Sahrens 
155fa9e4066Sahrens /*
156fa9e4066Sahrens  * Master command table.  Each ZFS command has a name, associated function, and
157ea8dc4b6Seschrock  * usage message.  The usage messages need to be internationalized, so we have
158ea8dc4b6Seschrock  * to have a function to return the usage message based on a command index.
15965cd9f28Seschrock  *
16065cd9f28Seschrock  * These commands are organized according to how they are displayed in the usage
16165cd9f28Seschrock  * message.  An empty command (one with a NULL name) indicates an empty line in
16265cd9f28Seschrock  * the generic usage message.
163fa9e4066Sahrens  */
164fa9e4066Sahrens static zfs_command_t command_table[] = {
16565cd9f28Seschrock 	{ "create",	zfs_do_create,		HELP_CREATE		},
16665cd9f28Seschrock 	{ "destroy",	zfs_do_destroy,		HELP_DESTROY		},
167fa9e4066Sahrens 	{ NULL },
16865cd9f28Seschrock 	{ "snapshot",	zfs_do_snapshot,	HELP_SNAPSHOT		},
16965cd9f28Seschrock 	{ "rollback",	zfs_do_rollback,	HELP_ROLLBACK		},
17065cd9f28Seschrock 	{ "clone",	zfs_do_clone,		HELP_CLONE		},
17199653d4eSeschrock 	{ "promote",	zfs_do_promote,		HELP_PROMOTE		},
17265cd9f28Seschrock 	{ "rename",	zfs_do_rename,		HELP_RENAME		},
173fa9e4066Sahrens 	{ NULL },
17465cd9f28Seschrock 	{ "list",	zfs_do_list,		HELP_LIST		},
175fa9e4066Sahrens 	{ NULL },
17665cd9f28Seschrock 	{ "set",	zfs_do_set,		HELP_SET		},
17765cd9f28Seschrock 	{ "get",	zfs_do_get,		HELP_GET		},
17865cd9f28Seschrock 	{ "inherit",	zfs_do_inherit,		HELP_INHERIT		},
179e7437265Sahrens 	{ "upgrade",	zfs_do_upgrade,		HELP_UPGRADE		},
18014843421SMatthew Ahrens 	{ "userspace",	zfs_do_userspace,	HELP_USERSPACE		},
18114843421SMatthew Ahrens 	{ "groupspace",	zfs_do_userspace,	HELP_GROUPSPACE		},
182fa9e4066Sahrens 	{ NULL },
18365cd9f28Seschrock 	{ "mount",	zfs_do_mount,		HELP_MOUNT		},
18465cd9f28Seschrock 	{ "unmount",	zfs_do_unmount,		HELP_UNMOUNT		},
18565cd9f28Seschrock 	{ "share",	zfs_do_share,		HELP_SHARE		},
18665cd9f28Seschrock 	{ "unshare",	zfs_do_unshare,		HELP_UNSHARE		},
187fa9e4066Sahrens 	{ NULL },
188f2a3c691Sahrens 	{ "send",	zfs_do_send,		HELP_SEND		},
189f2a3c691Sahrens 	{ "receive",	zfs_do_receive,		HELP_RECEIVE		},
190ecd6cf80Smarks 	{ NULL },
1911af68beaSAlexander Stetsenko 	{ "allow",	zfs_do_allow,		HELP_ALLOW		},
192ecd6cf80Smarks 	{ NULL },
1931af68beaSAlexander Stetsenko 	{ "unallow",	zfs_do_unallow,		HELP_UNALLOW		},
194842727c2SChris Kirby 	{ NULL },
195842727c2SChris Kirby 	{ "hold",	zfs_do_hold,		HELP_HOLD		},
1961af68beaSAlexander Stetsenko 	{ "holds",	zfs_do_holds,		HELP_HOLDS		},
197842727c2SChris Kirby 	{ "release",	zfs_do_release,		HELP_RELEASE		},
19899d5e173STim Haley 	{ "diff",	zfs_do_diff,		HELP_DIFF		},
199fa9e4066Sahrens };
200fa9e4066Sahrens 
201fa9e4066Sahrens #define	NCOMMAND	(sizeof (command_table) / sizeof (command_table[0]))
202fa9e4066Sahrens 
203fa9e4066Sahrens zfs_command_t *current_command;
204fa9e4066Sahrens 
20565cd9f28Seschrock static const char *
20665cd9f28Seschrock get_usage(zfs_help_t idx)
20765cd9f28Seschrock {
20865cd9f28Seschrock 	switch (idx) {
20965cd9f28Seschrock 	case HELP_CLONE:
210bb0ade09Sahrens 		return (gettext("\tclone [-p] [-o property=value] ... "
211bb0ade09Sahrens 		    "<snapshot> <filesystem|volume>\n"));
21265cd9f28Seschrock 	case HELP_CREATE:
213e45ce728Sahrens 		return (gettext("\tcreate [-p] [-o property=value] ... "
214e9dbad6fSeschrock 		    "<filesystem>\n"
215e45ce728Sahrens 		    "\tcreate [-ps] [-b blocksize] [-o property=value] ... "
216e45ce728Sahrens 		    "-V <size> <volume>\n"));
21765cd9f28Seschrock 	case HELP_DESTROY:
21819b94df9SMatthew Ahrens 		return (gettext("\tdestroy [-fnpRrv] <filesystem|volume>\n"
21919b94df9SMatthew Ahrens 		    "\tdestroy [-dnpRrv] "
22019b94df9SMatthew Ahrens 		    "<filesystem|volume>@<snap>[%<snap>][,...]\n"));
22165cd9f28Seschrock 	case HELP_GET:
222ae1726b6SChris Gerhard 		return (gettext("\tget [-rHp] [-d max] "
223441cac7aSAndrew Stormont 		    "[-o \"all\" | field[,...]] [-t type[,...]] "
224441cac7aSAndrew Stormont 		    "[-s source[,...]]\n"
225e45ce728Sahrens 		    "\t    <\"all\" | property[,...]> "
226e9dbad6fSeschrock 		    "[filesystem|volume|snapshot] ...\n"));
22765cd9f28Seschrock 	case HELP_INHERIT:
22892241e0bSTom Erickson 		return (gettext("\tinherit [-rS] <property> "
229bb0ade09Sahrens 		    "<filesystem|volume|snapshot> ...\n"));
230e7437265Sahrens 	case HELP_UPGRADE:
231e7437265Sahrens 		return (gettext("\tupgrade [-v]\n"
232e7437265Sahrens 		    "\tupgrade [-r] [-V version] <-a | filesystem ...>\n"));
23365cd9f28Seschrock 	case HELP_LIST:
234ae1726b6SChris Gerhard 		return (gettext("\tlist [-rH][-d max] "
235ae1726b6SChris Gerhard 		    "[-o property[,...]] [-t type[,...]] [-s property] ...\n"
236e45ce728Sahrens 		    "\t    [-S property] ... "
237e45ce728Sahrens 		    "[filesystem|volume|snapshot] ...\n"));
23865cd9f28Seschrock 	case HELP_MOUNT:
23965cd9f28Seschrock 		return (gettext("\tmount\n"
240e45ce728Sahrens 		    "\tmount [-vO] [-o opts] <-a | filesystem>\n"));
24199653d4eSeschrock 	case HELP_PROMOTE:
242e45ce728Sahrens 		return (gettext("\tpromote <clone-filesystem>\n"));
243f2a3c691Sahrens 	case HELP_RECEIVE:
244b1d99cdfSTom Erickson 		return (gettext("\treceive [-vnFu] <filesystem|volume|"
24598579b20Snd150628 		"snapshot>\n"
246b1d99cdfSTom Erickson 		"\treceive [-vnFu] [-d | -e] <filesystem>\n"));
24765cd9f28Seschrock 	case HELP_RENAME:
2486a9cb0eaSEric Schrock 		return (gettext("\trename [-f] <filesystem|volume|snapshot> "
249cdf5b4caSmmusante 		    "<filesystem|volume|snapshot>\n"
2506a9cb0eaSEric Schrock 		    "\trename [-f] -p <filesystem|volume> <filesystem|volume>\n"
251cdf5b4caSmmusante 		    "\trename -r <snapshot> <snapshot>"));
25265cd9f28Seschrock 	case HELP_ROLLBACK:
253f17c7ff8Sahrens 		return (gettext("\trollback [-rRf] <snapshot>\n"));
254f2a3c691Sahrens 	case HELP_SEND:
255bde2df36SYuri Pankov 		return (gettext("\tsend [-DnPpRv] [-[iI] snapshot] "
25619b94df9SMatthew Ahrens 		    "<snapshot>\n"));
25765cd9f28Seschrock 	case HELP_SET:
25865cd9f28Seschrock 		return (gettext("\tset <property=value> "
259bb0ade09Sahrens 		    "<filesystem|volume|snapshot> ...\n"));
26065cd9f28Seschrock 	case HELP_SHARE:
261e45ce728Sahrens 		return (gettext("\tshare <-a | filesystem>\n"));
26265cd9f28Seschrock 	case HELP_SNAPSHOT:
263bb0ade09Sahrens 		return (gettext("\tsnapshot [-r] [-o property=value] ... "
2644445fffbSMatthew Ahrens 		    "<filesystem@snapname|volume@snapname> ...\n"));
26565cd9f28Seschrock 	case HELP_UNMOUNT:
266e45ce728Sahrens 		return (gettext("\tunmount [-f] "
267e45ce728Sahrens 		    "<-a | filesystem|mountpoint>\n"));
26865cd9f28Seschrock 	case HELP_UNSHARE:
2692269545aSstephanie scheffler 		return (gettext("\tunshare "
270e45ce728Sahrens 		    "<-a | filesystem|mountpoint>\n"));
271ecd6cf80Smarks 	case HELP_ALLOW:
27260b94cc3Sstephanie scheffler 		return (gettext("\tallow <filesystem|volume>\n"
27360b94cc3Sstephanie scheffler 		    "\tallow [-ldug] "
274e45ce728Sahrens 		    "<\"everyone\"|user|group>[,...] <perm|@setname>[,...]\n"
275e45ce728Sahrens 		    "\t    <filesystem|volume>\n"
276e45ce728Sahrens 		    "\tallow [-ld] -e <perm|@setname>[,...] "
277ecd6cf80Smarks 		    "<filesystem|volume>\n"
278e45ce728Sahrens 		    "\tallow -c <perm|@setname>[,...] <filesystem|volume>\n"
279e45ce728Sahrens 		    "\tallow -s @setname <perm|@setname>[,...] "
280ecd6cf80Smarks 		    "<filesystem|volume>\n"));
281ecd6cf80Smarks 	case HELP_UNALLOW:
282e45ce728Sahrens 		return (gettext("\tunallow [-rldug] "
283e45ce728Sahrens 		    "<\"everyone\"|user|group>[,...]\n"
284e45ce728Sahrens 		    "\t    [<perm|@setname>[,...]] <filesystem|volume>\n"
285e45ce728Sahrens 		    "\tunallow [-rld] -e [<perm|@setname>[,...]] "
286ecd6cf80Smarks 		    "<filesystem|volume>\n"
287e45ce728Sahrens 		    "\tunallow [-r] -c [<perm|@setname>[,...]] "
288ecd6cf80Smarks 		    "<filesystem|volume>\n"
289e45ce728Sahrens 		    "\tunallow [-r] -s @setname [<perm|@setname>[,...]] "
290e45ce728Sahrens 		    "<filesystem|volume>\n"));
29114843421SMatthew Ahrens 	case HELP_USERSPACE:
29289f5d17bSYuri Pankov 		return (gettext("\tuserspace [-Hinp] [-o field[,...]] "
29389f5d17bSYuri Pankov 		    "[-s field] ...\n\t[-S field] ... "
29489f5d17bSYuri Pankov 		    "[-t type[,...]] <filesystem|snapshot>\n"));
29514843421SMatthew Ahrens 	case HELP_GROUPSPACE:
29689f5d17bSYuri Pankov 		return (gettext("\tgroupspace [-Hinp] [-o field[,...]] "
29789f5d17bSYuri Pankov 		    "[-s field] ...\n\t[-S field] ... "
29889f5d17bSYuri Pankov 		    "[-t type[,...]] <filesystem|snapshot>\n"));
299842727c2SChris Kirby 	case HELP_HOLD:
300842727c2SChris Kirby 		return (gettext("\thold [-r] <tag> <snapshot> ...\n"));
301842727c2SChris Kirby 	case HELP_HOLDS:
302842727c2SChris Kirby 		return (gettext("\tholds [-r] <snapshot> ...\n"));
303842727c2SChris Kirby 	case HELP_RELEASE:
304842727c2SChris Kirby 		return (gettext("\trelease [-r] <tag> <snapshot> ...\n"));
30599d5e173STim Haley 	case HELP_DIFF:
30699d5e173STim Haley 		return (gettext("\tdiff [-FHt] <snapshot> "
30799d5e173STim Haley 		    "[snapshot|filesystem]\n"));
30865cd9f28Seschrock 	}
30965cd9f28Seschrock 
31065cd9f28Seschrock 	abort();
31165cd9f28Seschrock 	/* NOTREACHED */
31265cd9f28Seschrock }
31365cd9f28Seschrock 
314a8b6ddafSMark J Musante void
315a8b6ddafSMark J Musante nomem(void)
316a8b6ddafSMark J Musante {
317a8b6ddafSMark J Musante 	(void) fprintf(stderr, gettext("internal error: out of memory\n"));
318a8b6ddafSMark J Musante 	exit(1);
319a8b6ddafSMark J Musante }
320a8b6ddafSMark J Musante 
321fa9e4066Sahrens /*
322fa9e4066Sahrens  * Utility function to guarantee malloc() success.
323fa9e4066Sahrens  */
324a8b6ddafSMark J Musante 
325fa9e4066Sahrens void *
326fa9e4066Sahrens safe_malloc(size_t size)
327fa9e4066Sahrens {
328fa9e4066Sahrens 	void *data;
329fa9e4066Sahrens 
330a8b6ddafSMark J Musante 	if ((data = calloc(1, size)) == NULL)
331a8b6ddafSMark J Musante 		nomem();
332fa9e4066Sahrens 
333fa9e4066Sahrens 	return (data);
334fa9e4066Sahrens }
335fa9e4066Sahrens 
336a8b6ddafSMark J Musante static char *
337a8b6ddafSMark J Musante safe_strdup(char *str)
338a8b6ddafSMark J Musante {
339a8b6ddafSMark J Musante 	char *dupstr = strdup(str);
340a8b6ddafSMark J Musante 
341a8b6ddafSMark J Musante 	if (dupstr == NULL)
342a8b6ddafSMark J Musante 		nomem();
343a8b6ddafSMark J Musante 
344a8b6ddafSMark J Musante 	return (dupstr);
345a8b6ddafSMark J Musante }
346a8b6ddafSMark J Musante 
347fa9e4066Sahrens /*
348990b4856Slling  * Callback routine that will print out information for each of
34966e2aaccSgw25295  * the properties.
35066e2aaccSgw25295  */
351990b4856Slling static int
352990b4856Slling usage_prop_cb(int prop, void *cb)
35366e2aaccSgw25295 {
35466e2aaccSgw25295 	FILE *fp = cb;
35566e2aaccSgw25295 
356c5904d13Seschrock 	(void) fprintf(fp, "\t%-15s ", zfs_prop_to_name(prop));
35766e2aaccSgw25295 
358c5904d13Seschrock 	if (zfs_prop_readonly(prop))
35966e2aaccSgw25295 		(void) fprintf(fp, " NO    ");
36066e2aaccSgw25295 	else
36166e2aaccSgw25295 		(void) fprintf(fp, "YES    ");
36266e2aaccSgw25295 
36366e2aaccSgw25295 	if (zfs_prop_inheritable(prop))
36466e2aaccSgw25295 		(void) fprintf(fp, "  YES   ");
36566e2aaccSgw25295 	else
36666e2aaccSgw25295 		(void) fprintf(fp, "   NO   ");
36766e2aaccSgw25295 
36866e2aaccSgw25295 	if (zfs_prop_values(prop) == NULL)
36966e2aaccSgw25295 		(void) fprintf(fp, "-\n");
37066e2aaccSgw25295 	else
37166e2aaccSgw25295 		(void) fprintf(fp, "%s\n", zfs_prop_values(prop));
37266e2aaccSgw25295 
373990b4856Slling 	return (ZPROP_CONT);
37466e2aaccSgw25295 }
37566e2aaccSgw25295 
37666e2aaccSgw25295 /*
377fa9e4066Sahrens  * Display usage message.  If we're inside a command, display only the usage for
378fa9e4066Sahrens  * that command.  Otherwise, iterate over the entire command table and display
379fa9e4066Sahrens  * a complete usage message.
380fa9e4066Sahrens  */
381fa9e4066Sahrens static void
38299653d4eSeschrock usage(boolean_t requested)
383fa9e4066Sahrens {
384fa9e4066Sahrens 	int i;
38599653d4eSeschrock 	boolean_t show_properties = B_FALSE;
386fa9e4066Sahrens 	FILE *fp = requested ? stdout : stderr;
387fa9e4066Sahrens 
388fa9e4066Sahrens 	if (current_command == NULL) {
389fa9e4066Sahrens 
390fa9e4066Sahrens 		(void) fprintf(fp, gettext("usage: zfs command args ...\n"));
391fa9e4066Sahrens 		(void) fprintf(fp,
392fa9e4066Sahrens 		    gettext("where 'command' is one of the following:\n\n"));
393fa9e4066Sahrens 
394fa9e4066Sahrens 		for (i = 0; i < NCOMMAND; i++) {
395fa9e4066Sahrens 			if (command_table[i].name == NULL)
396fa9e4066Sahrens 				(void) fprintf(fp, "\n");
397fa9e4066Sahrens 			else
398fa9e4066Sahrens 				(void) fprintf(fp, "%s",
39965cd9f28Seschrock 				    get_usage(command_table[i].usage));
400fa9e4066Sahrens 		}
401fa9e4066Sahrens 
402fa9e4066Sahrens 		(void) fprintf(fp, gettext("\nEach dataset is of the form: "
403fa9e4066Sahrens 		    "pool/[dataset/]*dataset[@name]\n"));
404fa9e4066Sahrens 	} else {
405fa9e4066Sahrens 		(void) fprintf(fp, gettext("usage:\n"));
40665cd9f28Seschrock 		(void) fprintf(fp, "%s", get_usage(current_command->usage));
407fa9e4066Sahrens 	}
408fa9e4066Sahrens 
4095c21526aSdarrenm 	if (current_command != NULL &&
4105c21526aSdarrenm 	    (strcmp(current_command->name, "set") == 0 ||
411fa9e4066Sahrens 	    strcmp(current_command->name, "get") == 0 ||
412fa9e4066Sahrens 	    strcmp(current_command->name, "inherit") == 0 ||
4135c21526aSdarrenm 	    strcmp(current_command->name, "list") == 0))
41499653d4eSeschrock 		show_properties = B_TRUE;
415fa9e4066Sahrens 
416fa9e4066Sahrens 	if (show_properties) {
417fa9e4066Sahrens 		(void) fprintf(fp,
418fa9e4066Sahrens 		    gettext("\nThe following properties are supported:\n"));
419fa9e4066Sahrens 
420a9799022Sck153898 		(void) fprintf(fp, "\n\t%-14s %s  %s   %s\n\n",
421fa9e4066Sahrens 		    "PROPERTY", "EDIT", "INHERIT", "VALUES");
422fa9e4066Sahrens 
42366e2aaccSgw25295 		/* Iterate over all properties */
424990b4856Slling 		(void) zprop_iter(usage_prop_cb, fp, B_FALSE, B_TRUE,
425990b4856Slling 		    ZFS_TYPE_DATASET);
426fa9e4066Sahrens 
42714843421SMatthew Ahrens 		(void) fprintf(fp, "\t%-15s ", "userused@...");
42814843421SMatthew Ahrens 		(void) fprintf(fp, " NO       NO   <size>\n");
42914843421SMatthew Ahrens 		(void) fprintf(fp, "\t%-15s ", "groupused@...");
43014843421SMatthew Ahrens 		(void) fprintf(fp, " NO       NO   <size>\n");
43114843421SMatthew Ahrens 		(void) fprintf(fp, "\t%-15s ", "userquota@...");
43214843421SMatthew Ahrens 		(void) fprintf(fp, "YES       NO   <size> | none\n");
43314843421SMatthew Ahrens 		(void) fprintf(fp, "\t%-15s ", "groupquota@...");
43414843421SMatthew Ahrens 		(void) fprintf(fp, "YES       NO   <size> | none\n");
43519b94df9SMatthew Ahrens 		(void) fprintf(fp, "\t%-15s ", "written@<snap>");
43619b94df9SMatthew Ahrens 		(void) fprintf(fp, " NO       NO   <size>\n");
43714843421SMatthew Ahrens 
438fa9e4066Sahrens 		(void) fprintf(fp, gettext("\nSizes are specified in bytes "
439fa9e4066Sahrens 		    "with standard units such as K, M, G, etc.\n"));
44074e7dc98SMatthew Ahrens 		(void) fprintf(fp, gettext("\nUser-defined properties can "
441e9dbad6fSeschrock 		    "be specified by using a name containing a colon (:).\n"));
44214843421SMatthew Ahrens 		(void) fprintf(fp, gettext("\nThe {user|group}{used|quota}@ "
44314843421SMatthew Ahrens 		    "properties must be appended with\n"
44414843421SMatthew Ahrens 		    "a user or group specifier of one of these forms:\n"
44514843421SMatthew Ahrens 		    "    POSIX name      (eg: \"matt\")\n"
44614843421SMatthew Ahrens 		    "    POSIX id        (eg: \"126829\")\n"
44714843421SMatthew Ahrens 		    "    SMB name@domain (eg: \"matt@sun\")\n"
44814843421SMatthew Ahrens 		    "    SMB SID         (eg: \"S-1-234-567-89\")\n"));
4495c21526aSdarrenm 	} else {
4505c21526aSdarrenm 		(void) fprintf(fp,
451deb8317bSMark J Musante 		    gettext("\nFor the property list, run: %s\n"),
452deb8317bSMark J Musante 		    "zfs set|get");
4536949a980Smarks 		(void) fprintf(fp,
454deb8317bSMark J Musante 		    gettext("\nFor the delegated permission list, run: %s\n"),
455deb8317bSMark J Musante 		    "zfs allow|unallow");
456fa9e4066Sahrens 	}
457fa9e4066Sahrens 
458e9dbad6fSeschrock 	/*
459e9dbad6fSeschrock 	 * See comments at end of main().
460e9dbad6fSeschrock 	 */
461e9dbad6fSeschrock 	if (getenv("ZFS_ABORT") != NULL) {
462e9dbad6fSeschrock 		(void) printf("dumping core by request\n");
463e9dbad6fSeschrock 		abort();
464e9dbad6fSeschrock 	}
465e9dbad6fSeschrock 
466fa9e4066Sahrens 	exit(requested ? 0 : 2);
467fa9e4066Sahrens }
468fa9e4066Sahrens 
469bb0ade09Sahrens static int
470bb0ade09Sahrens parseprop(nvlist_t *props)
471bb0ade09Sahrens {
472bb0ade09Sahrens 	char *propname = optarg;
473bb0ade09Sahrens 	char *propval, *strval;
474bb0ade09Sahrens 
475bb0ade09Sahrens 	if ((propval = strchr(propname, '=')) == NULL) {
476bb0ade09Sahrens 		(void) fprintf(stderr, gettext("missing "
477bb0ade09Sahrens 		    "'=' for -o option\n"));
478bb0ade09Sahrens 		return (-1);
479bb0ade09Sahrens 	}
480bb0ade09Sahrens 	*propval = '\0';
481bb0ade09Sahrens 	propval++;
482bb0ade09Sahrens 	if (nvlist_lookup_string(props, propname, &strval) == 0) {
483bb0ade09Sahrens 		(void) fprintf(stderr, gettext("property '%s' "
484bb0ade09Sahrens 		    "specified multiple times\n"), propname);
485bb0ade09Sahrens 		return (-1);
486bb0ade09Sahrens 	}
487a8b6ddafSMark J Musante 	if (nvlist_add_string(props, propname, propval) != 0)
488a8b6ddafSMark J Musante 		nomem();
489bb0ade09Sahrens 	return (0);
490bb0ade09Sahrens }
491bb0ade09Sahrens 
492ae1726b6SChris Gerhard static int
493ae1726b6SChris Gerhard parse_depth(char *opt, int *flags)
494ae1726b6SChris Gerhard {
495ae1726b6SChris Gerhard 	char *tmp;
496ae1726b6SChris Gerhard 	int depth;
497ae1726b6SChris Gerhard 
498ae1726b6SChris Gerhard 	depth = (int)strtol(opt, &tmp, 0);
499ae1726b6SChris Gerhard 	if (*tmp) {
500ae1726b6SChris Gerhard 		(void) fprintf(stderr,
501ae1726b6SChris Gerhard 		    gettext("%s is not an integer\n"), optarg);
502ae1726b6SChris Gerhard 		usage(B_FALSE);
503ae1726b6SChris Gerhard 	}
504ae1726b6SChris Gerhard 	if (depth < 0) {
505ae1726b6SChris Gerhard 		(void) fprintf(stderr,
506ae1726b6SChris Gerhard 		    gettext("Depth can not be negative.\n"));
507ae1726b6SChris Gerhard 		usage(B_FALSE);
508ae1726b6SChris Gerhard 	}
509ae1726b6SChris Gerhard 	*flags |= (ZFS_ITER_DEPTH_LIMIT|ZFS_ITER_RECURSE);
510ae1726b6SChris Gerhard 	return (depth);
511ae1726b6SChris Gerhard }
512ae1726b6SChris Gerhard 
513a8b6ddafSMark J Musante #define	PROGRESS_DELAY 2		/* seconds */
514a8b6ddafSMark J Musante 
515a8b6ddafSMark J Musante static char *pt_reverse = "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b";
516a8b6ddafSMark J Musante static time_t pt_begin;
517a8b6ddafSMark J Musante static char *pt_header = NULL;
518a8b6ddafSMark J Musante static boolean_t pt_shown;
519a8b6ddafSMark J Musante 
520a8b6ddafSMark J Musante static void
521a8b6ddafSMark J Musante start_progress_timer(void)
522a8b6ddafSMark J Musante {
523a8b6ddafSMark J Musante 	pt_begin = time(NULL) + PROGRESS_DELAY;
524a8b6ddafSMark J Musante 	pt_shown = B_FALSE;
525a8b6ddafSMark J Musante }
526a8b6ddafSMark J Musante 
527a8b6ddafSMark J Musante static void
528a8b6ddafSMark J Musante set_progress_header(char *header)
529a8b6ddafSMark J Musante {
530a8b6ddafSMark J Musante 	assert(pt_header == NULL);
531a8b6ddafSMark J Musante 	pt_header = safe_strdup(header);
532a8b6ddafSMark J Musante 	if (pt_shown) {
533a8b6ddafSMark J Musante 		(void) printf("%s: ", header);
534a8b6ddafSMark J Musante 		(void) fflush(stdout);
535a8b6ddafSMark J Musante 	}
536a8b6ddafSMark J Musante }
537a8b6ddafSMark J Musante 
538a8b6ddafSMark J Musante static void
539a8b6ddafSMark J Musante update_progress(char *update)
540a8b6ddafSMark J Musante {
541a8b6ddafSMark J Musante 	if (!pt_shown && time(NULL) > pt_begin) {
542a8b6ddafSMark J Musante 		int len = strlen(update);
543a8b6ddafSMark J Musante 
544a8b6ddafSMark J Musante 		(void) printf("%s: %s%*.*s", pt_header, update, len, len,
545a8b6ddafSMark J Musante 		    pt_reverse);
546a8b6ddafSMark J Musante 		(void) fflush(stdout);
547a8b6ddafSMark J Musante 		pt_shown = B_TRUE;
548a8b6ddafSMark J Musante 	} else if (pt_shown) {
549a8b6ddafSMark J Musante 		int len = strlen(update);
550a8b6ddafSMark J Musante 
551a8b6ddafSMark J Musante 		(void) printf("%s%*.*s", update, len, len, pt_reverse);
552a8b6ddafSMark J Musante 		(void) fflush(stdout);
553a8b6ddafSMark J Musante 	}
554a8b6ddafSMark J Musante }
555a8b6ddafSMark J Musante 
556a8b6ddafSMark J Musante static void
557a8b6ddafSMark J Musante finish_progress(char *done)
558a8b6ddafSMark J Musante {
559a8b6ddafSMark J Musante 	if (pt_shown) {
560a8b6ddafSMark J Musante 		(void) printf("%s\n", done);
561a8b6ddafSMark J Musante 		(void) fflush(stdout);
562a8b6ddafSMark J Musante 	}
563a8b6ddafSMark J Musante 	free(pt_header);
564a8b6ddafSMark J Musante 	pt_header = NULL;
565a8b6ddafSMark J Musante }
566fa9e4066Sahrens /*
567bb0ade09Sahrens  * zfs clone [-p] [-o prop=value] ... <snap> <fs | vol>
568fa9e4066Sahrens  *
569fa9e4066Sahrens  * Given an existing dataset, create a writable copy whose initial contents
570fa9e4066Sahrens  * are the same as the source.  The newly created dataset maintains a
571fa9e4066Sahrens  * dependency on the original; the original cannot be destroyed so long as
572fa9e4066Sahrens  * the clone exists.
5737f1f55eaSvb160487  *
5747f1f55eaSvb160487  * The '-p' flag creates all the non-existing ancestors of the target first.
575fa9e4066Sahrens  */
576fa9e4066Sahrens static int
577fa9e4066Sahrens zfs_do_clone(int argc, char **argv)
578fa9e4066Sahrens {
579bb0ade09Sahrens 	zfs_handle_t *zhp = NULL;
5807f1f55eaSvb160487 	boolean_t parents = B_FALSE;
581bb0ade09Sahrens 	nvlist_t *props;
58205c998d6SRichard Lowe 	int ret = 0;
5837f1f55eaSvb160487 	int c;
584fa9e4066Sahrens 
585a8b6ddafSMark J Musante 	if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0)
586a8b6ddafSMark J Musante 		nomem();
587bb0ade09Sahrens 
588fa9e4066Sahrens 	/* check options */
589bb0ade09Sahrens 	while ((c = getopt(argc, argv, "o:p")) != -1) {
5907f1f55eaSvb160487 		switch (c) {
591bb0ade09Sahrens 		case 'o':
592bb0ade09Sahrens 			if (parseprop(props))
593bb0ade09Sahrens 				return (1);
594bb0ade09Sahrens 			break;
5957f1f55eaSvb160487 		case 'p':
5967f1f55eaSvb160487 			parents = B_TRUE;
5977f1f55eaSvb160487 			break;
5987f1f55eaSvb160487 		case '?':
599fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
6007f1f55eaSvb160487 			    optopt);
601bb0ade09Sahrens 			goto usage;
602fa9e4066Sahrens 		}
6037f1f55eaSvb160487 	}
6047f1f55eaSvb160487 
6057f1f55eaSvb160487 	argc -= optind;
6067f1f55eaSvb160487 	argv += optind;
607fa9e4066Sahrens 
608fa9e4066Sahrens 	/* check number of arguments */
6097f1f55eaSvb160487 	if (argc < 1) {
610fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing source dataset "
611fa9e4066Sahrens 		    "argument\n"));
612bb0ade09Sahrens 		goto usage;
613fa9e4066Sahrens 	}
6147f1f55eaSvb160487 	if (argc < 2) {
615fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing target dataset "
616fa9e4066Sahrens 		    "argument\n"));
617bb0ade09Sahrens 		goto usage;
618fa9e4066Sahrens 	}
6197f1f55eaSvb160487 	if (argc > 2) {
620fa9e4066Sahrens 		(void) fprintf(stderr, gettext("too many arguments\n"));
621bb0ade09Sahrens 		goto usage;
622fa9e4066Sahrens 	}
623fa9e4066Sahrens 
624fa9e4066Sahrens 	/* open the source dataset */
6257f1f55eaSvb160487 	if ((zhp = zfs_open(g_zfs, argv[0], ZFS_TYPE_SNAPSHOT)) == NULL)
626fa9e4066Sahrens 		return (1);
627fa9e4066Sahrens 
6287f1f55eaSvb160487 	if (parents && zfs_name_valid(argv[1], ZFS_TYPE_FILESYSTEM |
6297f1f55eaSvb160487 	    ZFS_TYPE_VOLUME)) {
6307f1f55eaSvb160487 		/*
6317f1f55eaSvb160487 		 * Now create the ancestors of the target dataset.  If the
6327f1f55eaSvb160487 		 * target already exists and '-p' option was used we should not
6337f1f55eaSvb160487 		 * complain.
6347f1f55eaSvb160487 		 */
6357f1f55eaSvb160487 		if (zfs_dataset_exists(g_zfs, argv[1], ZFS_TYPE_FILESYSTEM |
6367f1f55eaSvb160487 		    ZFS_TYPE_VOLUME))
6377f1f55eaSvb160487 			return (0);
6387f1f55eaSvb160487 		if (zfs_create_ancestors(g_zfs, argv[1]) != 0)
6397f1f55eaSvb160487 			return (1);
6407f1f55eaSvb160487 	}
6417f1f55eaSvb160487 
642fa9e4066Sahrens 	/* pass to libzfs */
643bb0ade09Sahrens 	ret = zfs_clone(zhp, argv[1], props);
644fa9e4066Sahrens 
645fa9e4066Sahrens 	/* create the mountpoint if necessary */
646fa9e4066Sahrens 	if (ret == 0) {
647990b4856Slling 		zfs_handle_t *clone;
648990b4856Slling 
649990b4856Slling 		clone = zfs_open(g_zfs, argv[1], ZFS_TYPE_DATASET);
650fa9e4066Sahrens 		if (clone != NULL) {
6519d9a58e3SEric Taylor 			if (zfs_get_type(clone) != ZFS_TYPE_VOLUME)
652fa9e4066Sahrens 				if ((ret = zfs_mount(clone, NULL, 0)) == 0)
653fa9e4066Sahrens 					ret = zfs_share(clone);
654fa9e4066Sahrens 			zfs_close(clone);
655fa9e4066Sahrens 		}
656fa9e4066Sahrens 	}
657fa9e4066Sahrens 
658fa9e4066Sahrens 	zfs_close(zhp);
659bb0ade09Sahrens 	nvlist_free(props);
660fa9e4066Sahrens 
661bb0ade09Sahrens 	return (!!ret);
662bb0ade09Sahrens 
663bb0ade09Sahrens usage:
664bb0ade09Sahrens 	if (zhp)
665bb0ade09Sahrens 		zfs_close(zhp);
666bb0ade09Sahrens 	nvlist_free(props);
667bb0ade09Sahrens 	usage(B_FALSE);
668bb0ade09Sahrens 	return (-1);
669fa9e4066Sahrens }
670fa9e4066Sahrens 
671fa9e4066Sahrens /*
6727f1f55eaSvb160487  * zfs create [-p] [-o prop=value] ... fs
6737f1f55eaSvb160487  * zfs create [-ps] [-b blocksize] [-o prop=value] ... -V vol size
674fa9e4066Sahrens  *
675fa9e4066Sahrens  * Create a new dataset.  This command can be used to create filesystems
676fa9e4066Sahrens  * and volumes.  Snapshot creation is handled by 'zfs snapshot'.
677fa9e4066Sahrens  * For volumes, the user must specify a size to be used.
678fa9e4066Sahrens  *
679fa9e4066Sahrens  * The '-s' flag applies only to volumes, and indicates that we should not try
680fa9e4066Sahrens  * to set the reservation for this volume.  By default we set a reservation
681a9b821a0Sck153898  * equal to the size for any volume.  For pools with SPA_VERSION >=
682a9b821a0Sck153898  * SPA_VERSION_REFRESERVATION, we set a refreservation instead.
6837f1f55eaSvb160487  *
6847f1f55eaSvb160487  * The '-p' flag creates all the non-existing ancestors of the target first.
685fa9e4066Sahrens  */
686fa9e4066Sahrens static int
687fa9e4066Sahrens zfs_do_create(int argc, char **argv)
688fa9e4066Sahrens {
689fa9e4066Sahrens 	zfs_type_t type = ZFS_TYPE_FILESYSTEM;
690e9dbad6fSeschrock 	zfs_handle_t *zhp = NULL;
691e9dbad6fSeschrock 	uint64_t volsize;
692fa9e4066Sahrens 	int c;
69399653d4eSeschrock 	boolean_t noreserve = B_FALSE;
6943cb34c60Sahrens 	boolean_t bflag = B_FALSE;
6957f1f55eaSvb160487 	boolean_t parents = B_FALSE;
696e9dbad6fSeschrock 	int ret = 1;
697bb0ade09Sahrens 	nvlist_t *props;
698e9dbad6fSeschrock 	uint64_t intval;
6999d9a58e3SEric Taylor 	int canmount = ZFS_CANMOUNT_OFF;
700e9dbad6fSeschrock 
701a8b6ddafSMark J Musante 	if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0)
702a8b6ddafSMark J Musante 		nomem();
703fa9e4066Sahrens 
704fa9e4066Sahrens 	/* check options */
7057f1f55eaSvb160487 	while ((c = getopt(argc, argv, ":V:b:so:p")) != -1) {
706fa9e4066Sahrens 		switch (c) {
707fa9e4066Sahrens 		case 'V':
708fa9e4066Sahrens 			type = ZFS_TYPE_VOLUME;
709e9dbad6fSeschrock 			if (zfs_nicestrtonum(g_zfs, optarg, &intval) != 0) {
710e9dbad6fSeschrock 				(void) fprintf(stderr, gettext("bad volume "
711e9dbad6fSeschrock 				    "size '%s': %s\n"), optarg,
712e9dbad6fSeschrock 				    libzfs_error_description(g_zfs));
713e9dbad6fSeschrock 				goto error;
714e9dbad6fSeschrock 			}
715e9dbad6fSeschrock 
716e9dbad6fSeschrock 			if (nvlist_add_uint64(props,
717a8b6ddafSMark J Musante 			    zfs_prop_to_name(ZFS_PROP_VOLSIZE), intval) != 0)
718a8b6ddafSMark J Musante 				nomem();
719e9dbad6fSeschrock 			volsize = intval;
720fa9e4066Sahrens 			break;
7217f1f55eaSvb160487 		case 'p':
7227f1f55eaSvb160487 			parents = B_TRUE;
7237f1f55eaSvb160487 			break;
724fa9e4066Sahrens 		case 'b':
7253cb34c60Sahrens 			bflag = B_TRUE;
726e9dbad6fSeschrock 			if (zfs_nicestrtonum(g_zfs, optarg, &intval) != 0) {
727e9dbad6fSeschrock 				(void) fprintf(stderr, gettext("bad volume "
728e9dbad6fSeschrock 				    "block size '%s': %s\n"), optarg,
729e9dbad6fSeschrock 				    libzfs_error_description(g_zfs));
730e9dbad6fSeschrock 				goto error;
731e9dbad6fSeschrock 			}
732e9dbad6fSeschrock 
733e9dbad6fSeschrock 			if (nvlist_add_uint64(props,
734e9dbad6fSeschrock 			    zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE),
735a8b6ddafSMark J Musante 			    intval) != 0)
736a8b6ddafSMark J Musante 				nomem();
737e9dbad6fSeschrock 			break;
738e9dbad6fSeschrock 		case 'o':
739bb0ade09Sahrens 			if (parseprop(props))
740e9dbad6fSeschrock 				goto error;
741fa9e4066Sahrens 			break;
742fa9e4066Sahrens 		case 's':
74399653d4eSeschrock 			noreserve = B_TRUE;
744fa9e4066Sahrens 			break;
745fa9e4066Sahrens 		case ':':
746fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing size "
747fa9e4066Sahrens 			    "argument\n"));
748e9dbad6fSeschrock 			goto badusage;
749fa9e4066Sahrens 		case '?':
750fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
751fa9e4066Sahrens 			    optopt);
752e9dbad6fSeschrock 			goto badusage;
753fa9e4066Sahrens 		}
754fa9e4066Sahrens 	}
755fa9e4066Sahrens 
7563cb34c60Sahrens 	if ((bflag || noreserve) && type != ZFS_TYPE_VOLUME) {
7573cb34c60Sahrens 		(void) fprintf(stderr, gettext("'-s' and '-b' can only be "
7583cb34c60Sahrens 		    "used when creating a volume\n"));
759e9dbad6fSeschrock 		goto badusage;
760fa9e4066Sahrens 	}
761fa9e4066Sahrens 
762fa9e4066Sahrens 	argc -= optind;
763fa9e4066Sahrens 	argv += optind;
764fa9e4066Sahrens 
765fa9e4066Sahrens 	/* check number of arguments */
766fa9e4066Sahrens 	if (argc == 0) {
767fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing %s argument\n"),
768fa9e4066Sahrens 		    zfs_type_to_name(type));
769e9dbad6fSeschrock 		goto badusage;
770fa9e4066Sahrens 	}
771fa9e4066Sahrens 	if (argc > 1) {
772fa9e4066Sahrens 		(void) fprintf(stderr, gettext("too many arguments\n"));
773e9dbad6fSeschrock 		goto badusage;
774e9dbad6fSeschrock 	}
775e9dbad6fSeschrock 
776a9b821a0Sck153898 	if (type == ZFS_TYPE_VOLUME && !noreserve) {
777a9b821a0Sck153898 		zpool_handle_t *zpool_handle;
778*c61ea566SGeorge Wilson 		nvlist_t *real_props;
779a9b821a0Sck153898 		uint64_t spa_version;
780a9b821a0Sck153898 		char *p;
781a9b821a0Sck153898 		zfs_prop_t resv_prop;
782bb0ade09Sahrens 		char *strval;
783*c61ea566SGeorge Wilson 		char msg[1024];
784a9b821a0Sck153898 
785a9b821a0Sck153898 		if (p = strchr(argv[0], '/'))
786a9b821a0Sck153898 			*p = '\0';
787a9b821a0Sck153898 		zpool_handle = zpool_open(g_zfs, argv[0]);
788a9b821a0Sck153898 		if (p != NULL)
789a9b821a0Sck153898 			*p = '/';
790a9b821a0Sck153898 		if (zpool_handle == NULL)
791a9b821a0Sck153898 			goto error;
792a9b821a0Sck153898 		spa_version = zpool_get_prop_int(zpool_handle,
793a9b821a0Sck153898 		    ZPOOL_PROP_VERSION, NULL);
794a9b821a0Sck153898 		zpool_close(zpool_handle);
795a9b821a0Sck153898 		if (spa_version >= SPA_VERSION_REFRESERVATION)
796a9b821a0Sck153898 			resv_prop = ZFS_PROP_REFRESERVATION;
797a9b821a0Sck153898 		else
798a9b821a0Sck153898 			resv_prop = ZFS_PROP_RESERVATION;
799*c61ea566SGeorge Wilson 
800*c61ea566SGeorge Wilson 		(void) snprintf(msg, sizeof (msg),
801*c61ea566SGeorge Wilson 		    gettext("cannot create '%s'"), argv[0]);
802*c61ea566SGeorge Wilson 		if (props && (real_props = zfs_valid_proplist(g_zfs, type,
803*c61ea566SGeorge Wilson 		    props, 0, NULL, msg)) == NULL)
804*c61ea566SGeorge Wilson 			goto error;
805*c61ea566SGeorge Wilson 
806*c61ea566SGeorge Wilson 		volsize = zvol_volsize_to_reservation(volsize, real_props);
807*c61ea566SGeorge Wilson 		nvlist_free(real_props);
808a9b821a0Sck153898 
809a9b821a0Sck153898 		if (nvlist_lookup_string(props, zfs_prop_to_name(resv_prop),
810e9dbad6fSeschrock 		    &strval) != 0) {
811e9dbad6fSeschrock 			if (nvlist_add_uint64(props,
812a9b821a0Sck153898 			    zfs_prop_to_name(resv_prop), volsize) != 0) {
813e9dbad6fSeschrock 				nvlist_free(props);
814a8b6ddafSMark J Musante 				nomem();
815e9dbad6fSeschrock 			}
816fa9e4066Sahrens 		}
817a9b821a0Sck153898 	}
818fa9e4066Sahrens 
8197f1f55eaSvb160487 	if (parents && zfs_name_valid(argv[0], type)) {
8207f1f55eaSvb160487 		/*
8217f1f55eaSvb160487 		 * Now create the ancestors of target dataset.  If the target
8227f1f55eaSvb160487 		 * already exists and '-p' option was used we should not
8237f1f55eaSvb160487 		 * complain.
8247f1f55eaSvb160487 		 */
8257f1f55eaSvb160487 		if (zfs_dataset_exists(g_zfs, argv[0], type)) {
8267f1f55eaSvb160487 			ret = 0;
8277f1f55eaSvb160487 			goto error;
8287f1f55eaSvb160487 		}
8297f1f55eaSvb160487 		if (zfs_create_ancestors(g_zfs, argv[0]) != 0)
8307f1f55eaSvb160487 			goto error;
8317f1f55eaSvb160487 	}
8327f1f55eaSvb160487 
833fa9e4066Sahrens 	/* pass to libzfs */
834e9dbad6fSeschrock 	if (zfs_create(g_zfs, argv[0], type, props) != 0)
835e9dbad6fSeschrock 		goto error;
836fa9e4066Sahrens 
837990b4856Slling 	if ((zhp = zfs_open(g_zfs, argv[0], ZFS_TYPE_DATASET)) == NULL)
838e9dbad6fSeschrock 		goto error;
8399d9a58e3SEric Taylor 
8409d9a58e3SEric Taylor 	ret = 0;
841a227b7f4Shs24103 	/*
842a227b7f4Shs24103 	 * if the user doesn't want the dataset automatically mounted,
843a227b7f4Shs24103 	 * then skip the mount/share step
844a227b7f4Shs24103 	 */
8459d9a58e3SEric Taylor 	if (zfs_prop_valid_for_type(ZFS_PROP_CANMOUNT, type))
846a227b7f4Shs24103 		canmount = zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT);
847fa9e4066Sahrens 
848fa9e4066Sahrens 	/*
849fa9e4066Sahrens 	 * Mount and/or share the new filesystem as appropriate.  We provide a
850fa9e4066Sahrens 	 * verbose error message to let the user know that their filesystem was
851fa9e4066Sahrens 	 * in fact created, even if we failed to mount or share it.
852fa9e4066Sahrens 	 */
853a227b7f4Shs24103 	if (canmount == ZFS_CANMOUNT_ON) {
854fa9e4066Sahrens 		if (zfs_mount(zhp, NULL, 0) != 0) {
855a227b7f4Shs24103 			(void) fprintf(stderr, gettext("filesystem "
856a227b7f4Shs24103 			    "successfully created, but not mounted\n"));
857fa9e4066Sahrens 			ret = 1;
858fa9e4066Sahrens 		} else if (zfs_share(zhp) != 0) {
859a227b7f4Shs24103 			(void) fprintf(stderr, gettext("filesystem "
860a227b7f4Shs24103 			    "successfully created, but not shared\n"));
861fa9e4066Sahrens 			ret = 1;
862a227b7f4Shs24103 		}
863fa9e4066Sahrens 	}
864fa9e4066Sahrens 
865e9dbad6fSeschrock error:
866e9dbad6fSeschrock 	if (zhp)
867fa9e4066Sahrens 		zfs_close(zhp);
868e9dbad6fSeschrock 	nvlist_free(props);
869fa9e4066Sahrens 	return (ret);
870e9dbad6fSeschrock badusage:
871e9dbad6fSeschrock 	nvlist_free(props);
872e9dbad6fSeschrock 	usage(B_FALSE);
873e9dbad6fSeschrock 	return (2);
874fa9e4066Sahrens }
875fa9e4066Sahrens 
876fa9e4066Sahrens /*
877922d9a97SChris Kirby  * zfs destroy [-rRf] <fs, vol>
878922d9a97SChris Kirby  * zfs destroy [-rRd] <snap>
879fa9e4066Sahrens  *
880fa9e4066Sahrens  *	-r	Recursively destroy all children
881fa9e4066Sahrens  *	-R	Recursively destroy all dependents, including clones
882fa9e4066Sahrens  *	-f	Force unmounting of any dependents
883842727c2SChris Kirby  *	-d	If we can't destroy now, mark for deferred destruction
884fa9e4066Sahrens  *
885fa9e4066Sahrens  * Destroys the given dataset.  By default, it will unmount any filesystems,
886fa9e4066Sahrens  * and refuse to destroy a dataset that has any dependents.  A dependent can
887fa9e4066Sahrens  * either be a child, or a clone of a child.
888fa9e4066Sahrens  */
889fa9e4066Sahrens typedef struct destroy_cbdata {
89099653d4eSeschrock 	boolean_t	cb_first;
89119b94df9SMatthew Ahrens 	boolean_t	cb_force;
89219b94df9SMatthew Ahrens 	boolean_t	cb_recurse;
89319b94df9SMatthew Ahrens 	boolean_t	cb_error;
89419b94df9SMatthew Ahrens 	boolean_t	cb_doclones;
895fa9e4066Sahrens 	zfs_handle_t	*cb_target;
896842727c2SChris Kirby 	boolean_t	cb_defer_destroy;
89719b94df9SMatthew Ahrens 	boolean_t	cb_verbose;
89819b94df9SMatthew Ahrens 	boolean_t	cb_parsable;
89919b94df9SMatthew Ahrens 	boolean_t	cb_dryrun;
90019b94df9SMatthew Ahrens 	nvlist_t	*cb_nvl;
90119b94df9SMatthew Ahrens 
90219b94df9SMatthew Ahrens 	/* first snap in contiguous run */
9034445fffbSMatthew Ahrens 	char		*cb_firstsnap;
90419b94df9SMatthew Ahrens 	/* previous snap in contiguous run */
9054445fffbSMatthew Ahrens 	char		*cb_prevsnap;
90619b94df9SMatthew Ahrens 	int64_t		cb_snapused;
90719b94df9SMatthew Ahrens 	char		*cb_snapspec;
908fa9e4066Sahrens } destroy_cbdata_t;
909fa9e4066Sahrens 
910fa9e4066Sahrens /*
911fa9e4066Sahrens  * Check for any dependents based on the '-r' or '-R' flags.
912fa9e4066Sahrens  */
913fa9e4066Sahrens static int
914fa9e4066Sahrens destroy_check_dependent(zfs_handle_t *zhp, void *data)
915fa9e4066Sahrens {
916fa9e4066Sahrens 	destroy_cbdata_t *cbp = data;
917fa9e4066Sahrens 	const char *tname = zfs_get_name(cbp->cb_target);
918fa9e4066Sahrens 	const char *name = zfs_get_name(zhp);
919fa9e4066Sahrens 
920fa9e4066Sahrens 	if (strncmp(tname, name, strlen(tname)) == 0 &&
921fa9e4066Sahrens 	    (name[strlen(tname)] == '/' || name[strlen(tname)] == '@')) {
922fa9e4066Sahrens 		/*
923fa9e4066Sahrens 		 * This is a direct descendant, not a clone somewhere else in
924fa9e4066Sahrens 		 * the hierarchy.
925fa9e4066Sahrens 		 */
926fa9e4066Sahrens 		if (cbp->cb_recurse)
927fa9e4066Sahrens 			goto out;
928fa9e4066Sahrens 
929fa9e4066Sahrens 		if (cbp->cb_first) {
930fa9e4066Sahrens 			(void) fprintf(stderr, gettext("cannot destroy '%s': "
931fa9e4066Sahrens 			    "%s has children\n"),
932fa9e4066Sahrens 			    zfs_get_name(cbp->cb_target),
933fa9e4066Sahrens 			    zfs_type_to_name(zfs_get_type(cbp->cb_target)));
934fa9e4066Sahrens 			(void) fprintf(stderr, gettext("use '-r' to destroy "
935fa9e4066Sahrens 			    "the following datasets:\n"));
93699653d4eSeschrock 			cbp->cb_first = B_FALSE;
93719b94df9SMatthew Ahrens 			cbp->cb_error = B_TRUE;
938fa9e4066Sahrens 		}
939fa9e4066Sahrens 
940fa9e4066Sahrens 		(void) fprintf(stderr, "%s\n", zfs_get_name(zhp));
941fa9e4066Sahrens 	} else {
942fa9e4066Sahrens 		/*
943fa9e4066Sahrens 		 * This is a clone.  We only want to report this if the '-r'
944fa9e4066Sahrens 		 * wasn't specified, or the target is a snapshot.
945fa9e4066Sahrens 		 */
946fa9e4066Sahrens 		if (!cbp->cb_recurse &&
947fa9e4066Sahrens 		    zfs_get_type(cbp->cb_target) != ZFS_TYPE_SNAPSHOT)
948fa9e4066Sahrens 			goto out;
949fa9e4066Sahrens 
950fa9e4066Sahrens 		if (cbp->cb_first) {
951fa9e4066Sahrens 			(void) fprintf(stderr, gettext("cannot destroy '%s': "
952fa9e4066Sahrens 			    "%s has dependent clones\n"),
953fa9e4066Sahrens 			    zfs_get_name(cbp->cb_target),
954fa9e4066Sahrens 			    zfs_type_to_name(zfs_get_type(cbp->cb_target)));
955fa9e4066Sahrens 			(void) fprintf(stderr, gettext("use '-R' to destroy "
956fa9e4066Sahrens 			    "the following datasets:\n"));
95799653d4eSeschrock 			cbp->cb_first = B_FALSE;
95819b94df9SMatthew Ahrens 			cbp->cb_error = B_TRUE;
95919b94df9SMatthew Ahrens 			cbp->cb_dryrun = B_TRUE;
960fa9e4066Sahrens 		}
961fa9e4066Sahrens 
962fa9e4066Sahrens 		(void) fprintf(stderr, "%s\n", zfs_get_name(zhp));
963fa9e4066Sahrens 	}
964fa9e4066Sahrens 
965fa9e4066Sahrens out:
966fa9e4066Sahrens 	zfs_close(zhp);
967fa9e4066Sahrens 	return (0);
968fa9e4066Sahrens }
969fa9e4066Sahrens 
970fa9e4066Sahrens static int
971fa9e4066Sahrens destroy_callback(zfs_handle_t *zhp, void *data)
972fa9e4066Sahrens {
97319b94df9SMatthew Ahrens 	destroy_cbdata_t *cb = data;
97419b94df9SMatthew Ahrens 	const char *name = zfs_get_name(zhp);
97519b94df9SMatthew Ahrens 
97619b94df9SMatthew Ahrens 	if (cb->cb_verbose) {
97719b94df9SMatthew Ahrens 		if (cb->cb_parsable) {
97819b94df9SMatthew Ahrens 			(void) printf("destroy\t%s\n", name);
97919b94df9SMatthew Ahrens 		} else if (cb->cb_dryrun) {
98019b94df9SMatthew Ahrens 			(void) printf(gettext("would destroy %s\n"),
98119b94df9SMatthew Ahrens 			    name);
98219b94df9SMatthew Ahrens 		} else {
98319b94df9SMatthew Ahrens 			(void) printf(gettext("will destroy %s\n"),
98419b94df9SMatthew Ahrens 			    name);
98519b94df9SMatthew Ahrens 		}
98619b94df9SMatthew Ahrens 	}
987fa9e4066Sahrens 
988fa9e4066Sahrens 	/*
989fa9e4066Sahrens 	 * Ignore pools (which we've already flagged as an error before getting
990681d9761SEric Taylor 	 * here).
991fa9e4066Sahrens 	 */
992fa9e4066Sahrens 	if (strchr(zfs_get_name(zhp), '/') == NULL &&
993fa9e4066Sahrens 	    zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM) {
994fa9e4066Sahrens 		zfs_close(zhp);
995fa9e4066Sahrens 		return (0);
996fa9e4066Sahrens 	}
997fa9e4066Sahrens 
99819b94df9SMatthew Ahrens 	if (!cb->cb_dryrun) {
99919b94df9SMatthew Ahrens 		if (zfs_unmount(zhp, NULL, cb->cb_force ? MS_FORCE : 0) != 0 ||
100019b94df9SMatthew Ahrens 		    zfs_destroy(zhp, cb->cb_defer_destroy) != 0) {
1001fa9e4066Sahrens 			zfs_close(zhp);
1002fa9e4066Sahrens 			return (-1);
1003fa9e4066Sahrens 		}
100419b94df9SMatthew Ahrens 	}
1005fa9e4066Sahrens 
1006fa9e4066Sahrens 	zfs_close(zhp);
1007fa9e4066Sahrens 	return (0);
1008fa9e4066Sahrens }
1009fa9e4066Sahrens 
10101d452cf5Sahrens static int
101119b94df9SMatthew Ahrens destroy_print_cb(zfs_handle_t *zhp, void *arg)
10121d452cf5Sahrens {
101319b94df9SMatthew Ahrens 	destroy_cbdata_t *cb = arg;
101419b94df9SMatthew Ahrens 	const char *name = zfs_get_name(zhp);
101519b94df9SMatthew Ahrens 	int err = 0;
10161d452cf5Sahrens 
101719b94df9SMatthew Ahrens 	if (nvlist_exists(cb->cb_nvl, name)) {
101819b94df9SMatthew Ahrens 		if (cb->cb_firstsnap == NULL)
10194445fffbSMatthew Ahrens 			cb->cb_firstsnap = strdup(name);
102019b94df9SMatthew Ahrens 		if (cb->cb_prevsnap != NULL)
10214445fffbSMatthew Ahrens 			free(cb->cb_prevsnap);
102219b94df9SMatthew Ahrens 		/* this snap continues the current range */
10234445fffbSMatthew Ahrens 		cb->cb_prevsnap = strdup(name);
10244445fffbSMatthew Ahrens 		if (cb->cb_firstsnap == NULL || cb->cb_prevsnap == NULL)
10254445fffbSMatthew Ahrens 			nomem();
102619b94df9SMatthew Ahrens 		if (cb->cb_verbose) {
102719b94df9SMatthew Ahrens 			if (cb->cb_parsable) {
102819b94df9SMatthew Ahrens 				(void) printf("destroy\t%s\n", name);
102919b94df9SMatthew Ahrens 			} else if (cb->cb_dryrun) {
103019b94df9SMatthew Ahrens 				(void) printf(gettext("would destroy %s\n"),
103119b94df9SMatthew Ahrens 				    name);
103219b94df9SMatthew Ahrens 			} else {
103319b94df9SMatthew Ahrens 				(void) printf(gettext("will destroy %s\n"),
103419b94df9SMatthew Ahrens 				    name);
103519b94df9SMatthew Ahrens 			}
103619b94df9SMatthew Ahrens 		}
103719b94df9SMatthew Ahrens 	} else if (cb->cb_firstsnap != NULL) {
103819b94df9SMatthew Ahrens 		/* end of this range */
103919b94df9SMatthew Ahrens 		uint64_t used = 0;
10404445fffbSMatthew Ahrens 		err = lzc_snaprange_space(cb->cb_firstsnap,
104119b94df9SMatthew Ahrens 		    cb->cb_prevsnap, &used);
104219b94df9SMatthew Ahrens 		cb->cb_snapused += used;
10434445fffbSMatthew Ahrens 		free(cb->cb_firstsnap);
104419b94df9SMatthew Ahrens 		cb->cb_firstsnap = NULL;
10454445fffbSMatthew Ahrens 		free(cb->cb_prevsnap);
104619b94df9SMatthew Ahrens 		cb->cb_prevsnap = NULL;
104719b94df9SMatthew Ahrens 	}
104819b94df9SMatthew Ahrens 	zfs_close(zhp);
104919b94df9SMatthew Ahrens 	return (err);
105019b94df9SMatthew Ahrens }
10511d452cf5Sahrens 
105219b94df9SMatthew Ahrens static int
105319b94df9SMatthew Ahrens destroy_print_snapshots(zfs_handle_t *fs_zhp, destroy_cbdata_t *cb)
105419b94df9SMatthew Ahrens {
105505c998d6SRichard Lowe 	int err = 0;
105619b94df9SMatthew Ahrens 	assert(cb->cb_firstsnap == NULL);
105719b94df9SMatthew Ahrens 	assert(cb->cb_prevsnap == NULL);
105819b94df9SMatthew Ahrens 	err = zfs_iter_snapshots_sorted(fs_zhp, destroy_print_cb, cb);
105919b94df9SMatthew Ahrens 	if (cb->cb_firstsnap != NULL) {
106019b94df9SMatthew Ahrens 		uint64_t used = 0;
106119b94df9SMatthew Ahrens 		if (err == 0) {
10624445fffbSMatthew Ahrens 			err = lzc_snaprange_space(cb->cb_firstsnap,
106319b94df9SMatthew Ahrens 			    cb->cb_prevsnap, &used);
106419b94df9SMatthew Ahrens 		}
106519b94df9SMatthew Ahrens 		cb->cb_snapused += used;
10664445fffbSMatthew Ahrens 		free(cb->cb_firstsnap);
106719b94df9SMatthew Ahrens 		cb->cb_firstsnap = NULL;
10684445fffbSMatthew Ahrens 		free(cb->cb_prevsnap);
106919b94df9SMatthew Ahrens 		cb->cb_prevsnap = NULL;
107019b94df9SMatthew Ahrens 	}
107119b94df9SMatthew Ahrens 	return (err);
107219b94df9SMatthew Ahrens }
107319b94df9SMatthew Ahrens 
107419b94df9SMatthew Ahrens static int
107519b94df9SMatthew Ahrens snapshot_to_nvl_cb(zfs_handle_t *zhp, void *arg)
107619b94df9SMatthew Ahrens {
107719b94df9SMatthew Ahrens 	destroy_cbdata_t *cb = arg;
107819b94df9SMatthew Ahrens 	int err = 0;
107919b94df9SMatthew Ahrens 
108019b94df9SMatthew Ahrens 	/* Check for clones. */
108165fec9f6SChristopher Siden 	if (!cb->cb_doclones && !cb->cb_defer_destroy) {
108219b94df9SMatthew Ahrens 		cb->cb_target = zhp;
108319b94df9SMatthew Ahrens 		cb->cb_first = B_TRUE;
108419b94df9SMatthew Ahrens 		err = zfs_iter_dependents(zhp, B_TRUE,
108519b94df9SMatthew Ahrens 		    destroy_check_dependent, cb);
108619b94df9SMatthew Ahrens 	}
108719b94df9SMatthew Ahrens 
108819b94df9SMatthew Ahrens 	if (err == 0) {
108919b94df9SMatthew Ahrens 		if (nvlist_add_boolean(cb->cb_nvl, zfs_get_name(zhp)))
109019b94df9SMatthew Ahrens 			nomem();
109119b94df9SMatthew Ahrens 	}
109219b94df9SMatthew Ahrens 	zfs_close(zhp);
109319b94df9SMatthew Ahrens 	return (err);
109419b94df9SMatthew Ahrens }
109519b94df9SMatthew Ahrens 
109619b94df9SMatthew Ahrens static int
109719b94df9SMatthew Ahrens gather_snapshots(zfs_handle_t *zhp, void *arg)
109819b94df9SMatthew Ahrens {
109919b94df9SMatthew Ahrens 	destroy_cbdata_t *cb = arg;
110019b94df9SMatthew Ahrens 	int err = 0;
110119b94df9SMatthew Ahrens 
110219b94df9SMatthew Ahrens 	err = zfs_iter_snapspec(zhp, cb->cb_snapspec, snapshot_to_nvl_cb, cb);
110319b94df9SMatthew Ahrens 	if (err == ENOENT)
110419b94df9SMatthew Ahrens 		err = 0;
110519b94df9SMatthew Ahrens 	if (err != 0)
110619b94df9SMatthew Ahrens 		goto out;
110719b94df9SMatthew Ahrens 
110819b94df9SMatthew Ahrens 	if (cb->cb_verbose) {
110919b94df9SMatthew Ahrens 		err = destroy_print_snapshots(zhp, cb);
111019b94df9SMatthew Ahrens 		if (err != 0)
111119b94df9SMatthew Ahrens 			goto out;
111219b94df9SMatthew Ahrens 	}
111319b94df9SMatthew Ahrens 
111419b94df9SMatthew Ahrens 	if (cb->cb_recurse)
111519b94df9SMatthew Ahrens 		err = zfs_iter_filesystems(zhp, gather_snapshots, cb);
111619b94df9SMatthew Ahrens 
111719b94df9SMatthew Ahrens out:
111819b94df9SMatthew Ahrens 	zfs_close(zhp);
111919b94df9SMatthew Ahrens 	return (err);
112019b94df9SMatthew Ahrens }
112119b94df9SMatthew Ahrens 
112219b94df9SMatthew Ahrens static int
112319b94df9SMatthew Ahrens destroy_clones(destroy_cbdata_t *cb)
112419b94df9SMatthew Ahrens {
112519b94df9SMatthew Ahrens 	nvpair_t *pair;
112619b94df9SMatthew Ahrens 	for (pair = nvlist_next_nvpair(cb->cb_nvl, NULL);
112719b94df9SMatthew Ahrens 	    pair != NULL;
112819b94df9SMatthew Ahrens 	    pair = nvlist_next_nvpair(cb->cb_nvl, pair)) {
112919b94df9SMatthew Ahrens 		zfs_handle_t *zhp = zfs_open(g_zfs, nvpair_name(pair),
113019b94df9SMatthew Ahrens 		    ZFS_TYPE_SNAPSHOT);
113119b94df9SMatthew Ahrens 		if (zhp != NULL) {
113219b94df9SMatthew Ahrens 			boolean_t defer = cb->cb_defer_destroy;
113305c998d6SRichard Lowe 			int err = 0;
113419b94df9SMatthew Ahrens 
11351d452cf5Sahrens 			/*
113619b94df9SMatthew Ahrens 			 * We can't defer destroy non-snapshots, so set it to
113719b94df9SMatthew Ahrens 			 * false while destroying the clones.
11381d452cf5Sahrens 			 */
113919b94df9SMatthew Ahrens 			cb->cb_defer_destroy = B_FALSE;
114019b94df9SMatthew Ahrens 			err = zfs_iter_dependents(zhp, B_FALSE,
114119b94df9SMatthew Ahrens 			    destroy_callback, cb);
114219b94df9SMatthew Ahrens 			cb->cb_defer_destroy = defer;
11433ccfa83cSahrens 			zfs_close(zhp);
114419b94df9SMatthew Ahrens 			if (err != 0)
114519b94df9SMatthew Ahrens 				return (err);
11463bb79becSeschrock 		}
11471d452cf5Sahrens 	}
114819b94df9SMatthew Ahrens 	return (0);
11491d452cf5Sahrens }
1150fa9e4066Sahrens 
1151fa9e4066Sahrens static int
1152fa9e4066Sahrens zfs_do_destroy(int argc, char **argv)
1153fa9e4066Sahrens {
1154fa9e4066Sahrens 	destroy_cbdata_t cb = { 0 };
1155fa9e4066Sahrens 	int c;
1156fa9e4066Sahrens 	zfs_handle_t *zhp;
115719b94df9SMatthew Ahrens 	char *at;
1158922d9a97SChris Kirby 	zfs_type_t type = ZFS_TYPE_DATASET;
1159fa9e4066Sahrens 
1160fa9e4066Sahrens 	/* check options */
116119b94df9SMatthew Ahrens 	while ((c = getopt(argc, argv, "vpndfrR")) != -1) {
1162fa9e4066Sahrens 		switch (c) {
116319b94df9SMatthew Ahrens 		case 'v':
116419b94df9SMatthew Ahrens 			cb.cb_verbose = B_TRUE;
116519b94df9SMatthew Ahrens 			break;
116619b94df9SMatthew Ahrens 		case 'p':
116719b94df9SMatthew Ahrens 			cb.cb_verbose = B_TRUE;
116819b94df9SMatthew Ahrens 			cb.cb_parsable = B_TRUE;
116919b94df9SMatthew Ahrens 			break;
117019b94df9SMatthew Ahrens 		case 'n':
117119b94df9SMatthew Ahrens 			cb.cb_dryrun = B_TRUE;
117219b94df9SMatthew Ahrens 			break;
1173842727c2SChris Kirby 		case 'd':
1174842727c2SChris Kirby 			cb.cb_defer_destroy = B_TRUE;
1175922d9a97SChris Kirby 			type = ZFS_TYPE_SNAPSHOT;
1176842727c2SChris Kirby 			break;
1177fa9e4066Sahrens 		case 'f':
117819b94df9SMatthew Ahrens 			cb.cb_force = B_TRUE;
1179fa9e4066Sahrens 			break;
1180fa9e4066Sahrens 		case 'r':
118119b94df9SMatthew Ahrens 			cb.cb_recurse = B_TRUE;
1182fa9e4066Sahrens 			break;
1183fa9e4066Sahrens 		case 'R':
118419b94df9SMatthew Ahrens 			cb.cb_recurse = B_TRUE;
118519b94df9SMatthew Ahrens 			cb.cb_doclones = B_TRUE;
1186fa9e4066Sahrens 			break;
1187fa9e4066Sahrens 		case '?':
1188fa9e4066Sahrens 		default:
1189fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
1190fa9e4066Sahrens 			    optopt);
119199653d4eSeschrock 			usage(B_FALSE);
1192fa9e4066Sahrens 		}
1193fa9e4066Sahrens 	}
1194fa9e4066Sahrens 
1195fa9e4066Sahrens 	argc -= optind;
1196fa9e4066Sahrens 	argv += optind;
1197fa9e4066Sahrens 
1198fa9e4066Sahrens 	/* check number of arguments */
1199fa9e4066Sahrens 	if (argc == 0) {
120019b94df9SMatthew Ahrens 		(void) fprintf(stderr, gettext("missing dataset argument\n"));
120199653d4eSeschrock 		usage(B_FALSE);
1202fa9e4066Sahrens 	}
1203fa9e4066Sahrens 	if (argc > 1) {
1204fa9e4066Sahrens 		(void) fprintf(stderr, gettext("too many arguments\n"));
120599653d4eSeschrock 		usage(B_FALSE);
1206fa9e4066Sahrens 	}
1207fa9e4066Sahrens 
120819b94df9SMatthew Ahrens 	at = strchr(argv[0], '@');
120919b94df9SMatthew Ahrens 	if (at != NULL) {
121005c998d6SRichard Lowe 		int err = 0;
12111d452cf5Sahrens 
121219b94df9SMatthew Ahrens 		/* Build the list of snaps to destroy in cb_nvl. */
121319b94df9SMatthew Ahrens 		if (nvlist_alloc(&cb.cb_nvl, NV_UNIQUE_NAME, 0) != 0)
121419b94df9SMatthew Ahrens 			nomem();
121519b94df9SMatthew Ahrens 
121619b94df9SMatthew Ahrens 		*at = '\0';
121719b94df9SMatthew Ahrens 		zhp = zfs_open(g_zfs, argv[0],
121819b94df9SMatthew Ahrens 		    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
121919b94df9SMatthew Ahrens 		if (zhp == NULL)
12201d452cf5Sahrens 			return (1);
12211d452cf5Sahrens 
122219b94df9SMatthew Ahrens 		cb.cb_snapspec = at + 1;
122319b94df9SMatthew Ahrens 		if (gather_snapshots(zfs_handle_dup(zhp), &cb) != 0 ||
122419b94df9SMatthew Ahrens 		    cb.cb_error) {
12253bb79becSeschrock 			zfs_close(zhp);
122619b94df9SMatthew Ahrens 			nvlist_free(cb.cb_nvl);
12273bb79becSeschrock 			return (1);
12283bb79becSeschrock 		}
12291d452cf5Sahrens 
123019b94df9SMatthew Ahrens 		if (nvlist_empty(cb.cb_nvl)) {
123119b94df9SMatthew Ahrens 			(void) fprintf(stderr, gettext("could not find any "
123219b94df9SMatthew Ahrens 			    "snapshots to destroy; check snapshot names.\n"));
12331d452cf5Sahrens 			zfs_close(zhp);
123419b94df9SMatthew Ahrens 			nvlist_free(cb.cb_nvl);
123519b94df9SMatthew Ahrens 			return (1);
12361d452cf5Sahrens 		}
12371d452cf5Sahrens 
123819b94df9SMatthew Ahrens 		if (cb.cb_verbose) {
123919b94df9SMatthew Ahrens 			char buf[16];
124019b94df9SMatthew Ahrens 			zfs_nicenum(cb.cb_snapused, buf, sizeof (buf));
124119b94df9SMatthew Ahrens 			if (cb.cb_parsable) {
124219b94df9SMatthew Ahrens 				(void) printf("reclaim\t%llu\n",
124319b94df9SMatthew Ahrens 				    cb.cb_snapused);
124419b94df9SMatthew Ahrens 			} else if (cb.cb_dryrun) {
124519b94df9SMatthew Ahrens 				(void) printf(gettext("would reclaim %s\n"),
124619b94df9SMatthew Ahrens 				    buf);
124719b94df9SMatthew Ahrens 			} else {
124819b94df9SMatthew Ahrens 				(void) printf(gettext("will reclaim %s\n"),
124919b94df9SMatthew Ahrens 				    buf);
125019b94df9SMatthew Ahrens 			}
125119b94df9SMatthew Ahrens 		}
125219b94df9SMatthew Ahrens 
125319b94df9SMatthew Ahrens 		if (!cb.cb_dryrun) {
125419b94df9SMatthew Ahrens 			if (cb.cb_doclones)
125519b94df9SMatthew Ahrens 				err = destroy_clones(&cb);
125619b94df9SMatthew Ahrens 			if (err == 0) {
125719b94df9SMatthew Ahrens 				err = zfs_destroy_snaps_nvl(zhp, cb.cb_nvl,
125819b94df9SMatthew Ahrens 				    cb.cb_defer_destroy);
125919b94df9SMatthew Ahrens 			}
126019b94df9SMatthew Ahrens 		}
126119b94df9SMatthew Ahrens 
126219b94df9SMatthew Ahrens 		zfs_close(zhp);
126319b94df9SMatthew Ahrens 		nvlist_free(cb.cb_nvl);
126419b94df9SMatthew Ahrens 		if (err != 0)
126519b94df9SMatthew Ahrens 			return (1);
126619b94df9SMatthew Ahrens 	} else {
1267fa9e4066Sahrens 		/* Open the given dataset */
1268922d9a97SChris Kirby 		if ((zhp = zfs_open(g_zfs, argv[0], type)) == NULL)
1269fa9e4066Sahrens 			return (1);
1270fa9e4066Sahrens 
1271fa9e4066Sahrens 		cb.cb_target = zhp;
1272fa9e4066Sahrens 
1273fa9e4066Sahrens 		/*
1274fa9e4066Sahrens 		 * Perform an explicit check for pools before going any further.
1275fa9e4066Sahrens 		 */
1276fa9e4066Sahrens 		if (!cb.cb_recurse && strchr(zfs_get_name(zhp), '/') == NULL &&
1277fa9e4066Sahrens 		    zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM) {
1278fa9e4066Sahrens 			(void) fprintf(stderr, gettext("cannot destroy '%s': "
1279fa9e4066Sahrens 			    "operation does not apply to pools\n"),
1280fa9e4066Sahrens 			    zfs_get_name(zhp));
1281fa9e4066Sahrens 			(void) fprintf(stderr, gettext("use 'zfs destroy -r "
1282fa9e4066Sahrens 			    "%s' to destroy all datasets in the pool\n"),
1283fa9e4066Sahrens 			    zfs_get_name(zhp));
1284fa9e4066Sahrens 			(void) fprintf(stderr, gettext("use 'zpool destroy %s' "
1285fa9e4066Sahrens 			    "to destroy the pool itself\n"), zfs_get_name(zhp));
1286fa9e4066Sahrens 			zfs_close(zhp);
1287fa9e4066Sahrens 			return (1);
1288fa9e4066Sahrens 		}
1289fa9e4066Sahrens 
1290fa9e4066Sahrens 		/*
1291fa9e4066Sahrens 		 * Check for any dependents and/or clones.
1292fa9e4066Sahrens 		 */
129399653d4eSeschrock 		cb.cb_first = B_TRUE;
129419b94df9SMatthew Ahrens 		if (!cb.cb_doclones &&
12953bb79becSeschrock 		    zfs_iter_dependents(zhp, B_TRUE, destroy_check_dependent,
12963bb79becSeschrock 		    &cb) != 0) {
12973bb79becSeschrock 			zfs_close(zhp);
12983bb79becSeschrock 			return (1);
12993bb79becSeschrock 		}
1300fa9e4066Sahrens 
130119b94df9SMatthew Ahrens 		if (cb.cb_error) {
130219b94df9SMatthew Ahrens 			zfs_close(zhp);
130319b94df9SMatthew Ahrens 			return (1);
130419b94df9SMatthew Ahrens 		}
130519b94df9SMatthew Ahrens 
130619b94df9SMatthew Ahrens 		if (zfs_iter_dependents(zhp, B_FALSE, destroy_callback,
130719b94df9SMatthew Ahrens 		    &cb) != 0) {
1308fa9e4066Sahrens 			zfs_close(zhp);
1309fa9e4066Sahrens 			return (1);
1310fa9e4066Sahrens 		}
1311fa9e4066Sahrens 
1312fa9e4066Sahrens 		/*
131319b94df9SMatthew Ahrens 		 * Do the real thing.  The callback will close the
131419b94df9SMatthew Ahrens 		 * handle regardless of whether it succeeds or not.
1315fa9e4066Sahrens 		 */
13163bb79becSeschrock 		if (destroy_callback(zhp, &cb) != 0)
1317fa9e4066Sahrens 			return (1);
131819b94df9SMatthew Ahrens 	}
13193bb79becSeschrock 
13203bb79becSeschrock 	return (0);
1321fa9e4066Sahrens }
1322fa9e4066Sahrens 
132392241e0bSTom Erickson static boolean_t
132492241e0bSTom Erickson is_recvd_column(zprop_get_cbdata_t *cbp)
132592241e0bSTom Erickson {
132692241e0bSTom Erickson 	int i;
132792241e0bSTom Erickson 	zfs_get_column_t col;
132892241e0bSTom Erickson 
132992241e0bSTom Erickson 	for (i = 0; i < ZFS_GET_NCOLS &&
133092241e0bSTom Erickson 	    (col = cbp->cb_columns[i]) != GET_COL_NONE; i++)
133192241e0bSTom Erickson 		if (col == GET_COL_RECVD)
133292241e0bSTom Erickson 			return (B_TRUE);
133392241e0bSTom Erickson 	return (B_FALSE);
133492241e0bSTom Erickson }
133592241e0bSTom Erickson 
1336fa9e4066Sahrens /*
133792241e0bSTom Erickson  * zfs get [-rHp] [-o all | field[,field]...] [-s source[,source]...]
133807ba0419Seschrock  *	< all | property[,property]... > < fs | snap | vol > ...
1339fa9e4066Sahrens  *
1340fa9e4066Sahrens  *	-r	recurse over any child datasets
1341fa9e4066Sahrens  *	-H	scripted mode.  Headers are stripped, and fields are separated
1342fa9e4066Sahrens  *		by tabs instead of spaces.
134392241e0bSTom Erickson  *	-o	Set of fields to display.  One of "name,property,value,
134492241e0bSTom Erickson  *		received,source". Default is "name,property,value,source".
134592241e0bSTom Erickson  *		"all" is an alias for all five.
1346fa9e4066Sahrens  *	-s	Set of sources to allow.  One of
134792241e0bSTom Erickson  *		"local,default,inherited,received,temporary,none".  Default is
134892241e0bSTom Erickson  *		all six.
1349fa9e4066Sahrens  *	-p	Display values in parsable (literal) format.
1350fa9e4066Sahrens  *
1351fa9e4066Sahrens  *  Prints properties for the given datasets.  The user can control which
1352fa9e4066Sahrens  *  columns to display as well as which property types to allow.
1353fa9e4066Sahrens  */
1354fa9e4066Sahrens 
1355fa9e4066Sahrens /*
1356fa9e4066Sahrens  * Invoked to display the properties for a single dataset.
1357fa9e4066Sahrens  */
1358fa9e4066Sahrens static int
1359fa9e4066Sahrens get_callback(zfs_handle_t *zhp, void *data)
1360fa9e4066Sahrens {
1361fa9e4066Sahrens 	char buf[ZFS_MAXPROPLEN];
136292241e0bSTom Erickson 	char rbuf[ZFS_MAXPROPLEN];
1363990b4856Slling 	zprop_source_t sourcetype;
1364fa9e4066Sahrens 	char source[ZFS_MAXNAMELEN];
1365990b4856Slling 	zprop_get_cbdata_t *cbp = data;
136692241e0bSTom Erickson 	nvlist_t *user_props = zfs_get_user_props(zhp);
1367990b4856Slling 	zprop_list_t *pl = cbp->cb_proplist;
1368e9dbad6fSeschrock 	nvlist_t *propval;
1369e9dbad6fSeschrock 	char *strval;
1370e9dbad6fSeschrock 	char *sourceval;
137192241e0bSTom Erickson 	boolean_t received = is_recvd_column(cbp);
1372fa9e4066Sahrens 
1373e9dbad6fSeschrock 	for (; pl != NULL; pl = pl->pl_next) {
137492241e0bSTom Erickson 		char *recvdval = NULL;
1375e9dbad6fSeschrock 		/*
1376e9dbad6fSeschrock 		 * Skip the special fake placeholder.  This will also skip over
1377e9dbad6fSeschrock 		 * the name property when 'all' is specified.
1378e9dbad6fSeschrock 		 */
1379e9dbad6fSeschrock 		if (pl->pl_prop == ZFS_PROP_NAME &&
1380e9dbad6fSeschrock 		    pl == cbp->cb_proplist)
138107ba0419Seschrock 			continue;
1382e9dbad6fSeschrock 
1383990b4856Slling 		if (pl->pl_prop != ZPROP_INVAL) {
1384e9dbad6fSeschrock 			if (zfs_prop_get(zhp, pl->pl_prop, buf,
1385e9dbad6fSeschrock 			    sizeof (buf), &sourcetype, source,
1386e9dbad6fSeschrock 			    sizeof (source),
1387e9dbad6fSeschrock 			    cbp->cb_literal) != 0) {
1388e9dbad6fSeschrock 				if (pl->pl_all)
1389e9dbad6fSeschrock 					continue;
1390b1b8ab34Slling 				if (!zfs_prop_valid_for_type(pl->pl_prop,
1391990b4856Slling 				    ZFS_TYPE_DATASET)) {
1392b1b8ab34Slling 					(void) fprintf(stderr,
1393b1b8ab34Slling 					    gettext("No such property '%s'\n"),
1394b1b8ab34Slling 					    zfs_prop_to_name(pl->pl_prop));
1395b1b8ab34Slling 					continue;
1396b1b8ab34Slling 				}
1397990b4856Slling 				sourcetype = ZPROP_SRC_NONE;
1398e9dbad6fSeschrock 				(void) strlcpy(buf, "-", sizeof (buf));
1399fa9e4066Sahrens 			}
1400fa9e4066Sahrens 
140192241e0bSTom Erickson 			if (received && (zfs_prop_get_recvd(zhp,
140292241e0bSTom Erickson 			    zfs_prop_to_name(pl->pl_prop), rbuf, sizeof (rbuf),
140392241e0bSTom Erickson 			    cbp->cb_literal) == 0))
140492241e0bSTom Erickson 				recvdval = rbuf;
140592241e0bSTom Erickson 
1406990b4856Slling 			zprop_print_one_property(zfs_get_name(zhp), cbp,
1407e9dbad6fSeschrock 			    zfs_prop_to_name(pl->pl_prop),
140892241e0bSTom Erickson 			    buf, sourcetype, source, recvdval);
140914843421SMatthew Ahrens 		} else if (zfs_prop_userquota(pl->pl_user_prop)) {
141014843421SMatthew Ahrens 			sourcetype = ZPROP_SRC_LOCAL;
141114843421SMatthew Ahrens 
141214843421SMatthew Ahrens 			if (zfs_prop_get_userquota(zhp, pl->pl_user_prop,
141314843421SMatthew Ahrens 			    buf, sizeof (buf), cbp->cb_literal) != 0) {
141414843421SMatthew Ahrens 				sourcetype = ZPROP_SRC_NONE;
141514843421SMatthew Ahrens 				(void) strlcpy(buf, "-", sizeof (buf));
141614843421SMatthew Ahrens 			}
141714843421SMatthew Ahrens 
141814843421SMatthew Ahrens 			zprop_print_one_property(zfs_get_name(zhp), cbp,
141992241e0bSTom Erickson 			    pl->pl_user_prop, buf, sourcetype, source, NULL);
142019b94df9SMatthew Ahrens 		} else if (zfs_prop_written(pl->pl_user_prop)) {
142119b94df9SMatthew Ahrens 			sourcetype = ZPROP_SRC_LOCAL;
142219b94df9SMatthew Ahrens 
142319b94df9SMatthew Ahrens 			if (zfs_prop_get_written(zhp, pl->pl_user_prop,
142419b94df9SMatthew Ahrens 			    buf, sizeof (buf), cbp->cb_literal) != 0) {
142519b94df9SMatthew Ahrens 				sourcetype = ZPROP_SRC_NONE;
142619b94df9SMatthew Ahrens 				(void) strlcpy(buf, "-", sizeof (buf));
142719b94df9SMatthew Ahrens 			}
142819b94df9SMatthew Ahrens 
142919b94df9SMatthew Ahrens 			zprop_print_one_property(zfs_get_name(zhp), cbp,
143019b94df9SMatthew Ahrens 			    pl->pl_user_prop, buf, sourcetype, source, NULL);
1431e9dbad6fSeschrock 		} else {
143292241e0bSTom Erickson 			if (nvlist_lookup_nvlist(user_props,
1433e9dbad6fSeschrock 			    pl->pl_user_prop, &propval) != 0) {
1434e9dbad6fSeschrock 				if (pl->pl_all)
1435e9dbad6fSeschrock 					continue;
1436990b4856Slling 				sourcetype = ZPROP_SRC_NONE;
1437e9dbad6fSeschrock 				strval = "-";
1438e9dbad6fSeschrock 			} else {
1439e9dbad6fSeschrock 				verify(nvlist_lookup_string(propval,
1440990b4856Slling 				    ZPROP_VALUE, &strval) == 0);
1441e9dbad6fSeschrock 				verify(nvlist_lookup_string(propval,
1442990b4856Slling 				    ZPROP_SOURCE, &sourceval) == 0);
1443e9dbad6fSeschrock 
1444e9dbad6fSeschrock 				if (strcmp(sourceval,
1445e9dbad6fSeschrock 				    zfs_get_name(zhp)) == 0) {
1446990b4856Slling 					sourcetype = ZPROP_SRC_LOCAL;
144792241e0bSTom Erickson 				} else if (strcmp(sourceval,
144892241e0bSTom Erickson 				    ZPROP_SOURCE_VAL_RECVD) == 0) {
144992241e0bSTom Erickson 					sourcetype = ZPROP_SRC_RECEIVED;
1450e9dbad6fSeschrock 				} else {
1451990b4856Slling 					sourcetype = ZPROP_SRC_INHERITED;
1452e9dbad6fSeschrock 					(void) strlcpy(source,
1453e9dbad6fSeschrock 					    sourceval, sizeof (source));
1454e9dbad6fSeschrock 				}
1455e9dbad6fSeschrock 			}
1456e9dbad6fSeschrock 
145792241e0bSTom Erickson 			if (received && (zfs_prop_get_recvd(zhp,
145892241e0bSTom Erickson 			    pl->pl_user_prop, rbuf, sizeof (rbuf),
145992241e0bSTom Erickson 			    cbp->cb_literal) == 0))
146092241e0bSTom Erickson 				recvdval = rbuf;
146192241e0bSTom Erickson 
1462990b4856Slling 			zprop_print_one_property(zfs_get_name(zhp), cbp,
1463e9dbad6fSeschrock 			    pl->pl_user_prop, strval, sourcetype,
146492241e0bSTom Erickson 			    source, recvdval);
1465e9dbad6fSeschrock 		}
1466fa9e4066Sahrens 	}
1467fa9e4066Sahrens 
1468fa9e4066Sahrens 	return (0);
1469fa9e4066Sahrens }
1470fa9e4066Sahrens 
1471fa9e4066Sahrens static int
1472fa9e4066Sahrens zfs_do_get(int argc, char **argv)
1473fa9e4066Sahrens {
1474990b4856Slling 	zprop_get_cbdata_t cb = { 0 };
14755ead3ed9SShampavman 	int i, c, flags = ZFS_ITER_ARGS_CAN_BE_PATHS;
1476441cac7aSAndrew Stormont 	int types = ZFS_TYPE_DATASET;
1477e9dbad6fSeschrock 	char *value, *fields;
147805c998d6SRichard Lowe 	int ret = 0;
1479ae1726b6SChris Gerhard 	int limit = 0;
1480990b4856Slling 	zprop_list_t fake_name = { 0 };
1481fa9e4066Sahrens 
1482fa9e4066Sahrens 	/*
1483fa9e4066Sahrens 	 * Set up default columns and sources.
1484fa9e4066Sahrens 	 */
1485990b4856Slling 	cb.cb_sources = ZPROP_SRC_ALL;
1486fa9e4066Sahrens 	cb.cb_columns[0] = GET_COL_NAME;
1487fa9e4066Sahrens 	cb.cb_columns[1] = GET_COL_PROPERTY;
1488fa9e4066Sahrens 	cb.cb_columns[2] = GET_COL_VALUE;
1489fa9e4066Sahrens 	cb.cb_columns[3] = GET_COL_SOURCE;
1490990b4856Slling 	cb.cb_type = ZFS_TYPE_DATASET;
1491fa9e4066Sahrens 
1492fa9e4066Sahrens 	/* check options */
1493441cac7aSAndrew Stormont 	while ((c = getopt(argc, argv, ":d:o:s:rt:Hp")) != -1) {
1494fa9e4066Sahrens 		switch (c) {
1495fa9e4066Sahrens 		case 'p':
149699653d4eSeschrock 			cb.cb_literal = B_TRUE;
1497fa9e4066Sahrens 			break;
1498ae1726b6SChris Gerhard 		case 'd':
1499ae1726b6SChris Gerhard 			limit = parse_depth(optarg, &flags);
1500ae1726b6SChris Gerhard 			break;
1501fa9e4066Sahrens 		case 'r':
1502d5b5bb25SRich Morris 			flags |= ZFS_ITER_RECURSE;
1503fa9e4066Sahrens 			break;
1504fa9e4066Sahrens 		case 'H':
150599653d4eSeschrock 			cb.cb_scripted = B_TRUE;
1506fa9e4066Sahrens 			break;
1507fa9e4066Sahrens 		case ':':
1508fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing argument for "
1509fa9e4066Sahrens 			    "'%c' option\n"), optopt);
151099653d4eSeschrock 			usage(B_FALSE);
1511fa9e4066Sahrens 			break;
1512fa9e4066Sahrens 		case 'o':
1513fa9e4066Sahrens 			/*
1514fa9e4066Sahrens 			 * Process the set of columns to display.  We zero out
1515fa9e4066Sahrens 			 * the structure to give us a blank slate.
1516fa9e4066Sahrens 			 */
1517fa9e4066Sahrens 			bzero(&cb.cb_columns, sizeof (cb.cb_columns));
1518fa9e4066Sahrens 			i = 0;
1519fa9e4066Sahrens 			while (*optarg != '\0') {
1520fa9e4066Sahrens 				static char *col_subopts[] =
152192241e0bSTom Erickson 				    { "name", "property", "value", "received",
152292241e0bSTom Erickson 				    "source", "all", NULL };
1523fa9e4066Sahrens 
152492241e0bSTom Erickson 				if (i == ZFS_GET_NCOLS) {
1525fa9e4066Sahrens 					(void) fprintf(stderr, gettext("too "
1526fa9e4066Sahrens 					    "many fields given to -o "
1527fa9e4066Sahrens 					    "option\n"));
152899653d4eSeschrock 					usage(B_FALSE);
1529fa9e4066Sahrens 				}
1530fa9e4066Sahrens 
1531fa9e4066Sahrens 				switch (getsubopt(&optarg, col_subopts,
1532fa9e4066Sahrens 				    &value)) {
1533fa9e4066Sahrens 				case 0:
1534fa9e4066Sahrens 					cb.cb_columns[i++] = GET_COL_NAME;
1535fa9e4066Sahrens 					break;
1536fa9e4066Sahrens 				case 1:
1537fa9e4066Sahrens 					cb.cb_columns[i++] = GET_COL_PROPERTY;
1538fa9e4066Sahrens 					break;
1539fa9e4066Sahrens 				case 2:
1540fa9e4066Sahrens 					cb.cb_columns[i++] = GET_COL_VALUE;
1541fa9e4066Sahrens 					break;
1542fa9e4066Sahrens 				case 3:
154392241e0bSTom Erickson 					cb.cb_columns[i++] = GET_COL_RECVD;
154492241e0bSTom Erickson 					flags |= ZFS_ITER_RECVD_PROPS;
154592241e0bSTom Erickson 					break;
154692241e0bSTom Erickson 				case 4:
1547fa9e4066Sahrens 					cb.cb_columns[i++] = GET_COL_SOURCE;
1548fa9e4066Sahrens 					break;
154992241e0bSTom Erickson 				case 5:
155092241e0bSTom Erickson 					if (i > 0) {
155192241e0bSTom Erickson 						(void) fprintf(stderr,
155292241e0bSTom Erickson 						    gettext("\"all\" conflicts "
155392241e0bSTom Erickson 						    "with specific fields "
155492241e0bSTom Erickson 						    "given to -o option\n"));
155592241e0bSTom Erickson 						usage(B_FALSE);
155692241e0bSTom Erickson 					}
155792241e0bSTom Erickson 					cb.cb_columns[0] = GET_COL_NAME;
155892241e0bSTom Erickson 					cb.cb_columns[1] = GET_COL_PROPERTY;
155992241e0bSTom Erickson 					cb.cb_columns[2] = GET_COL_VALUE;
156092241e0bSTom Erickson 					cb.cb_columns[3] = GET_COL_RECVD;
156192241e0bSTom Erickson 					cb.cb_columns[4] = GET_COL_SOURCE;
156292241e0bSTom Erickson 					flags |= ZFS_ITER_RECVD_PROPS;
156392241e0bSTom Erickson 					i = ZFS_GET_NCOLS;
156492241e0bSTom Erickson 					break;
1565fa9e4066Sahrens 				default:
1566fa9e4066Sahrens 					(void) fprintf(stderr,
1567fa9e4066Sahrens 					    gettext("invalid column name "
1568fa9e4066Sahrens 					    "'%s'\n"), value);
156999653d4eSeschrock 					usage(B_FALSE);
1570fa9e4066Sahrens 				}
1571fa9e4066Sahrens 			}
1572fa9e4066Sahrens 			break;
1573fa9e4066Sahrens 
1574fa9e4066Sahrens 		case 's':
1575fa9e4066Sahrens 			cb.cb_sources = 0;
1576fa9e4066Sahrens 			while (*optarg != '\0') {
1577fa9e4066Sahrens 				static char *source_subopts[] = {
1578fa9e4066Sahrens 					"local", "default", "inherited",
157992241e0bSTom Erickson 					"received", "temporary", "none",
158092241e0bSTom Erickson 					NULL };
1581fa9e4066Sahrens 
1582fa9e4066Sahrens 				switch (getsubopt(&optarg, source_subopts,
1583fa9e4066Sahrens 				    &value)) {
1584fa9e4066Sahrens 				case 0:
1585990b4856Slling 					cb.cb_sources |= ZPROP_SRC_LOCAL;
1586fa9e4066Sahrens 					break;
1587fa9e4066Sahrens 				case 1:
1588990b4856Slling 					cb.cb_sources |= ZPROP_SRC_DEFAULT;
1589fa9e4066Sahrens 					break;
1590fa9e4066Sahrens 				case 2:
1591990b4856Slling 					cb.cb_sources |= ZPROP_SRC_INHERITED;
1592fa9e4066Sahrens 					break;
1593fa9e4066Sahrens 				case 3:
159492241e0bSTom Erickson 					cb.cb_sources |= ZPROP_SRC_RECEIVED;
1595fa9e4066Sahrens 					break;
1596fa9e4066Sahrens 				case 4:
159792241e0bSTom Erickson 					cb.cb_sources |= ZPROP_SRC_TEMPORARY;
159892241e0bSTom Erickson 					break;
159992241e0bSTom Erickson 				case 5:
1600990b4856Slling 					cb.cb_sources |= ZPROP_SRC_NONE;
1601fa9e4066Sahrens 					break;
1602fa9e4066Sahrens 				default:
1603fa9e4066Sahrens 					(void) fprintf(stderr,
1604fa9e4066Sahrens 					    gettext("invalid source "
1605fa9e4066Sahrens 					    "'%s'\n"), value);
160699653d4eSeschrock 					usage(B_FALSE);
1607fa9e4066Sahrens 				}
1608fa9e4066Sahrens 			}
1609fa9e4066Sahrens 			break;
1610fa9e4066Sahrens 
1611441cac7aSAndrew Stormont 		case 't':
1612441cac7aSAndrew Stormont 			types = 0;
1613441cac7aSAndrew Stormont 			flags &= ~ZFS_ITER_PROP_LISTSNAPS;
1614441cac7aSAndrew Stormont 			while (*optarg != '\0') {
1615441cac7aSAndrew Stormont 				static char *type_subopts[] = { "filesystem",
1616441cac7aSAndrew Stormont 				    "volume", "snapshot", "all", NULL };
1617441cac7aSAndrew Stormont 
1618441cac7aSAndrew Stormont 				switch (getsubopt(&optarg, type_subopts,
1619441cac7aSAndrew Stormont 				    &value)) {
1620441cac7aSAndrew Stormont 				case 0:
1621441cac7aSAndrew Stormont 					types |= ZFS_TYPE_FILESYSTEM;
1622441cac7aSAndrew Stormont 					break;
1623441cac7aSAndrew Stormont 				case 1:
1624441cac7aSAndrew Stormont 					types |= ZFS_TYPE_VOLUME;
1625441cac7aSAndrew Stormont 					break;
1626441cac7aSAndrew Stormont 				case 2:
1627441cac7aSAndrew Stormont 					types |= ZFS_TYPE_SNAPSHOT;
1628441cac7aSAndrew Stormont 					break;
1629441cac7aSAndrew Stormont 				case 3:
1630441cac7aSAndrew Stormont 					types = ZFS_TYPE_DATASET;
1631441cac7aSAndrew Stormont 					break;
1632441cac7aSAndrew Stormont 
1633441cac7aSAndrew Stormont 				default:
1634441cac7aSAndrew Stormont 					(void) fprintf(stderr,
1635441cac7aSAndrew Stormont 					    gettext("invalid type '%s'\n"),
1636441cac7aSAndrew Stormont 					    value);
1637441cac7aSAndrew Stormont 					usage(B_FALSE);
1638441cac7aSAndrew Stormont 				}
1639441cac7aSAndrew Stormont 			}
1640441cac7aSAndrew Stormont 			break;
1641441cac7aSAndrew Stormont 
1642fa9e4066Sahrens 		case '?':
1643fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
1644fa9e4066Sahrens 			    optopt);
164599653d4eSeschrock 			usage(B_FALSE);
1646fa9e4066Sahrens 		}
1647fa9e4066Sahrens 	}
1648fa9e4066Sahrens 
1649fa9e4066Sahrens 	argc -= optind;
1650fa9e4066Sahrens 	argv += optind;
1651fa9e4066Sahrens 
1652fa9e4066Sahrens 	if (argc < 1) {
1653fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing property "
1654fa9e4066Sahrens 		    "argument\n"));
165599653d4eSeschrock 		usage(B_FALSE);
1656fa9e4066Sahrens 	}
1657fa9e4066Sahrens 
1658fa9e4066Sahrens 	fields = argv[0];
1659fa9e4066Sahrens 
1660990b4856Slling 	if (zprop_get_list(g_zfs, fields, &cb.cb_proplist, ZFS_TYPE_DATASET)
1661990b4856Slling 	    != 0)
166299653d4eSeschrock 		usage(B_FALSE);
1663fa9e4066Sahrens 
1664fa9e4066Sahrens 	argc--;
1665fa9e4066Sahrens 	argv++;
1666fa9e4066Sahrens 
1667e9dbad6fSeschrock 	/*
1668e9dbad6fSeschrock 	 * As part of zfs_expand_proplist(), we keep track of the maximum column
1669e9dbad6fSeschrock 	 * width for each property.  For the 'NAME' (and 'SOURCE') columns, we
1670e9dbad6fSeschrock 	 * need to know the maximum name length.  However, the user likely did
1671e9dbad6fSeschrock 	 * not specify 'name' as one of the properties to fetch, so we need to
1672e9dbad6fSeschrock 	 * make sure we always include at least this property for
1673e9dbad6fSeschrock 	 * print_get_headers() to work properly.
1674e9dbad6fSeschrock 	 */
1675e9dbad6fSeschrock 	if (cb.cb_proplist != NULL) {
1676e9dbad6fSeschrock 		fake_name.pl_prop = ZFS_PROP_NAME;
1677e9dbad6fSeschrock 		fake_name.pl_width = strlen(gettext("NAME"));
1678e9dbad6fSeschrock 		fake_name.pl_next = cb.cb_proplist;
1679e9dbad6fSeschrock 		cb.cb_proplist = &fake_name;
1680fa9e4066Sahrens 	}
1681fa9e4066Sahrens 
1682e9dbad6fSeschrock 	cb.cb_first = B_TRUE;
1683fa9e4066Sahrens 
1684fa9e4066Sahrens 	/* run for each object */
1685441cac7aSAndrew Stormont 	ret = zfs_for_each(argc, argv, flags, types, NULL,
1686ae1726b6SChris Gerhard 	    &cb.cb_proplist, limit, get_callback, &cb);
1687b6825278Ssjelinek 
1688e9dbad6fSeschrock 	if (cb.cb_proplist == &fake_name)
1689990b4856Slling 		zprop_free_list(fake_name.pl_next);
1690e9dbad6fSeschrock 	else
1691990b4856Slling 		zprop_free_list(cb.cb_proplist);
1692e9dbad6fSeschrock 
1693e9dbad6fSeschrock 	return (ret);
1694fa9e4066Sahrens }
1695fa9e4066Sahrens 
1696fa9e4066Sahrens /*
169792241e0bSTom Erickson  * inherit [-rS] <property> <fs|vol> ...
1698fa9e4066Sahrens  *
1699fa9e4066Sahrens  *	-r	Recurse over all children
170092241e0bSTom Erickson  *	-S	Revert to received value, if any
1701fa9e4066Sahrens  *
1702fa9e4066Sahrens  * For each dataset specified on the command line, inherit the given property
1703fa9e4066Sahrens  * from its parent.  Inheriting a property at the pool level will cause it to
1704fa9e4066Sahrens  * use the default value.  The '-r' flag will recurse over all children, and is
1705fa9e4066Sahrens  * useful for setting a property on a hierarchy-wide basis, regardless of any
1706fa9e4066Sahrens  * local modifications for each dataset.
1707fa9e4066Sahrens  */
170806eeb2adSek110237 
170992241e0bSTom Erickson typedef struct inherit_cbdata {
171092241e0bSTom Erickson 	const char *cb_propname;
171192241e0bSTom Erickson 	boolean_t cb_received;
171292241e0bSTom Erickson } inherit_cbdata_t;
171392241e0bSTom Erickson 
1714fa9e4066Sahrens static int
1715bb0ade09Sahrens inherit_recurse_cb(zfs_handle_t *zhp, void *data)
1716fa9e4066Sahrens {
171792241e0bSTom Erickson 	inherit_cbdata_t *cb = data;
171892241e0bSTom Erickson 	zfs_prop_t prop = zfs_name_to_prop(cb->cb_propname);
171906eeb2adSek110237 
1720bb0ade09Sahrens 	/*
1721bb0ade09Sahrens 	 * If we're doing it recursively, then ignore properties that
1722bb0ade09Sahrens 	 * are not valid for this type of dataset.
1723bb0ade09Sahrens 	 */
1724bb0ade09Sahrens 	if (prop != ZPROP_INVAL &&
1725bb0ade09Sahrens 	    !zfs_prop_valid_for_type(prop, zfs_get_type(zhp)))
1726bb0ade09Sahrens 		return (0);
1727bb0ade09Sahrens 
172892241e0bSTom Erickson 	return (zfs_prop_inherit(zhp, cb->cb_propname, cb->cb_received) != 0);
1729bb0ade09Sahrens }
1730bb0ade09Sahrens 
1731bb0ade09Sahrens static int
1732bb0ade09Sahrens inherit_cb(zfs_handle_t *zhp, void *data)
1733bb0ade09Sahrens {
173492241e0bSTom Erickson 	inherit_cbdata_t *cb = data;
1735bb0ade09Sahrens 
173692241e0bSTom Erickson 	return (zfs_prop_inherit(zhp, cb->cb_propname, cb->cb_received) != 0);
1737fa9e4066Sahrens }
1738fa9e4066Sahrens 
1739fa9e4066Sahrens static int
1740fa9e4066Sahrens zfs_do_inherit(int argc, char **argv)
1741fa9e4066Sahrens {
1742fa9e4066Sahrens 	int c;
1743fa9e4066Sahrens 	zfs_prop_t prop;
174492241e0bSTom Erickson 	inherit_cbdata_t cb = { 0 };
1745ecd6cf80Smarks 	char *propname;
174605c998d6SRichard Lowe 	int ret = 0;
1747d5b5bb25SRich Morris 	int flags = 0;
174892241e0bSTom Erickson 	boolean_t received = B_FALSE;
1749fa9e4066Sahrens 
1750fa9e4066Sahrens 	/* check options */
175192241e0bSTom Erickson 	while ((c = getopt(argc, argv, "rS")) != -1) {
1752fa9e4066Sahrens 		switch (c) {
1753fa9e4066Sahrens 		case 'r':
1754d5b5bb25SRich Morris 			flags |= ZFS_ITER_RECURSE;
1755fa9e4066Sahrens 			break;
175692241e0bSTom Erickson 		case 'S':
175792241e0bSTom Erickson 			received = B_TRUE;
175892241e0bSTom Erickson 			break;
1759fa9e4066Sahrens 		case '?':
1760fa9e4066Sahrens 		default:
1761fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
1762fa9e4066Sahrens 			    optopt);
176399653d4eSeschrock 			usage(B_FALSE);
1764fa9e4066Sahrens 		}
1765fa9e4066Sahrens 	}
1766fa9e4066Sahrens 
1767fa9e4066Sahrens 	argc -= optind;
1768fa9e4066Sahrens 	argv += optind;
1769fa9e4066Sahrens 
1770fa9e4066Sahrens 	/* check number of arguments */
1771fa9e4066Sahrens 	if (argc < 1) {
1772fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing property argument\n"));
177399653d4eSeschrock 		usage(B_FALSE);
1774fa9e4066Sahrens 	}
1775fa9e4066Sahrens 	if (argc < 2) {
1776fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing dataset argument\n"));
177799653d4eSeschrock 		usage(B_FALSE);
1778fa9e4066Sahrens 	}
1779fa9e4066Sahrens 
1780ecd6cf80Smarks 	propname = argv[0];
1781e9dbad6fSeschrock 	argc--;
1782e9dbad6fSeschrock 	argv++;
1783fa9e4066Sahrens 
1784990b4856Slling 	if ((prop = zfs_name_to_prop(propname)) != ZPROP_INVAL) {
1785fa9e4066Sahrens 		if (zfs_prop_readonly(prop)) {
1786e9dbad6fSeschrock 			(void) fprintf(stderr, gettext(
1787e9dbad6fSeschrock 			    "%s property is read-only\n"),
1788ecd6cf80Smarks 			    propname);
1789fa9e4066Sahrens 			return (1);
1790fa9e4066Sahrens 		}
179192241e0bSTom Erickson 		if (!zfs_prop_inheritable(prop) && !received) {
1792e9dbad6fSeschrock 			(void) fprintf(stderr, gettext("'%s' property cannot "
1793ecd6cf80Smarks 			    "be inherited\n"), propname);
1794e9dbad6fSeschrock 			if (prop == ZFS_PROP_QUOTA ||
1795a9799022Sck153898 			    prop == ZFS_PROP_RESERVATION ||
1796a9799022Sck153898 			    prop == ZFS_PROP_REFQUOTA ||
1797a9799022Sck153898 			    prop == ZFS_PROP_REFRESERVATION)
1798e9dbad6fSeschrock 				(void) fprintf(stderr, gettext("use 'zfs set "
1799ecd6cf80Smarks 				    "%s=none' to clear\n"), propname);
1800fa9e4066Sahrens 			return (1);
1801fa9e4066Sahrens 		}
1802a79992aaSTom Erickson 		if (received && (prop == ZFS_PROP_VOLSIZE ||
1803a79992aaSTom Erickson 		    prop == ZFS_PROP_VERSION)) {
1804a79992aaSTom Erickson 			(void) fprintf(stderr, gettext("'%s' property cannot "
1805a79992aaSTom Erickson 			    "be reverted to a received value\n"), propname);
1806a79992aaSTom Erickson 			return (1);
1807a79992aaSTom Erickson 		}
1808ecd6cf80Smarks 	} else if (!zfs_prop_user(propname)) {
1809ecd6cf80Smarks 		(void) fprintf(stderr, gettext("invalid property '%s'\n"),
1810ecd6cf80Smarks 		    propname);
1811e9dbad6fSeschrock 		usage(B_FALSE);
1812e9dbad6fSeschrock 	}
1813fa9e4066Sahrens 
181492241e0bSTom Erickson 	cb.cb_propname = propname;
181592241e0bSTom Erickson 	cb.cb_received = received;
181692241e0bSTom Erickson 
1817d5b5bb25SRich Morris 	if (flags & ZFS_ITER_RECURSE) {
1818d5b5bb25SRich Morris 		ret = zfs_for_each(argc, argv, flags, ZFS_TYPE_DATASET,
181992241e0bSTom Erickson 		    NULL, NULL, 0, inherit_recurse_cb, &cb);
1820bb0ade09Sahrens 	} else {
1821d5b5bb25SRich Morris 		ret = zfs_for_each(argc, argv, flags, ZFS_TYPE_DATASET,
182292241e0bSTom Erickson 		    NULL, NULL, 0, inherit_cb, &cb);
1823bb0ade09Sahrens 	}
182406eeb2adSek110237 
182506eeb2adSek110237 	return (ret);
1826fa9e4066Sahrens }
1827fa9e4066Sahrens 
1828e7437265Sahrens typedef struct upgrade_cbdata {
1829e7437265Sahrens 	uint64_t cb_numupgraded;
1830e7437265Sahrens 	uint64_t cb_numsamegraded;
1831e45ce728Sahrens 	uint64_t cb_numfailed;
1832e7437265Sahrens 	uint64_t cb_version;
1833e7437265Sahrens 	boolean_t cb_newer;
1834e7437265Sahrens 	boolean_t cb_foundone;
1835e7437265Sahrens 	char cb_lastfs[ZFS_MAXNAMELEN];
1836e7437265Sahrens } upgrade_cbdata_t;
1837e7437265Sahrens 
1838e7437265Sahrens static int
1839e7437265Sahrens same_pool(zfs_handle_t *zhp, const char *name)
1840e7437265Sahrens {
1841e7437265Sahrens 	int len1 = strcspn(name, "/@");
1842e7437265Sahrens 	const char *zhname = zfs_get_name(zhp);
1843e7437265Sahrens 	int len2 = strcspn(zhname, "/@");
1844e7437265Sahrens 
1845e7437265Sahrens 	if (len1 != len2)
1846e7437265Sahrens 		return (B_FALSE);
18472a6b87f0Sek110237 	return (strncmp(name, zhname, len1) == 0);
1848e7437265Sahrens }
1849e7437265Sahrens 
1850e7437265Sahrens static int
1851e7437265Sahrens upgrade_list_callback(zfs_handle_t *zhp, void *data)
1852e7437265Sahrens {
1853e7437265Sahrens 	upgrade_cbdata_t *cb = data;
1854e7437265Sahrens 	int version = zfs_prop_get_int(zhp, ZFS_PROP_VERSION);
1855e7437265Sahrens 
1856e7437265Sahrens 	/* list if it's old/new */
1857e7437265Sahrens 	if ((!cb->cb_newer && version < ZPL_VERSION) ||
18583cb34c60Sahrens 	    (cb->cb_newer && version > ZPL_VERSION)) {
1859e7437265Sahrens 		char *str;
1860e7437265Sahrens 		if (cb->cb_newer) {
1861e7437265Sahrens 			str = gettext("The following filesystems are "
1862e7437265Sahrens 			    "formatted using a newer software version and\n"
1863e7437265Sahrens 			    "cannot be accessed on the current system.\n\n");
1864e7437265Sahrens 		} else {
1865e7437265Sahrens 			str = gettext("The following filesystems are "
1866e7437265Sahrens 			    "out of date, and can be upgraded.  After being\n"
1867e7437265Sahrens 			    "upgraded, these filesystems (and any 'zfs send' "
1868e7437265Sahrens 			    "streams generated from\n"
1869e7437265Sahrens 			    "subsequent snapshots) will no longer be "
1870e7437265Sahrens 			    "accessible by older software versions.\n\n");
1871e7437265Sahrens 		}
1872e7437265Sahrens 
1873e7437265Sahrens 		if (!cb->cb_foundone) {
1874e7437265Sahrens 			(void) puts(str);
1875e7437265Sahrens 			(void) printf(gettext("VER  FILESYSTEM\n"));
1876e7437265Sahrens 			(void) printf(gettext("---  ------------\n"));
1877e7437265Sahrens 			cb->cb_foundone = B_TRUE;
1878e7437265Sahrens 		}
1879e7437265Sahrens 
1880e7437265Sahrens 		(void) printf("%2u   %s\n", version, zfs_get_name(zhp));
1881e7437265Sahrens 	}
1882e7437265Sahrens 
1883e7437265Sahrens 	return (0);
1884e7437265Sahrens }
1885e7437265Sahrens 
1886e7437265Sahrens static int
1887e7437265Sahrens upgrade_set_callback(zfs_handle_t *zhp, void *data)
1888e7437265Sahrens {
1889e7437265Sahrens 	upgrade_cbdata_t *cb = data;
1890e7437265Sahrens 	int version = zfs_prop_get_int(zhp, ZFS_PROP_VERSION);
18910a586ceaSMark Shellenbaum 	int needed_spa_version;
1892da6c28aaSamw 	int spa_version;
1893da6c28aaSamw 
18947b97dc1aSrm160521 	if (zfs_spa_version(zhp, &spa_version) < 0)
1895da6c28aaSamw 		return (-1);
1896da6c28aaSamw 
18970a586ceaSMark Shellenbaum 	needed_spa_version = zfs_spa_version_map(cb->cb_version);
18980a586ceaSMark Shellenbaum 
18990a586ceaSMark Shellenbaum 	if (needed_spa_version < 0)
19000a586ceaSMark Shellenbaum 		return (-1);
19010a586ceaSMark Shellenbaum 
19020a586ceaSMark Shellenbaum 	if (spa_version < needed_spa_version) {
1903da6c28aaSamw 		/* can't upgrade */
190414843421SMatthew Ahrens 		(void) printf(gettext("%s: can not be "
190514843421SMatthew Ahrens 		    "upgraded; the pool version needs to first "
190614843421SMatthew Ahrens 		    "be upgraded\nto version %d\n\n"),
19070a586ceaSMark Shellenbaum 		    zfs_get_name(zhp), needed_spa_version);
1908da6c28aaSamw 		cb->cb_numfailed++;
1909da6c28aaSamw 		return (0);
1910da6c28aaSamw 	}
1911da6c28aaSamw 
1912e7437265Sahrens 	/* upgrade */
1913e7437265Sahrens 	if (version < cb->cb_version) {
1914e7437265Sahrens 		char verstr[16];
1915e45ce728Sahrens 		(void) snprintf(verstr, sizeof (verstr),
1916e45ce728Sahrens 		    "%llu", cb->cb_version);
1917e7437265Sahrens 		if (cb->cb_lastfs[0] && !same_pool(zhp, cb->cb_lastfs)) {
1918e7437265Sahrens 			/*
1919e7437265Sahrens 			 * If they did "zfs upgrade -a", then we could
1920e7437265Sahrens 			 * be doing ioctls to different pools.  We need
19214445fffbSMatthew Ahrens 			 * to log this history once to each pool, and bypass
19224445fffbSMatthew Ahrens 			 * the normal history logging that happens in main().
1923e7437265Sahrens 			 */
19244445fffbSMatthew Ahrens 			(void) zpool_log_history(g_zfs, history_str);
19254445fffbSMatthew Ahrens 			log_history = B_FALSE;
1926e7437265Sahrens 		}
1927e7437265Sahrens 		if (zfs_prop_set(zhp, "version", verstr) == 0)
1928e7437265Sahrens 			cb->cb_numupgraded++;
1929e45ce728Sahrens 		else
1930e45ce728Sahrens 			cb->cb_numfailed++;
1931e7437265Sahrens 		(void) strcpy(cb->cb_lastfs, zfs_get_name(zhp));
1932e7437265Sahrens 	} else if (version > cb->cb_version) {
1933e7437265Sahrens 		/* can't downgrade */
1934e7437265Sahrens 		(void) printf(gettext("%s: can not be downgraded; "
1935e7437265Sahrens 		    "it is already at version %u\n"),
1936e7437265Sahrens 		    zfs_get_name(zhp), version);
1937e45ce728Sahrens 		cb->cb_numfailed++;
1938e7437265Sahrens 	} else {
1939e7437265Sahrens 		cb->cb_numsamegraded++;
1940e7437265Sahrens 	}
1941e7437265Sahrens 	return (0);
1942e7437265Sahrens }
1943e7437265Sahrens 
1944e7437265Sahrens /*
1945e7437265Sahrens  * zfs upgrade
1946e7437265Sahrens  * zfs upgrade -v
1947e7437265Sahrens  * zfs upgrade [-r] [-V <version>] <-a | filesystem>
1948e7437265Sahrens  */
1949e7437265Sahrens static int
1950e7437265Sahrens zfs_do_upgrade(int argc, char **argv)
1951e7437265Sahrens {
1952e7437265Sahrens 	boolean_t all = B_FALSE;
1953e7437265Sahrens 	boolean_t showversions = B_FALSE;
195405c998d6SRichard Lowe 	int ret = 0;
1955e7437265Sahrens 	upgrade_cbdata_t cb = { 0 };
1956e7437265Sahrens 	char c;
1957d5b5bb25SRich Morris 	int flags = ZFS_ITER_ARGS_CAN_BE_PATHS;
1958e7437265Sahrens 
1959e7437265Sahrens 	/* check options */
1960e7437265Sahrens 	while ((c = getopt(argc, argv, "rvV:a")) != -1) {
1961e7437265Sahrens 		switch (c) {
1962e7437265Sahrens 		case 'r':
1963d5b5bb25SRich Morris 			flags |= ZFS_ITER_RECURSE;
1964e7437265Sahrens 			break;
1965e7437265Sahrens 		case 'v':
1966e7437265Sahrens 			showversions = B_TRUE;
1967e7437265Sahrens 			break;
1968e7437265Sahrens 		case 'V':
1969e7437265Sahrens 			if (zfs_prop_string_to_index(ZFS_PROP_VERSION,
1970e7437265Sahrens 			    optarg, &cb.cb_version) != 0) {
1971e7437265Sahrens 				(void) fprintf(stderr,
1972e7437265Sahrens 				    gettext("invalid version %s\n"), optarg);
1973e7437265Sahrens 				usage(B_FALSE);
1974e7437265Sahrens 			}
1975e7437265Sahrens 			break;
1976e7437265Sahrens 		case 'a':
1977e7437265Sahrens 			all = B_TRUE;
1978e7437265Sahrens 			break;
1979e7437265Sahrens 		case '?':
1980e7437265Sahrens 		default:
1981e7437265Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
1982e7437265Sahrens 			    optopt);
1983e7437265Sahrens 			usage(B_FALSE);
1984e7437265Sahrens 		}
1985e7437265Sahrens 	}
1986e7437265Sahrens 
1987e7437265Sahrens 	argc -= optind;
1988e7437265Sahrens 	argv += optind;
1989e7437265Sahrens 
1990d5b5bb25SRich Morris 	if ((!all && !argc) && ((flags & ZFS_ITER_RECURSE) | cb.cb_version))
1991e7437265Sahrens 		usage(B_FALSE);
1992d5b5bb25SRich Morris 	if (showversions && (flags & ZFS_ITER_RECURSE || all ||
1993d5b5bb25SRich Morris 	    cb.cb_version || argc))
1994e7437265Sahrens 		usage(B_FALSE);
1995e7437265Sahrens 	if ((all || argc) && (showversions))
1996e7437265Sahrens 		usage(B_FALSE);
1997e7437265Sahrens 	if (all && argc)
1998e7437265Sahrens 		usage(B_FALSE);
1999e7437265Sahrens 
2000e7437265Sahrens 	if (showversions) {
2001e7437265Sahrens 		/* Show info on available versions. */
2002e7437265Sahrens 		(void) printf(gettext("The following filesystem versions are "
2003e7437265Sahrens 		    "supported:\n\n"));
2004e7437265Sahrens 		(void) printf(gettext("VER  DESCRIPTION\n"));
2005e7437265Sahrens 		(void) printf("---  -----------------------------------------"
2006e7437265Sahrens 		    "---------------\n");
2007e7437265Sahrens 		(void) printf(gettext(" 1   Initial ZFS filesystem version\n"));
2008e7437265Sahrens 		(void) printf(gettext(" 2   Enhanced directory entries\n"));
200919b94df9SMatthew Ahrens 		(void) printf(gettext(" 3   Case insensitive and filesystem "
201019b94df9SMatthew Ahrens 		    "user identifier (FUID)\n"));
201114843421SMatthew Ahrens 		(void) printf(gettext(" 4   userquota, groupquota "
201214843421SMatthew Ahrens 		    "properties\n"));
20130a586ceaSMark Shellenbaum 		(void) printf(gettext(" 5   System attributes\n"));
2014e7437265Sahrens 		(void) printf(gettext("\nFor more information on a particular "
20159a8685acSstephanie scheffler 		    "version, including supported releases,\n"));
20169a8685acSstephanie scheffler 		(void) printf("see the ZFS Administration Guide.\n\n");
2017e7437265Sahrens 		ret = 0;
2018e7437265Sahrens 	} else if (argc || all) {
2019e7437265Sahrens 		/* Upgrade filesystems */
2020e7437265Sahrens 		if (cb.cb_version == 0)
2021e7437265Sahrens 			cb.cb_version = ZPL_VERSION;
2022d5b5bb25SRich Morris 		ret = zfs_for_each(argc, argv, flags, ZFS_TYPE_FILESYSTEM,
2023ae1726b6SChris Gerhard 		    NULL, NULL, 0, upgrade_set_callback, &cb);
2024e7437265Sahrens 		(void) printf(gettext("%llu filesystems upgraded\n"),
2025e7437265Sahrens 		    cb.cb_numupgraded);
2026e7437265Sahrens 		if (cb.cb_numsamegraded) {
2027e7437265Sahrens 			(void) printf(gettext("%llu filesystems already at "
2028e7437265Sahrens 			    "this version\n"),
2029e7437265Sahrens 			    cb.cb_numsamegraded);
2030e7437265Sahrens 		}
2031e45ce728Sahrens 		if (cb.cb_numfailed != 0)
2032e7437265Sahrens 			ret = 1;
2033e7437265Sahrens 	} else {
2034e7437265Sahrens 		/* List old-version filesytems */
2035e7437265Sahrens 		boolean_t found;
2036e7437265Sahrens 		(void) printf(gettext("This system is currently running "
2037e7437265Sahrens 		    "ZFS filesystem version %llu.\n\n"), ZPL_VERSION);
2038e7437265Sahrens 
2039d5b5bb25SRich Morris 		flags |= ZFS_ITER_RECURSE;
2040d5b5bb25SRich Morris 		ret = zfs_for_each(0, NULL, flags, ZFS_TYPE_FILESYSTEM,
2041ae1726b6SChris Gerhard 		    NULL, NULL, 0, upgrade_list_callback, &cb);
2042e7437265Sahrens 
2043e7437265Sahrens 		found = cb.cb_foundone;
2044e7437265Sahrens 		cb.cb_foundone = B_FALSE;
2045e7437265Sahrens 		cb.cb_newer = B_TRUE;
2046e7437265Sahrens 
2047d5b5bb25SRich Morris 		ret = zfs_for_each(0, NULL, flags, ZFS_TYPE_FILESYSTEM,
2048ae1726b6SChris Gerhard 		    NULL, NULL, 0, upgrade_list_callback, &cb);
2049e7437265Sahrens 
2050e7437265Sahrens 		if (!cb.cb_foundone && !found) {
2051e7437265Sahrens 			(void) printf(gettext("All filesystems are "
2052e7437265Sahrens 			    "formatted with the current version.\n"));
2053e7437265Sahrens 		}
2054e7437265Sahrens 	}
2055e7437265Sahrens 
2056e7437265Sahrens 	return (ret);
2057e7437265Sahrens }
2058e7437265Sahrens 
205989f5d17bSYuri Pankov /*
206089f5d17bSYuri Pankov  * zfs userspace [-Hinp] [-o field[,...]] [-s field [-s field]...]
206189f5d17bSYuri Pankov  *               [-S field [-S field]...] [-t type[,...]] filesystem | snapshot
206289f5d17bSYuri Pankov  * zfs groupspace [-Hinp] [-o field[,...]] [-s field [-s field]...]
206389f5d17bSYuri Pankov  *                [-S field [-S field]...] [-t type[,...]] filesystem | snapshot
206489f5d17bSYuri Pankov  *
206589f5d17bSYuri Pankov  *	-H      Scripted mode; elide headers and separate columns by tabs.
206689f5d17bSYuri Pankov  *	-i	Translate SID to POSIX ID.
206789f5d17bSYuri Pankov  *	-n	Print numeric ID instead of user/group name.
206889f5d17bSYuri Pankov  *	-o      Control which fields to display.
206989f5d17bSYuri Pankov  *	-p	Use exact (parseable) numeric output.
207089f5d17bSYuri Pankov  *	-s      Specify sort columns, descending order.
207189f5d17bSYuri Pankov  *	-S      Specify sort columns, ascending order.
207289f5d17bSYuri Pankov  *	-t      Control which object types to display.
207389f5d17bSYuri Pankov  *
207489f5d17bSYuri Pankov  *	Displays space consumed by, and quotas on, each user in the specified
207589f5d17bSYuri Pankov  *	filesystem or snapshot.
207689f5d17bSYuri Pankov  */
20771af68beaSAlexander Stetsenko 
207889f5d17bSYuri Pankov /* us_field_types, us_field_hdr and us_field_names should be kept in sync */
207989f5d17bSYuri Pankov enum us_field_types {
208089f5d17bSYuri Pankov 	USFIELD_TYPE,
208189f5d17bSYuri Pankov 	USFIELD_NAME,
208289f5d17bSYuri Pankov 	USFIELD_USED,
208389f5d17bSYuri Pankov 	USFIELD_QUOTA
208489f5d17bSYuri Pankov };
208589f5d17bSYuri Pankov static char *us_field_hdr[] = { "TYPE", "NAME", "USED", "QUOTA" };
208689f5d17bSYuri Pankov static char *us_field_names[] = { "type", "name", "used", "quota" };
208789f5d17bSYuri Pankov #define	USFIELD_LAST	(sizeof (us_field_names) / sizeof (char *))
20881af68beaSAlexander Stetsenko 
208989f5d17bSYuri Pankov #define	USTYPE_PSX_GRP	(1 << 0)
209089f5d17bSYuri Pankov #define	USTYPE_PSX_USR	(1 << 1)
209189f5d17bSYuri Pankov #define	USTYPE_SMB_GRP	(1 << 2)
209289f5d17bSYuri Pankov #define	USTYPE_SMB_USR	(1 << 3)
209389f5d17bSYuri Pankov #define	USTYPE_ALL	\
209489f5d17bSYuri Pankov 	(USTYPE_PSX_GRP | USTYPE_PSX_USR | USTYPE_SMB_GRP | USTYPE_SMB_USR)
20951af68beaSAlexander Stetsenko 
209689f5d17bSYuri Pankov static int us_type_bits[] = {
209789f5d17bSYuri Pankov 	USTYPE_PSX_GRP,
209889f5d17bSYuri Pankov 	USTYPE_PSX_USR,
209989f5d17bSYuri Pankov 	USTYPE_SMB_GRP,
210089f5d17bSYuri Pankov 	USTYPE_SMB_USR,
210189f5d17bSYuri Pankov 	USTYPE_ALL
210289f5d17bSYuri Pankov };
210389f5d17bSYuri Pankov static char *us_type_names[] = { "posixgroup", "posxiuser", "smbgroup",
210489f5d17bSYuri Pankov 	"smbuser", "all" };
21051af68beaSAlexander Stetsenko 
21061af68beaSAlexander Stetsenko typedef struct us_node {
21071af68beaSAlexander Stetsenko 	nvlist_t	*usn_nvl;
21081af68beaSAlexander Stetsenko 	uu_avl_node_t	usn_avlnode;
21091af68beaSAlexander Stetsenko 	uu_list_node_t	usn_listnode;
21101af68beaSAlexander Stetsenko } us_node_t;
21111af68beaSAlexander Stetsenko 
21121af68beaSAlexander Stetsenko typedef struct us_cbdata {
21131af68beaSAlexander Stetsenko 	nvlist_t	**cb_nvlp;
21141af68beaSAlexander Stetsenko 	uu_avl_pool_t	*cb_avl_pool;
21151af68beaSAlexander Stetsenko 	uu_avl_t	*cb_avl;
21161af68beaSAlexander Stetsenko 	boolean_t	cb_numname;
21171af68beaSAlexander Stetsenko 	boolean_t	cb_nicenum;
21181af68beaSAlexander Stetsenko 	boolean_t	cb_sid2posix;
21191af68beaSAlexander Stetsenko 	zfs_userquota_prop_t cb_prop;
21201af68beaSAlexander Stetsenko 	zfs_sort_column_t *cb_sortcol;
212189f5d17bSYuri Pankov 	size_t		cb_width[USFIELD_LAST];
21221af68beaSAlexander Stetsenko } us_cbdata_t;
21231af68beaSAlexander Stetsenko 
212489f5d17bSYuri Pankov static boolean_t us_populated = B_FALSE;
212589f5d17bSYuri Pankov 
21261af68beaSAlexander Stetsenko typedef struct {
21271af68beaSAlexander Stetsenko 	zfs_sort_column_t *si_sortcol;
212889f5d17bSYuri Pankov 	boolean_t	si_numname;
21291af68beaSAlexander Stetsenko } us_sort_info_t;
21301af68beaSAlexander Stetsenko 
21311af68beaSAlexander Stetsenko static int
213289f5d17bSYuri Pankov us_field_index(char *field)
213389f5d17bSYuri Pankov {
213489f5d17bSYuri Pankov 	int i;
213589f5d17bSYuri Pankov 
213689f5d17bSYuri Pankov 	for (i = 0; i < USFIELD_LAST; i++) {
213789f5d17bSYuri Pankov 		if (strcmp(field, us_field_names[i]) == 0)
213889f5d17bSYuri Pankov 			return (i);
213989f5d17bSYuri Pankov 	}
214089f5d17bSYuri Pankov 
214189f5d17bSYuri Pankov 	return (-1);
214289f5d17bSYuri Pankov }
214389f5d17bSYuri Pankov 
214489f5d17bSYuri Pankov static int
21451af68beaSAlexander Stetsenko us_compare(const void *larg, const void *rarg, void *unused)
21461af68beaSAlexander Stetsenko {
21471af68beaSAlexander Stetsenko 	const us_node_t *l = larg;
21481af68beaSAlexander Stetsenko 	const us_node_t *r = rarg;
21491af68beaSAlexander Stetsenko 	us_sort_info_t *si = (us_sort_info_t *)unused;
21501af68beaSAlexander Stetsenko 	zfs_sort_column_t *sortcol = si->si_sortcol;
215189f5d17bSYuri Pankov 	boolean_t numname = si->si_numname;
21521af68beaSAlexander Stetsenko 	nvlist_t *lnvl = l->usn_nvl;
21531af68beaSAlexander Stetsenko 	nvlist_t *rnvl = r->usn_nvl;
215489f5d17bSYuri Pankov 	int rc = 0;
215589f5d17bSYuri Pankov 	boolean_t lvb, rvb;
21561af68beaSAlexander Stetsenko 
21571af68beaSAlexander Stetsenko 	for (; sortcol != NULL; sortcol = sortcol->sc_next) {
21581af68beaSAlexander Stetsenko 		char *lvstr = "";
21591af68beaSAlexander Stetsenko 		char *rvstr = "";
21601af68beaSAlexander Stetsenko 		uint32_t lv32 = 0;
21611af68beaSAlexander Stetsenko 		uint32_t rv32 = 0;
21621af68beaSAlexander Stetsenko 		uint64_t lv64 = 0;
21631af68beaSAlexander Stetsenko 		uint64_t rv64 = 0;
21641af68beaSAlexander Stetsenko 		zfs_prop_t prop = sortcol->sc_prop;
21651af68beaSAlexander Stetsenko 		const char *propname = NULL;
21661af68beaSAlexander Stetsenko 		boolean_t reverse = sortcol->sc_reverse;
21671af68beaSAlexander Stetsenko 
21681af68beaSAlexander Stetsenko 		switch (prop) {
21691af68beaSAlexander Stetsenko 		case ZFS_PROP_TYPE:
21701af68beaSAlexander Stetsenko 			propname = "type";
21711af68beaSAlexander Stetsenko 			(void) nvlist_lookup_uint32(lnvl, propname, &lv32);
21721af68beaSAlexander Stetsenko 			(void) nvlist_lookup_uint32(rnvl, propname, &rv32);
21731af68beaSAlexander Stetsenko 			if (rv32 != lv32)
217489f5d17bSYuri Pankov 				rc = (rv32 < lv32) ? 1 : -1;
21751af68beaSAlexander Stetsenko 			break;
21761af68beaSAlexander Stetsenko 		case ZFS_PROP_NAME:
21771af68beaSAlexander Stetsenko 			propname = "name";
217889f5d17bSYuri Pankov 			if (numname) {
217989f5d17bSYuri Pankov 				(void) nvlist_lookup_uint64(lnvl, propname,
218089f5d17bSYuri Pankov 				    &lv64);
218189f5d17bSYuri Pankov 				(void) nvlist_lookup_uint64(rnvl, propname,
218289f5d17bSYuri Pankov 				    &rv64);
218389f5d17bSYuri Pankov 				if (rv64 != lv64)
218489f5d17bSYuri Pankov 					rc = (rv64 < lv64) ? 1 : -1;
21851af68beaSAlexander Stetsenko 			} else {
21861af68beaSAlexander Stetsenko 				(void) nvlist_lookup_string(lnvl, propname,
21871af68beaSAlexander Stetsenko 				    &lvstr);
21881af68beaSAlexander Stetsenko 				(void) nvlist_lookup_string(rnvl, propname,
21891af68beaSAlexander Stetsenko 				    &rvstr);
21901af68beaSAlexander Stetsenko 				rc = strcmp(lvstr, rvstr);
21911af68beaSAlexander Stetsenko 			}
21921af68beaSAlexander Stetsenko 			break;
21931af68beaSAlexander Stetsenko 		case ZFS_PROP_USED:
21941af68beaSAlexander Stetsenko 		case ZFS_PROP_QUOTA:
219589f5d17bSYuri Pankov 			if (!us_populated)
219689f5d17bSYuri Pankov 				break;
219789f5d17bSYuri Pankov 			if (prop == ZFS_PROP_USED)
21981af68beaSAlexander Stetsenko 				propname = "used";
21991af68beaSAlexander Stetsenko 			else
22001af68beaSAlexander Stetsenko 				propname = "quota";
22011af68beaSAlexander Stetsenko 			(void) nvlist_lookup_uint64(lnvl, propname, &lv64);
22021af68beaSAlexander Stetsenko 			(void) nvlist_lookup_uint64(rnvl, propname, &rv64);
22031af68beaSAlexander Stetsenko 			if (rv64 != lv64)
220489f5d17bSYuri Pankov 				rc = (rv64 < lv64) ? 1 : -1;
220589f5d17bSYuri Pankov 			break;
22061af68beaSAlexander Stetsenko 		}
22071af68beaSAlexander Stetsenko 
220889f5d17bSYuri Pankov 		if (rc != 0) {
22091af68beaSAlexander Stetsenko 			if (rc < 0)
22101af68beaSAlexander Stetsenko 				return (reverse ? 1 : -1);
22111af68beaSAlexander Stetsenko 			else
22121af68beaSAlexander Stetsenko 				return (reverse ? -1 : 1);
22131af68beaSAlexander Stetsenko 		}
221489f5d17bSYuri Pankov 	}
22151af68beaSAlexander Stetsenko 
221689f5d17bSYuri Pankov 	/*
221789f5d17bSYuri Pankov 	 * If entries still seem to be the same, check if they are of the same
221889f5d17bSYuri Pankov 	 * type (smbentity is added only if we are doing SID to POSIX ID
221989f5d17bSYuri Pankov 	 * translation where we can have duplicate type/name combinations).
222089f5d17bSYuri Pankov 	 */
222189f5d17bSYuri Pankov 	if (nvlist_lookup_boolean_value(lnvl, "smbentity", &lvb) == 0 &&
222289f5d17bSYuri Pankov 	    nvlist_lookup_boolean_value(rnvl, "smbentity", &rvb) == 0 &&
222389f5d17bSYuri Pankov 	    lvb != rvb)
222489f5d17bSYuri Pankov 		return (lvb < rvb ? -1 : 1);
222589f5d17bSYuri Pankov 
222689f5d17bSYuri Pankov 	return (0);
22271af68beaSAlexander Stetsenko }
22281af68beaSAlexander Stetsenko 
22291af68beaSAlexander Stetsenko static inline const char *
22301af68beaSAlexander Stetsenko us_type2str(unsigned field_type)
22311af68beaSAlexander Stetsenko {
22321af68beaSAlexander Stetsenko 	switch (field_type) {
22331af68beaSAlexander Stetsenko 	case USTYPE_PSX_USR:
22341af68beaSAlexander Stetsenko 		return ("POSIX User");
22351af68beaSAlexander Stetsenko 	case USTYPE_PSX_GRP:
22361af68beaSAlexander Stetsenko 		return ("POSIX Group");
22371af68beaSAlexander Stetsenko 	case USTYPE_SMB_USR:
22381af68beaSAlexander Stetsenko 		return ("SMB User");
22391af68beaSAlexander Stetsenko 	case USTYPE_SMB_GRP:
22401af68beaSAlexander Stetsenko 		return ("SMB Group");
22411af68beaSAlexander Stetsenko 	default:
22421af68beaSAlexander Stetsenko 		return ("Undefined");
22431af68beaSAlexander Stetsenko 	}
22441af68beaSAlexander Stetsenko }
22451af68beaSAlexander Stetsenko 
22460aea4b19SMatthew Ahrens static int
224714843421SMatthew Ahrens userspace_cb(void *arg, const char *domain, uid_t rid, uint64_t space)
224814843421SMatthew Ahrens {
22491af68beaSAlexander Stetsenko 	us_cbdata_t *cb = (us_cbdata_t *)arg;
22501af68beaSAlexander Stetsenko 	zfs_userquota_prop_t prop = cb->cb_prop;
22510aea4b19SMatthew Ahrens 	char *name = NULL;
22521af68beaSAlexander Stetsenko 	char *propname;
225314843421SMatthew Ahrens 	char sizebuf[32];
22541af68beaSAlexander Stetsenko 	us_node_t *node;
22551af68beaSAlexander Stetsenko 	uu_avl_pool_t *avl_pool = cb->cb_avl_pool;
22561af68beaSAlexander Stetsenko 	uu_avl_t *avl = cb->cb_avl;
22571af68beaSAlexander Stetsenko 	uu_avl_index_t idx;
22581af68beaSAlexander Stetsenko 	nvlist_t *props;
22591af68beaSAlexander Stetsenko 	us_node_t *n;
22601af68beaSAlexander Stetsenko 	zfs_sort_column_t *sortcol = cb->cb_sortcol;
22611af68beaSAlexander Stetsenko 	unsigned type;
22621af68beaSAlexander Stetsenko 	const char *typestr;
22631af68beaSAlexander Stetsenko 	size_t namelen;
22641af68beaSAlexander Stetsenko 	size_t typelen;
22651af68beaSAlexander Stetsenko 	size_t sizelen;
226689f5d17bSYuri Pankov 	int typeidx, nameidx, sizeidx;
22671af68beaSAlexander Stetsenko 	us_sort_info_t sortinfo = { sortcol, cb->cb_numname };
226889f5d17bSYuri Pankov 	boolean_t smbentity = B_FALSE;
226914843421SMatthew Ahrens 
227089f5d17bSYuri Pankov 	if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0)
227189f5d17bSYuri Pankov 		nomem();
227289f5d17bSYuri Pankov 	node = safe_malloc(sizeof (us_node_t));
227389f5d17bSYuri Pankov 	uu_avl_node_init(node, &node->usn_avlnode, avl_pool);
227489f5d17bSYuri Pankov 	node->usn_nvl = props;
227589f5d17bSYuri Pankov 
227689f5d17bSYuri Pankov 	if (domain != NULL && domain[0] != '\0') {
227789f5d17bSYuri Pankov 		/* SMB */
22781af68beaSAlexander Stetsenko 		char sid[ZFS_MAXNAMELEN + 32];
22791af68beaSAlexander Stetsenko 		uid_t id;
22801af68beaSAlexander Stetsenko 		uint64_t classes;
228189f5d17bSYuri Pankov 		int err;
22821af68beaSAlexander Stetsenko 		directory_error_t e;
22831af68beaSAlexander Stetsenko 
228489f5d17bSYuri Pankov 		smbentity = B_TRUE;
228589f5d17bSYuri Pankov 
22861af68beaSAlexander Stetsenko 		(void) snprintf(sid, sizeof (sid), "%s-%u", domain, rid);
228789f5d17bSYuri Pankov 
22881af68beaSAlexander Stetsenko 		if (prop == ZFS_PROP_GROUPUSED || prop == ZFS_PROP_GROUPQUOTA) {
22891af68beaSAlexander Stetsenko 			type = USTYPE_SMB_GRP;
22901af68beaSAlexander Stetsenko 			err = sid_to_id(sid, B_FALSE, &id);
22911af68beaSAlexander Stetsenko 		} else {
22921af68beaSAlexander Stetsenko 			type = USTYPE_SMB_USR;
22931af68beaSAlexander Stetsenko 			err = sid_to_id(sid, B_TRUE, &id);
229414843421SMatthew Ahrens 		}
229514843421SMatthew Ahrens 
22961af68beaSAlexander Stetsenko 		if (err == 0) {
22971af68beaSAlexander Stetsenko 			rid = id;
229889f5d17bSYuri Pankov 			if (!cb->cb_sid2posix) {
229989f5d17bSYuri Pankov 				e = directory_name_from_sid(NULL, sid, &name,
230089f5d17bSYuri Pankov 				    &classes);
230170f56fa6SYuri Pankov 				if (e != NULL)
23021af68beaSAlexander Stetsenko 					directory_error_free(e);
23031af68beaSAlexander Stetsenko 				if (name == NULL)
23041af68beaSAlexander Stetsenko 					name = sid;
23051af68beaSAlexander Stetsenko 			}
23061af68beaSAlexander Stetsenko 		}
23071af68beaSAlexander Stetsenko 	}
23081af68beaSAlexander Stetsenko 
230989f5d17bSYuri Pankov 	if (cb->cb_sid2posix || domain == NULL || domain[0] == '\0') {
231089f5d17bSYuri Pankov 		/* POSIX or -i */
231189f5d17bSYuri Pankov 		if (prop == ZFS_PROP_GROUPUSED || prop == ZFS_PROP_GROUPQUOTA) {
231289f5d17bSYuri Pankov 			type = USTYPE_PSX_GRP;
231389f5d17bSYuri Pankov 			if (!cb->cb_numname) {
231489f5d17bSYuri Pankov 				struct group *g;
231589f5d17bSYuri Pankov 
231689f5d17bSYuri Pankov 				if ((g = getgrgid(rid)) != NULL)
231789f5d17bSYuri Pankov 					name = g->gr_name;
231889f5d17bSYuri Pankov 			}
231989f5d17bSYuri Pankov 		} else {
232089f5d17bSYuri Pankov 			type = USTYPE_PSX_USR;
232189f5d17bSYuri Pankov 			if (!cb->cb_numname) {
232289f5d17bSYuri Pankov 				struct passwd *p;
232389f5d17bSYuri Pankov 
232489f5d17bSYuri Pankov 				if ((p = getpwuid(rid)) != NULL)
232589f5d17bSYuri Pankov 					name = p->pw_name;
232689f5d17bSYuri Pankov 			}
232789f5d17bSYuri Pankov 		}
232889f5d17bSYuri Pankov 	}
232989f5d17bSYuri Pankov 
233089f5d17bSYuri Pankov 	/*
233189f5d17bSYuri Pankov 	 * Make sure that the type/name combination is unique when doing
233289f5d17bSYuri Pankov 	 * SID to POSIX ID translation (hence changing the type from SMB to
233389f5d17bSYuri Pankov 	 * POSIX).
233489f5d17bSYuri Pankov 	 */
233589f5d17bSYuri Pankov 	if (cb->cb_sid2posix &&
233689f5d17bSYuri Pankov 	    nvlist_add_boolean_value(props, "smbentity", smbentity) != 0)
233789f5d17bSYuri Pankov 		nomem();
233889f5d17bSYuri Pankov 
233989f5d17bSYuri Pankov 	/* Calculate/update width of TYPE field */
234089f5d17bSYuri Pankov 	typestr = us_type2str(type);
234189f5d17bSYuri Pankov 	typelen = strlen(gettext(typestr));
234289f5d17bSYuri Pankov 	typeidx = us_field_index("type");
234389f5d17bSYuri Pankov 	if (typelen > cb->cb_width[typeidx])
234489f5d17bSYuri Pankov 		cb->cb_width[typeidx] = typelen;
23451af68beaSAlexander Stetsenko 	if (nvlist_add_uint32(props, "type", type) != 0)
23461af68beaSAlexander Stetsenko 		nomem();
23471af68beaSAlexander Stetsenko 
234889f5d17bSYuri Pankov 	/* Calculate/update width of NAME field */
234989f5d17bSYuri Pankov 	if ((cb->cb_numname && cb->cb_sid2posix) || name == NULL) {
235089f5d17bSYuri Pankov 		if (nvlist_add_uint64(props, "name", rid) != 0)
23511af68beaSAlexander Stetsenko 			nomem();
235289f5d17bSYuri Pankov 		namelen = snprintf(NULL, 0, "%u", rid);
23531af68beaSAlexander Stetsenko 	} else {
23541af68beaSAlexander Stetsenko 		if (nvlist_add_string(props, "name", name) != 0)
23551af68beaSAlexander Stetsenko 			nomem();
23561af68beaSAlexander Stetsenko 		namelen = strlen(name);
23571af68beaSAlexander Stetsenko 	}
235889f5d17bSYuri Pankov 	nameidx = us_field_index("name");
235989f5d17bSYuri Pankov 	if (namelen > cb->cb_width[nameidx])
236089f5d17bSYuri Pankov 		cb->cb_width[nameidx] = namelen;
23611af68beaSAlexander Stetsenko 
236289f5d17bSYuri Pankov 	/*
236389f5d17bSYuri Pankov 	 * Check if this type/name combination is in the list and update it;
236489f5d17bSYuri Pankov 	 * otherwise add new node to the list.
236589f5d17bSYuri Pankov 	 */
236689f5d17bSYuri Pankov 	if ((n = uu_avl_find(avl, node, &sortinfo, &idx)) == NULL) {
23671af68beaSAlexander Stetsenko 		uu_avl_insert(avl, node, idx);
236889f5d17bSYuri Pankov 	} else {
23691af68beaSAlexander Stetsenko 		nvlist_free(props);
23701af68beaSAlexander Stetsenko 		free(node);
23711af68beaSAlexander Stetsenko 		node = n;
23721af68beaSAlexander Stetsenko 		props = node->usn_nvl;
23731af68beaSAlexander Stetsenko 	}
23741af68beaSAlexander Stetsenko 
237589f5d17bSYuri Pankov 	/* Calculate/update width of USED/QUOTA fields */
237689f5d17bSYuri Pankov 	if (cb->cb_nicenum)
237789f5d17bSYuri Pankov 		zfs_nicenum(space, sizebuf, sizeof (sizebuf));
237889f5d17bSYuri Pankov 	else
237989f5d17bSYuri Pankov 		(void) snprintf(sizebuf, sizeof (sizebuf), "%llu", space);
238089f5d17bSYuri Pankov 	sizelen = strlen(sizebuf);
238189f5d17bSYuri Pankov 	if (prop == ZFS_PROP_USERUSED || prop == ZFS_PROP_GROUPUSED) {
238289f5d17bSYuri Pankov 		propname = "used";
238389f5d17bSYuri Pankov 		if (!nvlist_exists(props, "quota"))
238489f5d17bSYuri Pankov 			(void) nvlist_add_uint64(props, "quota", 0);
238589f5d17bSYuri Pankov 	} else {
238689f5d17bSYuri Pankov 		propname = "quota";
238789f5d17bSYuri Pankov 		if (!nvlist_exists(props, "used"))
238889f5d17bSYuri Pankov 			(void) nvlist_add_uint64(props, "used", 0);
238989f5d17bSYuri Pankov 	}
239089f5d17bSYuri Pankov 	sizeidx = us_field_index(propname);
239189f5d17bSYuri Pankov 	if (sizelen > cb->cb_width[sizeidx])
239289f5d17bSYuri Pankov 		cb->cb_width[sizeidx] = sizelen;
239389f5d17bSYuri Pankov 
23941af68beaSAlexander Stetsenko 	if (nvlist_add_uint64(props, propname, space) != 0)
23951af68beaSAlexander Stetsenko 		nomem();
23960aea4b19SMatthew Ahrens 
23970aea4b19SMatthew Ahrens 	return (0);
239814843421SMatthew Ahrens }
239914843421SMatthew Ahrens 
24001af68beaSAlexander Stetsenko static void
240189f5d17bSYuri Pankov print_us_node(boolean_t scripted, boolean_t parsable, int *fields, int types,
240289f5d17bSYuri Pankov     size_t *width, us_node_t *node)
24031af68beaSAlexander Stetsenko {
24041af68beaSAlexander Stetsenko 	nvlist_t *nvl = node->usn_nvl;
24051af68beaSAlexander Stetsenko 	char valstr[ZFS_MAXNAMELEN];
24061af68beaSAlexander Stetsenko 	boolean_t first = B_TRUE;
240789f5d17bSYuri Pankov 	int cfield = 0;
240889f5d17bSYuri Pankov 	int field;
240989f5d17bSYuri Pankov 	uint32_t ustype;
24101af68beaSAlexander Stetsenko 
241189f5d17bSYuri Pankov 	/* Check type */
241289f5d17bSYuri Pankov 	(void) nvlist_lookup_uint32(nvl, "type", &ustype);
241389f5d17bSYuri Pankov 	if (!(ustype & types))
241489f5d17bSYuri Pankov 		return;
241589f5d17bSYuri Pankov 
241689f5d17bSYuri Pankov 	while ((field = fields[cfield]) != USFIELD_LAST) {
241789f5d17bSYuri Pankov 		nvpair_t *nvp = NULL;
241889f5d17bSYuri Pankov 		data_type_t type;
241989f5d17bSYuri Pankov 		uint32_t val32;
242089f5d17bSYuri Pankov 		uint64_t val64;
242189f5d17bSYuri Pankov 		char *strval = NULL;
24221af68beaSAlexander Stetsenko 
24231af68beaSAlexander Stetsenko 		while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
242489f5d17bSYuri Pankov 			if (strcmp(nvpair_name(nvp),
242589f5d17bSYuri Pankov 			    us_field_names[field]) == 0)
24261af68beaSAlexander Stetsenko 				break;
24271af68beaSAlexander Stetsenko 		}
24281af68beaSAlexander Stetsenko 
242989f5d17bSYuri Pankov 		type = nvpair_type(nvp);
24301af68beaSAlexander Stetsenko 		switch (type) {
24311af68beaSAlexander Stetsenko 		case DATA_TYPE_UINT32:
24321af68beaSAlexander Stetsenko 			(void) nvpair_value_uint32(nvp, &val32);
24331af68beaSAlexander Stetsenko 			break;
24341af68beaSAlexander Stetsenko 		case DATA_TYPE_UINT64:
24351af68beaSAlexander Stetsenko 			(void) nvpair_value_uint64(nvp, &val64);
24361af68beaSAlexander Stetsenko 			break;
24371af68beaSAlexander Stetsenko 		case DATA_TYPE_STRING:
24381af68beaSAlexander Stetsenko 			(void) nvpair_value_string(nvp, &strval);
24391af68beaSAlexander Stetsenko 			break;
24401af68beaSAlexander Stetsenko 		default:
244189f5d17bSYuri Pankov 			(void) fprintf(stderr, "invalid data type\n");
24421af68beaSAlexander Stetsenko 		}
24431af68beaSAlexander Stetsenko 
24441af68beaSAlexander Stetsenko 		switch (field) {
24451af68beaSAlexander Stetsenko 		case USFIELD_TYPE:
24461af68beaSAlexander Stetsenko 			strval = (char *)us_type2str(val32);
24471af68beaSAlexander Stetsenko 			break;
24481af68beaSAlexander Stetsenko 		case USFIELD_NAME:
24491af68beaSAlexander Stetsenko 			if (type == DATA_TYPE_UINT64) {
24501af68beaSAlexander Stetsenko 				(void) sprintf(valstr, "%llu", val64);
24511af68beaSAlexander Stetsenko 				strval = valstr;
24521af68beaSAlexander Stetsenko 			}
24531af68beaSAlexander Stetsenko 			break;
24541af68beaSAlexander Stetsenko 		case USFIELD_USED:
24551af68beaSAlexander Stetsenko 		case USFIELD_QUOTA:
24561af68beaSAlexander Stetsenko 			if (type == DATA_TYPE_UINT64) {
245789f5d17bSYuri Pankov 				if (parsable) {
24581af68beaSAlexander Stetsenko 					(void) sprintf(valstr, "%llu", val64);
245989f5d17bSYuri Pankov 				} else {
24601af68beaSAlexander Stetsenko 					zfs_nicenum(val64, valstr,
24611af68beaSAlexander Stetsenko 					    sizeof (valstr));
246289f5d17bSYuri Pankov 				}
246389f5d17bSYuri Pankov 				if (field == USFIELD_QUOTA &&
246489f5d17bSYuri Pankov 				    strcmp(valstr, "0") == 0)
246589f5d17bSYuri Pankov 					strval = "none";
246689f5d17bSYuri Pankov 				else
24671af68beaSAlexander Stetsenko 					strval = valstr;
24681af68beaSAlexander Stetsenko 			}
24691af68beaSAlexander Stetsenko 			break;
24701af68beaSAlexander Stetsenko 		}
24711af68beaSAlexander Stetsenko 
247289f5d17bSYuri Pankov 		if (!first) {
247389f5d17bSYuri Pankov 			if (scripted)
247489f5d17bSYuri Pankov 				(void) printf("\t");
24751af68beaSAlexander Stetsenko 			else
247689f5d17bSYuri Pankov 				(void) printf("  ");
24771af68beaSAlexander Stetsenko 		}
247889f5d17bSYuri Pankov 		if (scripted)
247989f5d17bSYuri Pankov 			(void) printf("%s", strval);
248089f5d17bSYuri Pankov 		else if (field == USFIELD_TYPE || field == USFIELD_NAME)
248189f5d17bSYuri Pankov 			(void) printf("%-*s", width[field], strval);
248289f5d17bSYuri Pankov 		else
248389f5d17bSYuri Pankov 			(void) printf("%*s", width[field], strval);
24841af68beaSAlexander Stetsenko 
24851af68beaSAlexander Stetsenko 		first = B_FALSE;
248689f5d17bSYuri Pankov 		cfield++;
24871af68beaSAlexander Stetsenko 	}
24881af68beaSAlexander Stetsenko 
24891af68beaSAlexander Stetsenko 	(void) printf("\n");
24901af68beaSAlexander Stetsenko }
24911af68beaSAlexander Stetsenko 
24921af68beaSAlexander Stetsenko static void
249389f5d17bSYuri Pankov print_us(boolean_t scripted, boolean_t parsable, int *fields, int types,
249489f5d17bSYuri Pankov     size_t *width, boolean_t rmnode, uu_avl_t *avl)
24951af68beaSAlexander Stetsenko {
24961af68beaSAlexander Stetsenko 	us_node_t *node;
24971af68beaSAlexander Stetsenko 	const char *col;
249889f5d17bSYuri Pankov 	int cfield = 0;
249989f5d17bSYuri Pankov 	int field;
25001af68beaSAlexander Stetsenko 
25011af68beaSAlexander Stetsenko 	if (!scripted) {
25021af68beaSAlexander Stetsenko 		boolean_t first = B_TRUE;
25031af68beaSAlexander Stetsenko 
250489f5d17bSYuri Pankov 		while ((field = fields[cfield]) != USFIELD_LAST) {
250589f5d17bSYuri Pankov 			col = gettext(us_field_hdr[field]);
250689f5d17bSYuri Pankov 			if (field == USFIELD_TYPE || field == USFIELD_NAME) {
250789f5d17bSYuri Pankov 				(void) printf(first ? "%-*s" : "  %-*s",
250889f5d17bSYuri Pankov 				    width[field], col);
250989f5d17bSYuri Pankov 			} else {
251089f5d17bSYuri Pankov 				(void) printf(first ? "%*s" : "  %*s",
251189f5d17bSYuri Pankov 				    width[field], col);
251289f5d17bSYuri Pankov 			}
25131af68beaSAlexander Stetsenko 			first = B_FALSE;
251489f5d17bSYuri Pankov 			cfield++;
25151af68beaSAlexander Stetsenko 		}
25161af68beaSAlexander Stetsenko 		(void) printf("\n");
25171af68beaSAlexander Stetsenko 	}
25181af68beaSAlexander Stetsenko 
251989f5d17bSYuri Pankov 	for (node = uu_avl_first(avl); node; node = uu_avl_next(avl, node)) {
252089f5d17bSYuri Pankov 		print_us_node(scripted, parsable, fields, types, width, node);
25211af68beaSAlexander Stetsenko 		if (rmnode)
25221af68beaSAlexander Stetsenko 			nvlist_free(node->usn_nvl);
25231af68beaSAlexander Stetsenko 	}
25241af68beaSAlexander Stetsenko }
25251af68beaSAlexander Stetsenko 
252614843421SMatthew Ahrens static int
252714843421SMatthew Ahrens zfs_do_userspace(int argc, char **argv)
252814843421SMatthew Ahrens {
252914843421SMatthew Ahrens 	zfs_handle_t *zhp;
253014843421SMatthew Ahrens 	zfs_userquota_prop_t p;
25311af68beaSAlexander Stetsenko 	uu_avl_pool_t *avl_pool;
25321af68beaSAlexander Stetsenko 	uu_avl_t *avl_tree;
25331af68beaSAlexander Stetsenko 	uu_avl_walk_t *walk;
253489f5d17bSYuri Pankov 	char *delim;
253589f5d17bSYuri Pankov 	char deffields[] = "type,name,used,quota";
253689f5d17bSYuri Pankov 	char *ofield = NULL;
253789f5d17bSYuri Pankov 	char *tfield = NULL;
253889f5d17bSYuri Pankov 	int cfield = 0;
253989f5d17bSYuri Pankov 	int fields[256];
254089f5d17bSYuri Pankov 	int i;
25411af68beaSAlexander Stetsenko 	boolean_t scripted = B_FALSE;
25421af68beaSAlexander Stetsenko 	boolean_t prtnum = B_FALSE;
254389f5d17bSYuri Pankov 	boolean_t parsable = B_FALSE;
25441af68beaSAlexander Stetsenko 	boolean_t sid2posix = B_FALSE;
254570f56fa6SYuri Pankov 	int ret = 0;
25461af68beaSAlexander Stetsenko 	int c;
25471af68beaSAlexander Stetsenko 	zfs_sort_column_t *sortcol = NULL;
254889f5d17bSYuri Pankov 	int types = USTYPE_PSX_USR | USTYPE_SMB_USR;
25491af68beaSAlexander Stetsenko 	us_cbdata_t cb;
25501af68beaSAlexander Stetsenko 	us_node_t *node;
255189f5d17bSYuri Pankov 	us_node_t *rmnode;
255289f5d17bSYuri Pankov 	uu_list_pool_t *listpool;
255389f5d17bSYuri Pankov 	uu_list_t *list;
255489f5d17bSYuri Pankov 	uu_avl_index_t idx = 0;
255589f5d17bSYuri Pankov 	uu_list_index_t idx2 = 0;
255614843421SMatthew Ahrens 
25571af68beaSAlexander Stetsenko 	if (argc < 2)
25581af68beaSAlexander Stetsenko 		usage(B_FALSE);
255914843421SMatthew Ahrens 
256089f5d17bSYuri Pankov 	if (strcmp(argv[0], "groupspace") == 0)
256189f5d17bSYuri Pankov 		/* Toggle default group types */
25621af68beaSAlexander Stetsenko 		types = USTYPE_PSX_GRP | USTYPE_SMB_GRP;
25631af68beaSAlexander Stetsenko 
25641af68beaSAlexander Stetsenko 	while ((c = getopt(argc, argv, "nHpo:s:S:t:i")) != -1) {
25651af68beaSAlexander Stetsenko 		switch (c) {
25661af68beaSAlexander Stetsenko 		case 'n':
25671af68beaSAlexander Stetsenko 			prtnum = B_TRUE;
25681af68beaSAlexander Stetsenko 			break;
25691af68beaSAlexander Stetsenko 		case 'H':
25701af68beaSAlexander Stetsenko 			scripted = B_TRUE;
25711af68beaSAlexander Stetsenko 			break;
25721af68beaSAlexander Stetsenko 		case 'p':
257389f5d17bSYuri Pankov 			parsable = B_TRUE;
25741af68beaSAlexander Stetsenko 			break;
25751af68beaSAlexander Stetsenko 		case 'o':
257689f5d17bSYuri Pankov 			ofield = optarg;
25771af68beaSAlexander Stetsenko 			break;
25781af68beaSAlexander Stetsenko 		case 's':
25791af68beaSAlexander Stetsenko 		case 'S':
25801af68beaSAlexander Stetsenko 			if (zfs_add_sort_column(&sortcol, optarg,
258189f5d17bSYuri Pankov 			    c == 's' ? B_FALSE : B_TRUE) != 0) {
25821af68beaSAlexander Stetsenko 				(void) fprintf(stderr,
258389f5d17bSYuri Pankov 				    gettext("invalid field '%s'\n"), optarg);
25841af68beaSAlexander Stetsenko 				usage(B_FALSE);
25851af68beaSAlexander Stetsenko 			}
25861af68beaSAlexander Stetsenko 			break;
25871af68beaSAlexander Stetsenko 		case 't':
258889f5d17bSYuri Pankov 			tfield = optarg;
25891af68beaSAlexander Stetsenko 			break;
25901af68beaSAlexander Stetsenko 		case 'i':
25911af68beaSAlexander Stetsenko 			sid2posix = B_TRUE;
25921af68beaSAlexander Stetsenko 			break;
25931af68beaSAlexander Stetsenko 		case ':':
25941af68beaSAlexander Stetsenko 			(void) fprintf(stderr, gettext("missing argument for "
25951af68beaSAlexander Stetsenko 			    "'%c' option\n"), optopt);
25961af68beaSAlexander Stetsenko 			usage(B_FALSE);
25971af68beaSAlexander Stetsenko 			break;
25981af68beaSAlexander Stetsenko 		case '?':
25991af68beaSAlexander Stetsenko 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
26001af68beaSAlexander Stetsenko 			    optopt);
26011af68beaSAlexander Stetsenko 			usage(B_FALSE);
26021af68beaSAlexander Stetsenko 		}
26031af68beaSAlexander Stetsenko 	}
26041af68beaSAlexander Stetsenko 
26051af68beaSAlexander Stetsenko 	argc -= optind;
26061af68beaSAlexander Stetsenko 	argv += optind;
26071af68beaSAlexander Stetsenko 
260889f5d17bSYuri Pankov 	if (argc < 1) {
260989f5d17bSYuri Pankov 		(void) fprintf(stderr, gettext("missing dataset name\n"));
261089f5d17bSYuri Pankov 		usage(B_FALSE);
261189f5d17bSYuri Pankov 	}
261289f5d17bSYuri Pankov 	if (argc > 1) {
261389f5d17bSYuri Pankov 		(void) fprintf(stderr, gettext("too many arguments\n"));
261489f5d17bSYuri Pankov 		usage(B_FALSE);
261589f5d17bSYuri Pankov 	}
261689f5d17bSYuri Pankov 
261789f5d17bSYuri Pankov 	/* Use default output fields if not specified using -o */
261889f5d17bSYuri Pankov 	if (ofield == NULL)
261989f5d17bSYuri Pankov 		ofield = deffields;
262089f5d17bSYuri Pankov 	do {
262189f5d17bSYuri Pankov 		if ((delim = strchr(ofield, ',')) != NULL)
262289f5d17bSYuri Pankov 			*delim = '\0';
262389f5d17bSYuri Pankov 		if ((fields[cfield++] = us_field_index(ofield)) == -1) {
262489f5d17bSYuri Pankov 			(void) fprintf(stderr, gettext("invalid type '%s' "
262589f5d17bSYuri Pankov 			    "for -o option\n"), ofield);
262689f5d17bSYuri Pankov 			return (-1);
262789f5d17bSYuri Pankov 		}
262889f5d17bSYuri Pankov 		if (delim != NULL)
262989f5d17bSYuri Pankov 			ofield = delim + 1;
263089f5d17bSYuri Pankov 	} while (delim != NULL);
263189f5d17bSYuri Pankov 	fields[cfield] = USFIELD_LAST;
263289f5d17bSYuri Pankov 
263389f5d17bSYuri Pankov 	/* Override output types (-t option) */
263489f5d17bSYuri Pankov 	if (tfield != NULL) {
263589f5d17bSYuri Pankov 		types = 0;
263689f5d17bSYuri Pankov 
263789f5d17bSYuri Pankov 		do {
263889f5d17bSYuri Pankov 			boolean_t found = B_FALSE;
263989f5d17bSYuri Pankov 
264089f5d17bSYuri Pankov 			if ((delim = strchr(tfield, ',')) != NULL)
264189f5d17bSYuri Pankov 				*delim = '\0';
264289f5d17bSYuri Pankov 			for (i = 0; i < sizeof (us_type_bits) / sizeof (int);
264389f5d17bSYuri Pankov 			    i++) {
264489f5d17bSYuri Pankov 				if (strcmp(tfield, us_type_names[i]) == 0) {
264589f5d17bSYuri Pankov 					found = B_TRUE;
264689f5d17bSYuri Pankov 					types |= us_type_bits[i];
26471af68beaSAlexander Stetsenko 					break;
26481af68beaSAlexander Stetsenko 				}
26491af68beaSAlexander Stetsenko 			}
265089f5d17bSYuri Pankov 			if (!found) {
265189f5d17bSYuri Pankov 				(void) fprintf(stderr, gettext("invalid type "
265289f5d17bSYuri Pankov 				    "'%s' for -t option\n"), tfield);
265389f5d17bSYuri Pankov 				return (-1);
265489f5d17bSYuri Pankov 			}
265589f5d17bSYuri Pankov 			if (delim != NULL)
265689f5d17bSYuri Pankov 				tfield = delim + 1;
265789f5d17bSYuri Pankov 		} while (delim != NULL);
26581af68beaSAlexander Stetsenko 	}
26591af68beaSAlexander Stetsenko 
266089f5d17bSYuri Pankov 	if ((zhp = zfs_open(g_zfs, argv[0], ZFS_TYPE_DATASET)) == NULL)
266114843421SMatthew Ahrens 		return (1);
266214843421SMatthew Ahrens 
26631af68beaSAlexander Stetsenko 	if ((avl_pool = uu_avl_pool_create("us_avl_pool", sizeof (us_node_t),
266489f5d17bSYuri Pankov 	    offsetof(us_node_t, usn_avlnode), us_compare, UU_DEFAULT)) == NULL)
26651af68beaSAlexander Stetsenko 		nomem();
26661af68beaSAlexander Stetsenko 	if ((avl_tree = uu_avl_create(avl_pool, NULL, UU_DEFAULT)) == NULL)
26671af68beaSAlexander Stetsenko 		nomem();
26681af68beaSAlexander Stetsenko 
266989f5d17bSYuri Pankov 	/* Always add default sorting columns */
267089f5d17bSYuri Pankov 	(void) zfs_add_sort_column(&sortcol, "type", B_FALSE);
267189f5d17bSYuri Pankov 	(void) zfs_add_sort_column(&sortcol, "name", B_FALSE);
267289f5d17bSYuri Pankov 
26731af68beaSAlexander Stetsenko 	cb.cb_sortcol = sortcol;
26741af68beaSAlexander Stetsenko 	cb.cb_numname = prtnum;
267589f5d17bSYuri Pankov 	cb.cb_nicenum = !parsable;
26761af68beaSAlexander Stetsenko 	cb.cb_avl_pool = avl_pool;
26771af68beaSAlexander Stetsenko 	cb.cb_avl = avl_tree;
26781af68beaSAlexander Stetsenko 	cb.cb_sid2posix = sid2posix;
267989f5d17bSYuri Pankov 
268089f5d17bSYuri Pankov 	for (i = 0; i < USFIELD_LAST; i++)
268189f5d17bSYuri Pankov 		cb.cb_width[i] = strlen(gettext(us_field_hdr[i]));
268214843421SMatthew Ahrens 
268314843421SMatthew Ahrens 	for (p = 0; p < ZFS_NUM_USERQUOTA_PROPS; p++) {
268489f5d17bSYuri Pankov 		if (((p == ZFS_PROP_USERUSED || p == ZFS_PROP_USERQUOTA) &&
268589f5d17bSYuri Pankov 		    !(types & (USTYPE_PSX_USR | USTYPE_SMB_USR))) ||
268689f5d17bSYuri Pankov 		    ((p == ZFS_PROP_GROUPUSED || p == ZFS_PROP_GROUPQUOTA) &&
268789f5d17bSYuri Pankov 		    !(types & (USTYPE_PSX_GRP | USTYPE_SMB_GRP))))
26881af68beaSAlexander Stetsenko 			continue;
26891af68beaSAlexander Stetsenko 		cb.cb_prop = p;
269070f56fa6SYuri Pankov 		if ((ret = zfs_userspace(zhp, p, userspace_cb, &cb)) != 0)
269170f56fa6SYuri Pankov 			return (ret);
269214843421SMatthew Ahrens 	}
26931af68beaSAlexander Stetsenko 
269489f5d17bSYuri Pankov 	/* Sort the list */
269570f56fa6SYuri Pankov 	if ((node = uu_avl_first(avl_tree)) == NULL)
269670f56fa6SYuri Pankov 		return (0);
269770f56fa6SYuri Pankov 
269889f5d17bSYuri Pankov 	us_populated = B_TRUE;
269970f56fa6SYuri Pankov 
27001af68beaSAlexander Stetsenko 	listpool = uu_list_pool_create("tmplist", sizeof (us_node_t),
270189f5d17bSYuri Pankov 	    offsetof(us_node_t, usn_listnode), NULL, UU_DEFAULT);
27021af68beaSAlexander Stetsenko 	list = uu_list_create(listpool, NULL, UU_DEFAULT);
27031af68beaSAlexander Stetsenko 	uu_list_node_init(node, &node->usn_listnode, listpool);
270489f5d17bSYuri Pankov 
27051af68beaSAlexander Stetsenko 	while (node != NULL) {
27061af68beaSAlexander Stetsenko 		rmnode = node;
27071af68beaSAlexander Stetsenko 		node = uu_avl_next(avl_tree, node);
27081af68beaSAlexander Stetsenko 		uu_avl_remove(avl_tree, rmnode);
270989f5d17bSYuri Pankov 		if (uu_list_find(list, rmnode, NULL, &idx2) == NULL)
27101af68beaSAlexander Stetsenko 			uu_list_insert(list, rmnode, idx2);
27111af68beaSAlexander Stetsenko 	}
27121af68beaSAlexander Stetsenko 
27131af68beaSAlexander Stetsenko 	for (node = uu_list_first(list); node != NULL;
27141af68beaSAlexander Stetsenko 	    node = uu_list_next(list, node)) {
27151af68beaSAlexander Stetsenko 		us_sort_info_t sortinfo = { sortcol, cb.cb_numname };
271689f5d17bSYuri Pankov 
271789f5d17bSYuri Pankov 		if (uu_avl_find(avl_tree, node, &sortinfo, &idx) == NULL)
27181af68beaSAlexander Stetsenko 			uu_avl_insert(avl_tree, node, idx);
27191af68beaSAlexander Stetsenko 	}
27201af68beaSAlexander Stetsenko 
27211af68beaSAlexander Stetsenko 	uu_list_destroy(list);
272289f5d17bSYuri Pankov 	uu_list_pool_destroy(listpool);
27231af68beaSAlexander Stetsenko 
272489f5d17bSYuri Pankov 	/* Print and free node nvlist memory */
272589f5d17bSYuri Pankov 	print_us(scripted, parsable, fields, types, cb.cb_width, B_TRUE,
272689f5d17bSYuri Pankov 	    cb.cb_avl);
27271af68beaSAlexander Stetsenko 
27281af68beaSAlexander Stetsenko 	zfs_free_sort_columns(sortcol);
27291af68beaSAlexander Stetsenko 
273089f5d17bSYuri Pankov 	/* Clean up the AVL tree */
27311af68beaSAlexander Stetsenko 	if ((walk = uu_avl_walk_start(cb.cb_avl, UU_WALK_ROBUST)) == NULL)
27321af68beaSAlexander Stetsenko 		nomem();
27331af68beaSAlexander Stetsenko 
27341af68beaSAlexander Stetsenko 	while ((node = uu_avl_walk_next(walk)) != NULL) {
27351af68beaSAlexander Stetsenko 		uu_avl_remove(cb.cb_avl, node);
27361af68beaSAlexander Stetsenko 		free(node);
27371af68beaSAlexander Stetsenko 	}
27381af68beaSAlexander Stetsenko 
27391af68beaSAlexander Stetsenko 	uu_avl_walk_end(walk);
27401af68beaSAlexander Stetsenko 	uu_avl_destroy(avl_tree);
27411af68beaSAlexander Stetsenko 	uu_avl_pool_destroy(avl_pool);
27421af68beaSAlexander Stetsenko 
274370f56fa6SYuri Pankov 	return (ret);
274414843421SMatthew Ahrens }
274514843421SMatthew Ahrens 
274614843421SMatthew Ahrens /*
2747ae1726b6SChris Gerhard  * list [-r][-d max] [-H] [-o property[,property]...] [-t type[,type]...]
2748b6825278Ssjelinek  *      [-s property [-s property]...] [-S property [-S property]...]
2749b6825278Ssjelinek  *      <dataset> ...
2750fa9e4066Sahrens  *
2751fa9e4066Sahrens  *	-r	Recurse over all children
2752ae1726b6SChris Gerhard  *	-d	Limit recursion by depth.
2753da6c28aaSamw  *	-H	Scripted mode; elide headers and separate columns by tabs
2754fa9e4066Sahrens  *	-o	Control which fields to display.
275507ba0419Seschrock  *	-t	Control which object types to display.
2756b6825278Ssjelinek  *	-s	Specify sort columns, descending order.
2757b6825278Ssjelinek  *	-S	Specify sort columns, ascending order.
2758fa9e4066Sahrens  *
2759fa9e4066Sahrens  * When given no arguments, lists all filesystems in the system.
2760fa9e4066Sahrens  * Otherwise, list the specified datasets, optionally recursing down them if
2761fa9e4066Sahrens  * '-r' is specified.
2762fa9e4066Sahrens  */
2763fa9e4066Sahrens typedef struct list_cbdata {
276499653d4eSeschrock 	boolean_t	cb_first;
276599653d4eSeschrock 	boolean_t	cb_scripted;
2766990b4856Slling 	zprop_list_t	*cb_proplist;
2767fa9e4066Sahrens } list_cbdata_t;
2768fa9e4066Sahrens 
2769fa9e4066Sahrens /*
2770fa9e4066Sahrens  * Given a list of columns to display, output appropriate headers for each one.
2771fa9e4066Sahrens  */
2772fa9e4066Sahrens static void
2773990b4856Slling print_header(zprop_list_t *pl)
2774fa9e4066Sahrens {
2775e9dbad6fSeschrock 	char headerbuf[ZFS_MAXPROPLEN];
2776e9dbad6fSeschrock 	const char *header;
2777fa9e4066Sahrens 	int i;
2778e9dbad6fSeschrock 	boolean_t first = B_TRUE;
2779e9dbad6fSeschrock 	boolean_t right_justify;
2780fa9e4066Sahrens 
2781e9dbad6fSeschrock 	for (; pl != NULL; pl = pl->pl_next) {
2782e9dbad6fSeschrock 		if (!first) {
2783fa9e4066Sahrens 			(void) printf("  ");
2784e9dbad6fSeschrock 		} else {
2785e9dbad6fSeschrock 			first = B_FALSE;
2786e9dbad6fSeschrock 		}
2787e9dbad6fSeschrock 
2788e9dbad6fSeschrock 		right_justify = B_FALSE;
2789990b4856Slling 		if (pl->pl_prop != ZPROP_INVAL) {
2790e9dbad6fSeschrock 			header = zfs_prop_column_name(pl->pl_prop);
2791e9dbad6fSeschrock 			right_justify = zfs_prop_align_right(pl->pl_prop);
2792e9dbad6fSeschrock 		} else {
2793e9dbad6fSeschrock 			for (i = 0; pl->pl_user_prop[i] != '\0'; i++)
2794e9dbad6fSeschrock 				headerbuf[i] = toupper(pl->pl_user_prop[i]);
2795e9dbad6fSeschrock 			headerbuf[i] = '\0';
2796e9dbad6fSeschrock 			header = headerbuf;
2797e9dbad6fSeschrock 		}
2798e9dbad6fSeschrock 
2799e9dbad6fSeschrock 		if (pl->pl_next == NULL && !right_justify)
2800e9dbad6fSeschrock 			(void) printf("%s", header);
2801e9dbad6fSeschrock 		else if (right_justify)
2802e9dbad6fSeschrock 			(void) printf("%*s", pl->pl_width, header);
2803e9dbad6fSeschrock 		else
2804e9dbad6fSeschrock 			(void) printf("%-*s", pl->pl_width, header);
2805fa9e4066Sahrens 	}
2806fa9e4066Sahrens 
2807fa9e4066Sahrens 	(void) printf("\n");
2808fa9e4066Sahrens }
2809fa9e4066Sahrens 
2810fa9e4066Sahrens /*
2811fa9e4066Sahrens  * Given a dataset and a list of fields, print out all the properties according
2812fa9e4066Sahrens  * to the described layout.
2813fa9e4066Sahrens  */
2814fa9e4066Sahrens static void
2815990b4856Slling print_dataset(zfs_handle_t *zhp, zprop_list_t *pl, boolean_t scripted)
2816fa9e4066Sahrens {
2817e9dbad6fSeschrock 	boolean_t first = B_TRUE;
2818fa9e4066Sahrens 	char property[ZFS_MAXPROPLEN];
2819e9dbad6fSeschrock 	nvlist_t *userprops = zfs_get_user_props(zhp);
2820e9dbad6fSeschrock 	nvlist_t *propval;
2821e9dbad6fSeschrock 	char *propstr;
2822e9dbad6fSeschrock 	boolean_t right_justify;
2823e9dbad6fSeschrock 	int width;
2824fa9e4066Sahrens 
2825e9dbad6fSeschrock 	for (; pl != NULL; pl = pl->pl_next) {
2826e9dbad6fSeschrock 		if (!first) {
2827fa9e4066Sahrens 			if (scripted)
2828fa9e4066Sahrens 				(void) printf("\t");
2829fa9e4066Sahrens 			else
2830fa9e4066Sahrens 				(void) printf("  ");
2831e9dbad6fSeschrock 		} else {
2832e9dbad6fSeschrock 			first = B_FALSE;
2833fa9e4066Sahrens 		}
2834fa9e4066Sahrens 
2835990b4856Slling 		if (pl->pl_prop != ZPROP_INVAL) {
2836e9dbad6fSeschrock 			if (zfs_prop_get(zhp, pl->pl_prop, property,
283799653d4eSeschrock 			    sizeof (property), NULL, NULL, 0, B_FALSE) != 0)
2838e9dbad6fSeschrock 				propstr = "-";
2839e9dbad6fSeschrock 			else
2840e9dbad6fSeschrock 				propstr = property;
2841e9dbad6fSeschrock 
2842e9dbad6fSeschrock 			right_justify = zfs_prop_align_right(pl->pl_prop);
284314843421SMatthew Ahrens 		} else if (zfs_prop_userquota(pl->pl_user_prop)) {
284414843421SMatthew Ahrens 			if (zfs_prop_get_userquota(zhp, pl->pl_user_prop,
284514843421SMatthew Ahrens 			    property, sizeof (property), B_FALSE) != 0)
284614843421SMatthew Ahrens 				propstr = "-";
284714843421SMatthew Ahrens 			else
284814843421SMatthew Ahrens 				propstr = property;
284914843421SMatthew Ahrens 			right_justify = B_TRUE;
285019b94df9SMatthew Ahrens 		} else if (zfs_prop_written(pl->pl_user_prop)) {
285119b94df9SMatthew Ahrens 			if (zfs_prop_get_written(zhp, pl->pl_user_prop,
285219b94df9SMatthew Ahrens 			    property, sizeof (property), B_FALSE) != 0)
285319b94df9SMatthew Ahrens 				propstr = "-";
285419b94df9SMatthew Ahrens 			else
285519b94df9SMatthew Ahrens 				propstr = property;
285619b94df9SMatthew Ahrens 			right_justify = B_TRUE;
2857e9dbad6fSeschrock 		} else {
2858e9dbad6fSeschrock 			if (nvlist_lookup_nvlist(userprops,
2859e9dbad6fSeschrock 			    pl->pl_user_prop, &propval) != 0)
2860e9dbad6fSeschrock 				propstr = "-";
2861e9dbad6fSeschrock 			else
2862e9dbad6fSeschrock 				verify(nvlist_lookup_string(propval,
2863990b4856Slling 				    ZPROP_VALUE, &propstr) == 0);
286414843421SMatthew Ahrens 			right_justify = B_FALSE;
2865e9dbad6fSeschrock 		}
2866e9dbad6fSeschrock 
2867e9dbad6fSeschrock 		width = pl->pl_width;
2868fa9e4066Sahrens 
286907ba0419Seschrock 		/*
287007ba0419Seschrock 		 * If this is being called in scripted mode, or if this is the
287107ba0419Seschrock 		 * last column and it is left-justified, don't include a width
287207ba0419Seschrock 		 * format specifier.
287307ba0419Seschrock 		 */
2874e9dbad6fSeschrock 		if (scripted || (pl->pl_next == NULL && !right_justify))
2875e9dbad6fSeschrock 			(void) printf("%s", propstr);
2876e9dbad6fSeschrock 		else if (right_justify)
2877e9dbad6fSeschrock 			(void) printf("%*s", width, propstr);
2878e9dbad6fSeschrock 		else
2879e9dbad6fSeschrock 			(void) printf("%-*s", width, propstr);
2880fa9e4066Sahrens 	}
2881fa9e4066Sahrens 
2882fa9e4066Sahrens 	(void) printf("\n");
2883fa9e4066Sahrens }
2884fa9e4066Sahrens 
2885fa9e4066Sahrens /*
2886fa9e4066Sahrens  * Generic callback function to list a dataset or snapshot.
2887fa9e4066Sahrens  */
2888fa9e4066Sahrens static int
2889fa9e4066Sahrens list_callback(zfs_handle_t *zhp, void *data)
2890fa9e4066Sahrens {
2891fa9e4066Sahrens 	list_cbdata_t *cbp = data;
2892fa9e4066Sahrens 
2893fa9e4066Sahrens 	if (cbp->cb_first) {
2894fa9e4066Sahrens 		if (!cbp->cb_scripted)
2895e9dbad6fSeschrock 			print_header(cbp->cb_proplist);
289699653d4eSeschrock 		cbp->cb_first = B_FALSE;
2897fa9e4066Sahrens 	}
2898fa9e4066Sahrens 
2899e9dbad6fSeschrock 	print_dataset(zhp, cbp->cb_proplist, cbp->cb_scripted);
2900fa9e4066Sahrens 
2901fa9e4066Sahrens 	return (0);
2902fa9e4066Sahrens }
2903fa9e4066Sahrens 
2904fa9e4066Sahrens static int
2905fa9e4066Sahrens zfs_do_list(int argc, char **argv)
2906fa9e4066Sahrens {
2907fa9e4066Sahrens 	int c;
290899653d4eSeschrock 	boolean_t scripted = B_FALSE;
2909fa9e4066Sahrens 	static char default_fields[] =
2910fa9e4066Sahrens 	    "name,used,available,referenced,mountpoint";
29117f73c863SRich Morris 	int types = ZFS_TYPE_DATASET;
2912d5b5bb25SRich Morris 	boolean_t types_specified = B_FALSE;
2913fa9e4066Sahrens 	char *fields = NULL;
2914fa9e4066Sahrens 	list_cbdata_t cb = { 0 };
2915fa9e4066Sahrens 	char *value;
2916ae1726b6SChris Gerhard 	int limit = 0;
291705c998d6SRichard Lowe 	int ret = 0;
2918b6825278Ssjelinek 	zfs_sort_column_t *sortcol = NULL;
2919d5b5bb25SRich Morris 	int flags = ZFS_ITER_PROP_LISTSNAPS | ZFS_ITER_ARGS_CAN_BE_PATHS;
2920fa9e4066Sahrens 
2921fa9e4066Sahrens 	/* check options */
2922ae1726b6SChris Gerhard 	while ((c = getopt(argc, argv, ":d:o:rt:Hs:S:")) != -1) {
2923fa9e4066Sahrens 		switch (c) {
2924fa9e4066Sahrens 		case 'o':
2925fa9e4066Sahrens 			fields = optarg;
2926fa9e4066Sahrens 			break;
2927ae1726b6SChris Gerhard 		case 'd':
2928ae1726b6SChris Gerhard 			limit = parse_depth(optarg, &flags);
2929ae1726b6SChris Gerhard 			break;
2930fa9e4066Sahrens 		case 'r':
2931d5b5bb25SRich Morris 			flags |= ZFS_ITER_RECURSE;
2932fa9e4066Sahrens 			break;
2933fa9e4066Sahrens 		case 'H':
293499653d4eSeschrock 			scripted = B_TRUE;
2935fa9e4066Sahrens 			break;
2936b6825278Ssjelinek 		case 's':
2937e9dbad6fSeschrock 			if (zfs_add_sort_column(&sortcol, optarg,
2938e9dbad6fSeschrock 			    B_FALSE) != 0) {
2939b6825278Ssjelinek 				(void) fprintf(stderr,
2940b6825278Ssjelinek 				    gettext("invalid property '%s'\n"), optarg);
2941b6825278Ssjelinek 				usage(B_FALSE);
2942b6825278Ssjelinek 			}
2943b6825278Ssjelinek 			break;
2944b6825278Ssjelinek 		case 'S':
2945e9dbad6fSeschrock 			if (zfs_add_sort_column(&sortcol, optarg,
2946e9dbad6fSeschrock 			    B_TRUE) != 0) {
2947b6825278Ssjelinek 				(void) fprintf(stderr,
2948b6825278Ssjelinek 				    gettext("invalid property '%s'\n"), optarg);
2949b6825278Ssjelinek 				usage(B_FALSE);
2950b6825278Ssjelinek 			}
2951b6825278Ssjelinek 			break;
2952fa9e4066Sahrens 		case 't':
2953fa9e4066Sahrens 			types = 0;
2954d5b5bb25SRich Morris 			types_specified = B_TRUE;
2955d5b5bb25SRich Morris 			flags &= ~ZFS_ITER_PROP_LISTSNAPS;
2956fa9e4066Sahrens 			while (*optarg != '\0') {
2957d5b5bb25SRich Morris 				static char *type_subopts[] = { "filesystem",
2958d5b5bb25SRich Morris 				    "volume", "snapshot", "all", NULL };
2959d5b5bb25SRich Morris 
2960fa9e4066Sahrens 				switch (getsubopt(&optarg, type_subopts,
2961fa9e4066Sahrens 				    &value)) {
2962fa9e4066Sahrens 				case 0:
2963fa9e4066Sahrens 					types |= ZFS_TYPE_FILESYSTEM;
2964fa9e4066Sahrens 					break;
2965fa9e4066Sahrens 				case 1:
2966fa9e4066Sahrens 					types |= ZFS_TYPE_VOLUME;
2967fa9e4066Sahrens 					break;
2968fa9e4066Sahrens 				case 2:
2969fa9e4066Sahrens 					types |= ZFS_TYPE_SNAPSHOT;
2970fa9e4066Sahrens 					break;
2971d5b5bb25SRich Morris 				case 3:
2972d5b5bb25SRich Morris 					types = ZFS_TYPE_DATASET;
2973d5b5bb25SRich Morris 					break;
2974d5b5bb25SRich Morris 
2975fa9e4066Sahrens 				default:
2976fa9e4066Sahrens 					(void) fprintf(stderr,
2977fa9e4066Sahrens 					    gettext("invalid type '%s'\n"),
2978fa9e4066Sahrens 					    value);
297999653d4eSeschrock 					usage(B_FALSE);
2980fa9e4066Sahrens 				}
2981fa9e4066Sahrens 			}
2982fa9e4066Sahrens 			break;
2983fa9e4066Sahrens 		case ':':
2984fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing argument for "
2985fa9e4066Sahrens 			    "'%c' option\n"), optopt);
298699653d4eSeschrock 			usage(B_FALSE);
2987fa9e4066Sahrens 			break;
2988fa9e4066Sahrens 		case '?':
2989fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
2990fa9e4066Sahrens 			    optopt);
299199653d4eSeschrock 			usage(B_FALSE);
2992fa9e4066Sahrens 		}
2993fa9e4066Sahrens 	}
2994fa9e4066Sahrens 
2995fa9e4066Sahrens 	argc -= optind;
2996fa9e4066Sahrens 	argv += optind;
2997fa9e4066Sahrens 
2998fa9e4066Sahrens 	if (fields == NULL)
299974e7dc98SMatthew Ahrens 		fields = default_fields;
300074e7dc98SMatthew Ahrens 
300174e7dc98SMatthew Ahrens 	/*
3002d5b5bb25SRich Morris 	 * If "-o space" and no types were specified, don't display snapshots.
300374e7dc98SMatthew Ahrens 	 */
3004d5b5bb25SRich Morris 	if (strcmp(fields, "space") == 0 && types_specified == B_FALSE)
300574e7dc98SMatthew Ahrens 		types &= ~ZFS_TYPE_SNAPSHOT;
3006fa9e4066Sahrens 
300707ba0419Seschrock 	/*
3008990b4856Slling 	 * If the user specifies '-o all', the zprop_get_list() doesn't
300907ba0419Seschrock 	 * normally include the name of the dataset.  For 'zfs list', we always
301007ba0419Seschrock 	 * want this property to be first.
301107ba0419Seschrock 	 */
3012990b4856Slling 	if (zprop_get_list(g_zfs, fields, &cb.cb_proplist, ZFS_TYPE_DATASET)
3013990b4856Slling 	    != 0)
301499653d4eSeschrock 		usage(B_FALSE);
3015fa9e4066Sahrens 
3016fa9e4066Sahrens 	cb.cb_scripted = scripted;
301799653d4eSeschrock 	cb.cb_first = B_TRUE;
3018fa9e4066Sahrens 
3019d5b5bb25SRich Morris 	ret = zfs_for_each(argc, argv, flags, types, sortcol, &cb.cb_proplist,
3020ae1726b6SChris Gerhard 	    limit, list_callback, &cb);
3021b6825278Ssjelinek 
3022990b4856Slling 	zprop_free_list(cb.cb_proplist);
3023b6825278Ssjelinek 	zfs_free_sort_columns(sortcol);
3024fa9e4066Sahrens 
3025fce7d82bSmmusante 	if (ret == 0 && cb.cb_first && !cb.cb_scripted)
3026fa9e4066Sahrens 		(void) printf(gettext("no datasets available\n"));
3027fa9e4066Sahrens 
3028fa9e4066Sahrens 	return (ret);
3029fa9e4066Sahrens }
3030fa9e4066Sahrens 
3031fa9e4066Sahrens /*
30326a9cb0eaSEric Schrock  * zfs rename [-f] <fs | snap | vol> <fs | snap | vol>
30336a9cb0eaSEric Schrock  * zfs rename [-f] -p <fs | vol> <fs | vol>
30347f1f55eaSvb160487  * zfs rename -r <snap> <snap>
3035fa9e4066Sahrens  *
3036fa9e4066Sahrens  * Renames the given dataset to another of the same type.
30377f1f55eaSvb160487  *
30387f1f55eaSvb160487  * The '-p' flag creates all the non-existing ancestors of the target first.
3039fa9e4066Sahrens  */
3040fa9e4066Sahrens /* ARGSUSED */
3041fa9e4066Sahrens static int
3042fa9e4066Sahrens zfs_do_rename(int argc, char **argv)
3043fa9e4066Sahrens {
3044fa9e4066Sahrens 	zfs_handle_t *zhp;
3045cdf5b4caSmmusante 	int c;
304605c998d6SRichard Lowe 	int ret = 0;
30477f1f55eaSvb160487 	boolean_t recurse = B_FALSE;
30487f1f55eaSvb160487 	boolean_t parents = B_FALSE;
30496a9cb0eaSEric Schrock 	boolean_t force_unmount = B_FALSE;
3050fa9e4066Sahrens 
3051fa9e4066Sahrens 	/* check options */
30526a9cb0eaSEric Schrock 	while ((c = getopt(argc, argv, "prf")) != -1) {
3053cdf5b4caSmmusante 		switch (c) {
30547f1f55eaSvb160487 		case 'p':
30557f1f55eaSvb160487 			parents = B_TRUE;
30567f1f55eaSvb160487 			break;
3057cdf5b4caSmmusante 		case 'r':
30587f1f55eaSvb160487 			recurse = B_TRUE;
3059cdf5b4caSmmusante 			break;
30606a9cb0eaSEric Schrock 		case 'f':
30616a9cb0eaSEric Schrock 			force_unmount = B_TRUE;
30626a9cb0eaSEric Schrock 			break;
3063cdf5b4caSmmusante 		case '?':
3064cdf5b4caSmmusante 		default:
3065fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
3066cdf5b4caSmmusante 			    optopt);
306799653d4eSeschrock 			usage(B_FALSE);
3068fa9e4066Sahrens 		}
3069cdf5b4caSmmusante 	}
3070cdf5b4caSmmusante 
3071cdf5b4caSmmusante 	argc -= optind;
3072cdf5b4caSmmusante 	argv += optind;
3073fa9e4066Sahrens 
3074fa9e4066Sahrens 	/* check number of arguments */
3075cdf5b4caSmmusante 	if (argc < 1) {
3076fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing source dataset "
3077fa9e4066Sahrens 		    "argument\n"));
307899653d4eSeschrock 		usage(B_FALSE);
3079fa9e4066Sahrens 	}
3080cdf5b4caSmmusante 	if (argc < 2) {
3081fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing target dataset "
3082fa9e4066Sahrens 		    "argument\n"));
308399653d4eSeschrock 		usage(B_FALSE);
3084fa9e4066Sahrens 	}
3085cdf5b4caSmmusante 	if (argc > 2) {
3086fa9e4066Sahrens 		(void) fprintf(stderr, gettext("too many arguments\n"));
308799653d4eSeschrock 		usage(B_FALSE);
3088fa9e4066Sahrens 	}
3089fa9e4066Sahrens 
30907f1f55eaSvb160487 	if (recurse && parents) {
30917f1f55eaSvb160487 		(void) fprintf(stderr, gettext("-p and -r options are mutually "
30927f1f55eaSvb160487 		    "exclusive\n"));
30937f1f55eaSvb160487 		usage(B_FALSE);
30947f1f55eaSvb160487 	}
30957f1f55eaSvb160487 
3096cdf5b4caSmmusante 	if (recurse && strchr(argv[0], '@') == 0) {
3097cdf5b4caSmmusante 		(void) fprintf(stderr, gettext("source dataset for recursive "
3098cdf5b4caSmmusante 		    "rename must be a snapshot\n"));
3099cdf5b4caSmmusante 		usage(B_FALSE);
3100cdf5b4caSmmusante 	}
3101cdf5b4caSmmusante 
31027f1f55eaSvb160487 	if ((zhp = zfs_open(g_zfs, argv[0], parents ? ZFS_TYPE_FILESYSTEM |
3103990b4856Slling 	    ZFS_TYPE_VOLUME : ZFS_TYPE_DATASET)) == NULL)
3104fa9e4066Sahrens 		return (1);
3105fa9e4066Sahrens 
31067f1f55eaSvb160487 	/* If we were asked and the name looks good, try to create ancestors. */
31077f1f55eaSvb160487 	if (parents && zfs_name_valid(argv[1], zfs_get_type(zhp)) &&
31087f1f55eaSvb160487 	    zfs_create_ancestors(g_zfs, argv[1]) != 0) {
31097f1f55eaSvb160487 		zfs_close(zhp);
31107f1f55eaSvb160487 		return (1);
31117f1f55eaSvb160487 	}
31127f1f55eaSvb160487 
31136a9cb0eaSEric Schrock 	ret = (zfs_rename(zhp, argv[1], recurse, force_unmount) != 0);
3114fa9e4066Sahrens 
311599653d4eSeschrock 	zfs_close(zhp);
311699653d4eSeschrock 	return (ret);
311799653d4eSeschrock }
311899653d4eSeschrock 
311999653d4eSeschrock /*
312099653d4eSeschrock  * zfs promote <fs>
312199653d4eSeschrock  *
312299653d4eSeschrock  * Promotes the given clone fs to be the parent
312399653d4eSeschrock  */
312499653d4eSeschrock /* ARGSUSED */
312599653d4eSeschrock static int
312699653d4eSeschrock zfs_do_promote(int argc, char **argv)
312799653d4eSeschrock {
312899653d4eSeschrock 	zfs_handle_t *zhp;
312905c998d6SRichard Lowe 	int ret = 0;
313099653d4eSeschrock 
313199653d4eSeschrock 	/* check options */
313299653d4eSeschrock 	if (argc > 1 && argv[1][0] == '-') {
313399653d4eSeschrock 		(void) fprintf(stderr, gettext("invalid option '%c'\n"),
313499653d4eSeschrock 		    argv[1][1]);
313599653d4eSeschrock 		usage(B_FALSE);
313699653d4eSeschrock 	}
313799653d4eSeschrock 
313899653d4eSeschrock 	/* check number of arguments */
313999653d4eSeschrock 	if (argc < 2) {
314099653d4eSeschrock 		(void) fprintf(stderr, gettext("missing clone filesystem"
314199653d4eSeschrock 		    " argument\n"));
314299653d4eSeschrock 		usage(B_FALSE);
314399653d4eSeschrock 	}
314499653d4eSeschrock 	if (argc > 2) {
314599653d4eSeschrock 		(void) fprintf(stderr, gettext("too many arguments\n"));
314699653d4eSeschrock 		usage(B_FALSE);
314799653d4eSeschrock 	}
314899653d4eSeschrock 
314999653d4eSeschrock 	zhp = zfs_open(g_zfs, argv[1], ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
315099653d4eSeschrock 	if (zhp == NULL)
315199653d4eSeschrock 		return (1);
315299653d4eSeschrock 
315399653d4eSeschrock 	ret = (zfs_promote(zhp) != 0);
315499653d4eSeschrock 
315506eeb2adSek110237 
3156fa9e4066Sahrens 	zfs_close(zhp);
3157fa9e4066Sahrens 	return (ret);
3158fa9e4066Sahrens }
3159fa9e4066Sahrens 
3160fa9e4066Sahrens /*
3161f17c7ff8Sahrens  * zfs rollback [-rRf] <snapshot>
3162fa9e4066Sahrens  *
3163fa9e4066Sahrens  *	-r	Delete any intervening snapshots before doing rollback
3164fa9e4066Sahrens  *	-R	Delete any snapshots and their clones
3165f17c7ff8Sahrens  *	-f	ignored for backwards compatability
3166fa9e4066Sahrens  *
3167fa9e4066Sahrens  * Given a filesystem, rollback to a specific snapshot, discarding any changes
3168fa9e4066Sahrens  * since then and making it the active dataset.  If more recent snapshots exist,
3169fa9e4066Sahrens  * the command will complain unless the '-r' flag is given.
3170fa9e4066Sahrens  */
3171fa9e4066Sahrens typedef struct rollback_cbdata {
3172fa9e4066Sahrens 	uint64_t	cb_create;
317399653d4eSeschrock 	boolean_t	cb_first;
3174fa9e4066Sahrens 	int		cb_doclones;
3175fa9e4066Sahrens 	char		*cb_target;
3176fa9e4066Sahrens 	int		cb_error;
317799653d4eSeschrock 	boolean_t	cb_recurse;
317899653d4eSeschrock 	boolean_t	cb_dependent;
3179fa9e4066Sahrens } rollback_cbdata_t;
3180fa9e4066Sahrens 
3181fa9e4066Sahrens /*
3182fa9e4066Sahrens  * Report any snapshots more recent than the one specified.  Used when '-r' is
3183fa9e4066Sahrens  * not specified.  We reuse this same callback for the snapshot dependents - if
3184fa9e4066Sahrens  * 'cb_dependent' is set, then this is a dependent and we should report it
3185fa9e4066Sahrens  * without checking the transaction group.
3186fa9e4066Sahrens  */
3187fa9e4066Sahrens static int
3188fa9e4066Sahrens rollback_check(zfs_handle_t *zhp, void *data)
3189fa9e4066Sahrens {
3190fa9e4066Sahrens 	rollback_cbdata_t *cbp = data;
3191fa9e4066Sahrens 
319299653d4eSeschrock 	if (cbp->cb_doclones) {
319399653d4eSeschrock 		zfs_close(zhp);
3194fa9e4066Sahrens 		return (0);
319599653d4eSeschrock 	}
3196fa9e4066Sahrens 
3197fa9e4066Sahrens 	if (!cbp->cb_dependent) {
3198fa9e4066Sahrens 		if (strcmp(zfs_get_name(zhp), cbp->cb_target) != 0 &&
3199b12a1c38Slling 		    zfs_get_type(zhp) == ZFS_TYPE_SNAPSHOT &&
3200fa9e4066Sahrens 		    zfs_prop_get_int(zhp, ZFS_PROP_CREATETXG) >
3201fa9e4066Sahrens 		    cbp->cb_create) {
3202fa9e4066Sahrens 
3203fa9e4066Sahrens 			if (cbp->cb_first && !cbp->cb_recurse) {
3204fa9e4066Sahrens 				(void) fprintf(stderr, gettext("cannot "
3205fa9e4066Sahrens 				    "rollback to '%s': more recent snapshots "
3206fa9e4066Sahrens 				    "exist\n"),
3207fa9e4066Sahrens 				    cbp->cb_target);
3208fa9e4066Sahrens 				(void) fprintf(stderr, gettext("use '-r' to "
3209fa9e4066Sahrens 				    "force deletion of the following "
3210fa9e4066Sahrens 				    "snapshots:\n"));
3211fa9e4066Sahrens 				cbp->cb_first = 0;
3212fa9e4066Sahrens 				cbp->cb_error = 1;
3213fa9e4066Sahrens 			}
3214fa9e4066Sahrens 
3215fa9e4066Sahrens 			if (cbp->cb_recurse) {
321699653d4eSeschrock 				cbp->cb_dependent = B_TRUE;
32173bb79becSeschrock 				if (zfs_iter_dependents(zhp, B_TRUE,
32183bb79becSeschrock 				    rollback_check, cbp) != 0) {
32193bb79becSeschrock 					zfs_close(zhp);
32203bb79becSeschrock 					return (-1);
32213bb79becSeschrock 				}
322299653d4eSeschrock 				cbp->cb_dependent = B_FALSE;
3223fa9e4066Sahrens 			} else {
3224fa9e4066Sahrens 				(void) fprintf(stderr, "%s\n",
3225fa9e4066Sahrens 				    zfs_get_name(zhp));
3226fa9e4066Sahrens 			}
3227fa9e4066Sahrens 		}
3228fa9e4066Sahrens 	} else {
3229fa9e4066Sahrens 		if (cbp->cb_first && cbp->cb_recurse) {
3230fa9e4066Sahrens 			(void) fprintf(stderr, gettext("cannot rollback to "
3231fa9e4066Sahrens 			    "'%s': clones of previous snapshots exist\n"),
3232fa9e4066Sahrens 			    cbp->cb_target);
3233fa9e4066Sahrens 			(void) fprintf(stderr, gettext("use '-R' to "
3234fa9e4066Sahrens 			    "force deletion of the following clones and "
3235fa9e4066Sahrens 			    "dependents:\n"));
3236fa9e4066Sahrens 			cbp->cb_first = 0;
3237fa9e4066Sahrens 			cbp->cb_error = 1;
3238fa9e4066Sahrens 		}
3239fa9e4066Sahrens 
3240fa9e4066Sahrens 		(void) fprintf(stderr, "%s\n", zfs_get_name(zhp));
3241fa9e4066Sahrens 	}
3242fa9e4066Sahrens 
3243fa9e4066Sahrens 	zfs_close(zhp);
3244fa9e4066Sahrens 	return (0);
3245fa9e4066Sahrens }
3246fa9e4066Sahrens 
3247fa9e4066Sahrens static int
3248fa9e4066Sahrens zfs_do_rollback(int argc, char **argv)
3249fa9e4066Sahrens {
325005c998d6SRichard Lowe 	int ret = 0;
3251fa9e4066Sahrens 	int c;
3252c391e322Sahrens 	boolean_t force = B_FALSE;
3253fa9e4066Sahrens 	rollback_cbdata_t cb = { 0 };
3254fa9e4066Sahrens 	zfs_handle_t *zhp, *snap;
3255fa9e4066Sahrens 	char parentname[ZFS_MAXNAMELEN];
3256fa9e4066Sahrens 	char *delim;
3257fa9e4066Sahrens 
3258fa9e4066Sahrens 	/* check options */
3259f17c7ff8Sahrens 	while ((c = getopt(argc, argv, "rRf")) != -1) {
3260fa9e4066Sahrens 		switch (c) {
3261fa9e4066Sahrens 		case 'r':
3262fa9e4066Sahrens 			cb.cb_recurse = 1;
3263fa9e4066Sahrens 			break;
3264fa9e4066Sahrens 		case 'R':
3265fa9e4066Sahrens 			cb.cb_recurse = 1;
3266fa9e4066Sahrens 			cb.cb_doclones = 1;
3267fa9e4066Sahrens 			break;
3268f17c7ff8Sahrens 		case 'f':
3269c391e322Sahrens 			force = B_TRUE;
3270f17c7ff8Sahrens 			break;
3271fa9e4066Sahrens 		case '?':
3272fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
3273fa9e4066Sahrens 			    optopt);
327499653d4eSeschrock 			usage(B_FALSE);
3275fa9e4066Sahrens 		}
3276fa9e4066Sahrens 	}
3277fa9e4066Sahrens 
3278fa9e4066Sahrens 	argc -= optind;
3279fa9e4066Sahrens 	argv += optind;
3280fa9e4066Sahrens 
3281fa9e4066Sahrens 	/* check number of arguments */
3282fa9e4066Sahrens 	if (argc < 1) {
3283fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing dataset argument\n"));
328499653d4eSeschrock 		usage(B_FALSE);
3285fa9e4066Sahrens 	}
3286fa9e4066Sahrens 	if (argc > 1) {
3287fa9e4066Sahrens 		(void) fprintf(stderr, gettext("too many arguments\n"));
328899653d4eSeschrock 		usage(B_FALSE);
3289fa9e4066Sahrens 	}
3290fa9e4066Sahrens 
3291fa9e4066Sahrens 	/* open the snapshot */
329299653d4eSeschrock 	if ((snap = zfs_open(g_zfs, argv[0], ZFS_TYPE_SNAPSHOT)) == NULL)
3293fa9e4066Sahrens 		return (1);
3294fa9e4066Sahrens 
3295b12a1c38Slling 	/* open the parent dataset */
3296b12a1c38Slling 	(void) strlcpy(parentname, argv[0], sizeof (parentname));
3297fa9e4066Sahrens 	verify((delim = strrchr(parentname, '@')) != NULL);
3298fa9e4066Sahrens 	*delim = '\0';
3299990b4856Slling 	if ((zhp = zfs_open(g_zfs, parentname, ZFS_TYPE_DATASET)) == NULL) {
3300fa9e4066Sahrens 		zfs_close(snap);
3301fa9e4066Sahrens 		return (1);
3302fa9e4066Sahrens 	}
3303fa9e4066Sahrens 
3304fa9e4066Sahrens 	/*
3305fa9e4066Sahrens 	 * Check for more recent snapshots and/or clones based on the presence
3306fa9e4066Sahrens 	 * of '-r' and '-R'.
3307fa9e4066Sahrens 	 */
3308b12a1c38Slling 	cb.cb_target = argv[0];
3309b12a1c38Slling 	cb.cb_create = zfs_prop_get_int(snap, ZFS_PROP_CREATETXG);
331099653d4eSeschrock 	cb.cb_first = B_TRUE;
3311fa9e4066Sahrens 	cb.cb_error = 0;
33123bb79becSeschrock 	if ((ret = zfs_iter_children(zhp, rollback_check, &cb)) != 0)
33133bb79becSeschrock 		goto out;
3314fa9e4066Sahrens 
3315fa9e4066Sahrens 	if ((ret = cb.cb_error) != 0)
3316fa9e4066Sahrens 		goto out;
3317fa9e4066Sahrens 
3318fa9e4066Sahrens 	/*
3319b12a1c38Slling 	 * Rollback parent to the given snapshot.
3320fa9e4066Sahrens 	 */
3321c391e322Sahrens 	ret = zfs_rollback(zhp, snap, force);
3322fa9e4066Sahrens 
3323fa9e4066Sahrens out:
3324fa9e4066Sahrens 	zfs_close(snap);
3325fa9e4066Sahrens 	zfs_close(zhp);
3326fa9e4066Sahrens 
3327fa9e4066Sahrens 	if (ret == 0)
3328fa9e4066Sahrens 		return (0);
3329fa9e4066Sahrens 	else
3330fa9e4066Sahrens 		return (1);
3331fa9e4066Sahrens }
3332fa9e4066Sahrens 
3333fa9e4066Sahrens /*
3334fa9e4066Sahrens  * zfs set property=value { fs | snap | vol } ...
3335fa9e4066Sahrens  *
3336fa9e4066Sahrens  * Sets the given property for all datasets specified on the command line.
3337fa9e4066Sahrens  */
3338fa9e4066Sahrens typedef struct set_cbdata {
3339fa9e4066Sahrens 	char		*cb_propname;
3340fa9e4066Sahrens 	char		*cb_value;
3341fa9e4066Sahrens } set_cbdata_t;
3342fa9e4066Sahrens 
3343fa9e4066Sahrens static int
3344fa9e4066Sahrens set_callback(zfs_handle_t *zhp, void *data)
3345fa9e4066Sahrens {
3346fa9e4066Sahrens 	set_cbdata_t *cbp = data;
3347fa9e4066Sahrens 
3348e9dbad6fSeschrock 	if (zfs_prop_set(zhp, cbp->cb_propname, cbp->cb_value) != 0) {
3349efc555ebSnd150628 		switch (libzfs_errno(g_zfs)) {
3350efc555ebSnd150628 		case EZFS_MOUNTFAILED:
3351efc555ebSnd150628 			(void) fprintf(stderr, gettext("property may be set "
3352efc555ebSnd150628 			    "but unable to remount filesystem\n"));
3353efc555ebSnd150628 			break;
3354f3861e1aSahl 		case EZFS_SHARENFSFAILED:
3355efc555ebSnd150628 			(void) fprintf(stderr, gettext("property may be set "
3356efc555ebSnd150628 			    "but unable to reshare filesystem\n"));
3357efc555ebSnd150628 			break;
3358efc555ebSnd150628 		}
3359fa9e4066Sahrens 		return (1);
3360efc555ebSnd150628 	}
33615ad82045Snd150628 	return (0);
3362fa9e4066Sahrens }
3363fa9e4066Sahrens 
3364fa9e4066Sahrens static int
3365fa9e4066Sahrens zfs_do_set(int argc, char **argv)
3366fa9e4066Sahrens {
3367fa9e4066Sahrens 	set_cbdata_t cb;
336805c998d6SRichard Lowe 	int ret = 0;
3369fa9e4066Sahrens 
3370fa9e4066Sahrens 	/* check for options */
3371fa9e4066Sahrens 	if (argc > 1 && argv[1][0] == '-') {
3372fa9e4066Sahrens 		(void) fprintf(stderr, gettext("invalid option '%c'\n"),
3373fa9e4066Sahrens 		    argv[1][1]);
337499653d4eSeschrock 		usage(B_FALSE);
3375fa9e4066Sahrens 	}
3376fa9e4066Sahrens 
3377fa9e4066Sahrens 	/* check number of arguments */
3378fa9e4066Sahrens 	if (argc < 2) {
3379fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing property=value "
3380fa9e4066Sahrens 		    "argument\n"));
338199653d4eSeschrock 		usage(B_FALSE);
3382fa9e4066Sahrens 	}
3383fa9e4066Sahrens 	if (argc < 3) {
3384fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing dataset name\n"));
338599653d4eSeschrock 		usage(B_FALSE);
3386fa9e4066Sahrens 	}
3387fa9e4066Sahrens 
3388fa9e4066Sahrens 	/* validate property=value argument */
3389fa9e4066Sahrens 	cb.cb_propname = argv[1];
33904983ea4aSsg201626 	if (((cb.cb_value = strchr(cb.cb_propname, '=')) == NULL) ||
33914983ea4aSsg201626 	    (cb.cb_value[1] == '\0')) {
3392fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing value in "
3393fa9e4066Sahrens 		    "property=value argument\n"));
339499653d4eSeschrock 		usage(B_FALSE);
3395fa9e4066Sahrens 	}
3396fa9e4066Sahrens 
3397fa9e4066Sahrens 	*cb.cb_value = '\0';
3398fa9e4066Sahrens 	cb.cb_value++;
3399fa9e4066Sahrens 
3400fa9e4066Sahrens 	if (*cb.cb_propname == '\0') {
3401fa9e4066Sahrens 		(void) fprintf(stderr,
3402fa9e4066Sahrens 		    gettext("missing property in property=value argument\n"));
340399653d4eSeschrock 		usage(B_FALSE);
3404fa9e4066Sahrens 	}
3405fa9e4066Sahrens 
3406d5b5bb25SRich Morris 	ret = zfs_for_each(argc - 2, argv + 2, NULL,
3407ae1726b6SChris Gerhard 	    ZFS_TYPE_DATASET, NULL, NULL, 0, set_callback, &cb);
340806eeb2adSek110237 
340906eeb2adSek110237 	return (ret);
3410fa9e4066Sahrens }
3411fa9e4066Sahrens 
34124445fffbSMatthew Ahrens typedef struct snap_cbdata {
34134445fffbSMatthew Ahrens 	nvlist_t *sd_nvl;
34144445fffbSMatthew Ahrens 	boolean_t sd_recursive;
34154445fffbSMatthew Ahrens 	const char *sd_snapname;
34164445fffbSMatthew Ahrens } snap_cbdata_t;
34174445fffbSMatthew Ahrens 
34184445fffbSMatthew Ahrens static int
34194445fffbSMatthew Ahrens zfs_snapshot_cb(zfs_handle_t *zhp, void *arg)
34204445fffbSMatthew Ahrens {
34214445fffbSMatthew Ahrens 	snap_cbdata_t *sd = arg;
34224445fffbSMatthew Ahrens 	char *name;
34234445fffbSMatthew Ahrens 	int rv = 0;
34244445fffbSMatthew Ahrens 	int error;
34254445fffbSMatthew Ahrens 
34264445fffbSMatthew Ahrens 	error = asprintf(&name, "%s@%s", zfs_get_name(zhp), sd->sd_snapname);
34274445fffbSMatthew Ahrens 	if (error == -1)
34284445fffbSMatthew Ahrens 		nomem();
34294445fffbSMatthew Ahrens 	fnvlist_add_boolean(sd->sd_nvl, name);
34304445fffbSMatthew Ahrens 	free(name);
34314445fffbSMatthew Ahrens 
34324445fffbSMatthew Ahrens 	if (sd->sd_recursive)
34334445fffbSMatthew Ahrens 		rv = zfs_iter_filesystems(zhp, zfs_snapshot_cb, sd);
34344445fffbSMatthew Ahrens 	zfs_close(zhp);
34354445fffbSMatthew Ahrens 	return (rv);
34364445fffbSMatthew Ahrens }
34374445fffbSMatthew Ahrens 
3438fa9e4066Sahrens /*
3439bb0ade09Sahrens  * zfs snapshot [-r] [-o prop=value] ... <fs@snap>
3440fa9e4066Sahrens  *
3441fa9e4066Sahrens  * Creates a snapshot with the given name.  While functionally equivalent to
3442da6c28aaSamw  * 'zfs create', it is a separate command to differentiate intent.
3443fa9e4066Sahrens  */
3444fa9e4066Sahrens static int
3445fa9e4066Sahrens zfs_do_snapshot(int argc, char **argv)
3446fa9e4066Sahrens {
344705c998d6SRichard Lowe 	int ret = 0;
34481d452cf5Sahrens 	char c;
3449bb0ade09Sahrens 	nvlist_t *props;
34504445fffbSMatthew Ahrens 	snap_cbdata_t sd = { 0 };
34514445fffbSMatthew Ahrens 	boolean_t multiple_snaps = B_FALSE;
3452bb0ade09Sahrens 
3453a8b6ddafSMark J Musante 	if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0)
3454a8b6ddafSMark J Musante 		nomem();
34554445fffbSMatthew Ahrens 	if (nvlist_alloc(&sd.sd_nvl, NV_UNIQUE_NAME, 0) != 0)
34564445fffbSMatthew Ahrens 		nomem();
34571d452cf5Sahrens 
3458fa9e4066Sahrens 	/* check options */
3459bb0ade09Sahrens 	while ((c = getopt(argc, argv, "ro:")) != -1) {
34601d452cf5Sahrens 		switch (c) {
3461bb0ade09Sahrens 		case 'o':
3462bb0ade09Sahrens 			if (parseprop(props))
3463bb0ade09Sahrens 				return (1);
3464bb0ade09Sahrens 			break;
34651d452cf5Sahrens 		case 'r':
34664445fffbSMatthew Ahrens 			sd.sd_recursive = B_TRUE;
34674445fffbSMatthew Ahrens 			multiple_snaps = B_TRUE;
34681d452cf5Sahrens 			break;
34691d452cf5Sahrens 		case '?':
3470fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
34711d452cf5Sahrens 			    optopt);
3472bb0ade09Sahrens 			goto usage;
3473fa9e4066Sahrens 		}
34741d452cf5Sahrens 	}
34751d452cf5Sahrens 
34761d452cf5Sahrens 	argc -= optind;
34771d452cf5Sahrens 	argv += optind;
3478fa9e4066Sahrens 
3479fa9e4066Sahrens 	/* check number of arguments */
34801d452cf5Sahrens 	if (argc < 1) {
3481fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing snapshot argument\n"));
3482bb0ade09Sahrens 		goto usage;
3483fa9e4066Sahrens 	}
34844445fffbSMatthew Ahrens 
34854445fffbSMatthew Ahrens 	if (argc > 1)
34864445fffbSMatthew Ahrens 		multiple_snaps = B_TRUE;
34874445fffbSMatthew Ahrens 	for (; argc > 0; argc--, argv++) {
34884445fffbSMatthew Ahrens 		char *atp;
34894445fffbSMatthew Ahrens 		zfs_handle_t *zhp;
34904445fffbSMatthew Ahrens 
34914445fffbSMatthew Ahrens 		atp = strchr(argv[0], '@');
34924445fffbSMatthew Ahrens 		if (atp == NULL)
34934445fffbSMatthew Ahrens 			goto usage;
34944445fffbSMatthew Ahrens 		*atp = '\0';
34954445fffbSMatthew Ahrens 		sd.sd_snapname = atp + 1;
34964445fffbSMatthew Ahrens 		zhp = zfs_open(g_zfs, argv[0],
34974445fffbSMatthew Ahrens 		    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
34984445fffbSMatthew Ahrens 		if (zhp == NULL)
34994445fffbSMatthew Ahrens 			goto usage;
35004445fffbSMatthew Ahrens 		if (zfs_snapshot_cb(zhp, &sd) != 0)
3501bb0ade09Sahrens 			goto usage;
3502fa9e4066Sahrens 	}
3503fa9e4066Sahrens 
35044445fffbSMatthew Ahrens 	ret = zfs_snapshot_nvl(g_zfs, sd.sd_nvl, props);
35054445fffbSMatthew Ahrens 	nvlist_free(sd.sd_nvl);
3506bb0ade09Sahrens 	nvlist_free(props);
35074445fffbSMatthew Ahrens 	if (ret != 0 && multiple_snaps)
35081d452cf5Sahrens 		(void) fprintf(stderr, gettext("no snapshots were created\n"));
35091d452cf5Sahrens 	return (ret != 0);
3510bb0ade09Sahrens 
3511bb0ade09Sahrens usage:
35124445fffbSMatthew Ahrens 	nvlist_free(sd.sd_nvl);
3513bb0ade09Sahrens 	nvlist_free(props);
3514bb0ade09Sahrens 	usage(B_FALSE);
3515bb0ade09Sahrens 	return (-1);
3516fa9e4066Sahrens }
3517fa9e4066Sahrens 
3518fa9e4066Sahrens /*
3519fa9e4066Sahrens  * Send a backup stream to stdout.
3520fa9e4066Sahrens  */
3521fa9e4066Sahrens static int
3522f2a3c691Sahrens zfs_do_send(int argc, char **argv)
3523fa9e4066Sahrens {
3524fa9e4066Sahrens 	char *fromname = NULL;
35253cb34c60Sahrens 	char *toname = NULL;
3526a2eea2e1Sahrens 	char *cp;
3527a2eea2e1Sahrens 	zfs_handle_t *zhp;
35289e69d7d0SLori Alt 	sendflags_t flags = { 0 };
3529fa9e4066Sahrens 	int c, err;
353019b94df9SMatthew Ahrens 	nvlist_t *dbgnv = NULL;
35313f9d6ad7SLin Ling 	boolean_t extraverbose = B_FALSE;
3532fa9e4066Sahrens 
3533fa9e4066Sahrens 	/* check options */
353419b94df9SMatthew Ahrens 	while ((c = getopt(argc, argv, ":i:I:RDpvnP")) != -1) {
3535fa9e4066Sahrens 		switch (c) {
3536fa9e4066Sahrens 		case 'i':
3537a2eea2e1Sahrens 			if (fromname)
3538a2eea2e1Sahrens 				usage(B_FALSE);
3539fa9e4066Sahrens 			fromname = optarg;
3540fa9e4066Sahrens 			break;
35413cb34c60Sahrens 		case 'I':
35423cb34c60Sahrens 			if (fromname)
35433cb34c60Sahrens 				usage(B_FALSE);
35443cb34c60Sahrens 			fromname = optarg;
35459e69d7d0SLori Alt 			flags.doall = B_TRUE;
35463cb34c60Sahrens 			break;
35473cb34c60Sahrens 		case 'R':
35489e69d7d0SLori Alt 			flags.replicate = B_TRUE;
35493cb34c60Sahrens 			break;
355092241e0bSTom Erickson 		case 'p':
355192241e0bSTom Erickson 			flags.props = B_TRUE;
355292241e0bSTom Erickson 			break;
355319b94df9SMatthew Ahrens 		case 'P':
355419b94df9SMatthew Ahrens 			flags.parsable = B_TRUE;
355519b94df9SMatthew Ahrens 			flags.verbose = B_TRUE;
355619b94df9SMatthew Ahrens 			break;
35573cb34c60Sahrens 		case 'v':
35583f9d6ad7SLin Ling 			if (flags.verbose)
35593f9d6ad7SLin Ling 				extraverbose = B_TRUE;
35609e69d7d0SLori Alt 			flags.verbose = B_TRUE;
35614e3c9f44SBill Pijewski 			flags.progress = B_TRUE;
35629e69d7d0SLori Alt 			break;
35639e69d7d0SLori Alt 		case 'D':
35649e69d7d0SLori Alt 			flags.dedup = B_TRUE;
35653cb34c60Sahrens 			break;
356619b94df9SMatthew Ahrens 		case 'n':
356719b94df9SMatthew Ahrens 			flags.dryrun = B_TRUE;
356819b94df9SMatthew Ahrens 			break;
3569fa9e4066Sahrens 		case ':':
3570fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing argument for "
3571fa9e4066Sahrens 			    "'%c' option\n"), optopt);
357299653d4eSeschrock 			usage(B_FALSE);
3573fa9e4066Sahrens 			break;
3574fa9e4066Sahrens 		case '?':
3575fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
3576fa9e4066Sahrens 			    optopt);
357799653d4eSeschrock 			usage(B_FALSE);
3578fa9e4066Sahrens 		}
3579fa9e4066Sahrens 	}
3580fa9e4066Sahrens 
3581fa9e4066Sahrens 	argc -= optind;
3582fa9e4066Sahrens 	argv += optind;
3583fa9e4066Sahrens 
3584fa9e4066Sahrens 	/* check number of arguments */
3585fa9e4066Sahrens 	if (argc < 1) {
3586fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing snapshot argument\n"));
358799653d4eSeschrock 		usage(B_FALSE);
3588fa9e4066Sahrens 	}
3589fa9e4066Sahrens 	if (argc > 1) {
3590fa9e4066Sahrens 		(void) fprintf(stderr, gettext("too many arguments\n"));
359199653d4eSeschrock 		usage(B_FALSE);
3592fa9e4066Sahrens 	}
3593fa9e4066Sahrens 
359419b94df9SMatthew Ahrens 	if (!flags.dryrun && isatty(STDOUT_FILENO)) {
3595fa9e4066Sahrens 		(void) fprintf(stderr,
3596a2eea2e1Sahrens 		    gettext("Error: Stream can not be written to a terminal.\n"
3597fa9e4066Sahrens 		    "You must redirect standard output.\n"));
3598fa9e4066Sahrens 		return (1);
3599fa9e4066Sahrens 	}
3600fa9e4066Sahrens 
36013cb34c60Sahrens 	cp = strchr(argv[0], '@');
36023cb34c60Sahrens 	if (cp == NULL) {
36033cb34c60Sahrens 		(void) fprintf(stderr,
36043cb34c60Sahrens 		    gettext("argument must be a snapshot\n"));
36053cb34c60Sahrens 		usage(B_FALSE);
36063cb34c60Sahrens 	}
36073cb34c60Sahrens 	*cp = '\0';
36083cb34c60Sahrens 	toname = cp + 1;
36093cb34c60Sahrens 	zhp = zfs_open(g_zfs, argv[0], ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
36103cb34c60Sahrens 	if (zhp == NULL)
361198579b20Snd150628 		return (1);
361298579b20Snd150628 
361398579b20Snd150628 	/*
3614a2eea2e1Sahrens 	 * If they specified the full path to the snapshot, chop off
36153cb34c60Sahrens 	 * everything except the short name of the snapshot, but special
36163cb34c60Sahrens 	 * case if they specify the origin.
361798579b20Snd150628 	 */
3618a2eea2e1Sahrens 	if (fromname && (cp = strchr(fromname, '@')) != NULL) {
36193cb34c60Sahrens 		char origin[ZFS_MAXNAMELEN];
36203cb34c60Sahrens 		zprop_source_t src;
36213cb34c60Sahrens 
36223cb34c60Sahrens 		(void) zfs_prop_get(zhp, ZFS_PROP_ORIGIN,
36233cb34c60Sahrens 		    origin, sizeof (origin), &src, NULL, 0, B_FALSE);
36243cb34c60Sahrens 
36253cb34c60Sahrens 		if (strcmp(origin, fromname) == 0) {
36263cb34c60Sahrens 			fromname = NULL;
36279e69d7d0SLori Alt 			flags.fromorigin = B_TRUE;
36283cb34c60Sahrens 		} else {
36293cb34c60Sahrens 			*cp = '\0';
36303cb34c60Sahrens 			if (cp != fromname && strcmp(argv[0], fromname)) {
3631a2eea2e1Sahrens 				(void) fprintf(stderr,
3632a2eea2e1Sahrens 				    gettext("incremental source must be "
3633a2eea2e1Sahrens 				    "in same filesystem\n"));
3634a2eea2e1Sahrens 				usage(B_FALSE);
3635a2eea2e1Sahrens 			}
3636a2eea2e1Sahrens 			fromname = cp + 1;
3637a2eea2e1Sahrens 			if (strchr(fromname, '@') || strchr(fromname, '/')) {
3638a2eea2e1Sahrens 				(void) fprintf(stderr,
3639a2eea2e1Sahrens 				    gettext("invalid incremental source\n"));
3640a2eea2e1Sahrens 				usage(B_FALSE);
3641a2eea2e1Sahrens 			}
364298579b20Snd150628 		}
36433cb34c60Sahrens 	}
364498579b20Snd150628 
36459e69d7d0SLori Alt 	if (flags.replicate && fromname == NULL)
36469e69d7d0SLori Alt 		flags.doall = B_TRUE;
36473cb34c60Sahrens 
364819b94df9SMatthew Ahrens 	err = zfs_send(zhp, fromname, toname, &flags, STDOUT_FILENO, NULL, 0,
36493f9d6ad7SLin Ling 	    extraverbose ? &dbgnv : NULL);
36503f9d6ad7SLin Ling 
365119b94df9SMatthew Ahrens 	if (extraverbose && dbgnv != NULL) {
36523f9d6ad7SLin Ling 		/*
36533f9d6ad7SLin Ling 		 * dump_nvlist prints to stdout, but that's been
36543f9d6ad7SLin Ling 		 * redirected to a file.  Make it print to stderr
36553f9d6ad7SLin Ling 		 * instead.
36563f9d6ad7SLin Ling 		 */
36573f9d6ad7SLin Ling 		(void) dup2(STDERR_FILENO, STDOUT_FILENO);
36583f9d6ad7SLin Ling 		dump_nvlist(dbgnv, 0);
36593f9d6ad7SLin Ling 		nvlist_free(dbgnv);
36603f9d6ad7SLin Ling 	}
3661a2eea2e1Sahrens 	zfs_close(zhp);
3662fa9e4066Sahrens 
3663fa9e4066Sahrens 	return (err != 0);
3664fa9e4066Sahrens }
3665fa9e4066Sahrens 
3666fa9e4066Sahrens /*
3667b1d99cdfSTom Erickson  * zfs receive [-vnFu] [-d | -e] <fs@snap>
3668fa9e4066Sahrens  *
3669fa9e4066Sahrens  * Restore a backup stream from stdin.
3670fa9e4066Sahrens  */
3671fa9e4066Sahrens static int
3672f2a3c691Sahrens zfs_do_receive(int argc, char **argv)
3673fa9e4066Sahrens {
3674fa9e4066Sahrens 	int c, err;
367592241e0bSTom Erickson 	recvflags_t flags = { 0 };
3676fa9e4066Sahrens 
3677fa9e4066Sahrens 	/* check options */
3678f64930f5STom Erickson 	while ((c = getopt(argc, argv, ":denuvF")) != -1) {
3679fa9e4066Sahrens 		switch (c) {
3680fa9e4066Sahrens 		case 'd':
36813cb34c60Sahrens 			flags.isprefix = B_TRUE;
3682fa9e4066Sahrens 			break;
3683f64930f5STom Erickson 		case 'e':
3684f64930f5STom Erickson 			flags.isprefix = B_TRUE;
3685f64930f5STom Erickson 			flags.istail = B_TRUE;
3686f64930f5STom Erickson 			break;
3687fa9e4066Sahrens 		case 'n':
36883cb34c60Sahrens 			flags.dryrun = B_TRUE;
3689fa9e4066Sahrens 			break;
369033408eefSLori Alt 		case 'u':
369133408eefSLori Alt 			flags.nomount = B_TRUE;
369233408eefSLori Alt 			break;
3693fa9e4066Sahrens 		case 'v':
36943cb34c60Sahrens 			flags.verbose = B_TRUE;
3695fa9e4066Sahrens 			break;
369698579b20Snd150628 		case 'F':
36973cb34c60Sahrens 			flags.force = B_TRUE;
369898579b20Snd150628 			break;
3699fa9e4066Sahrens 		case ':':
3700fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing argument for "
3701fa9e4066Sahrens 			    "'%c' option\n"), optopt);
370299653d4eSeschrock 			usage(B_FALSE);
3703fa9e4066Sahrens 			break;
3704fa9e4066Sahrens 		case '?':
3705fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
3706fa9e4066Sahrens 			    optopt);
370799653d4eSeschrock 			usage(B_FALSE);
3708fa9e4066Sahrens 		}
3709fa9e4066Sahrens 	}
3710fa9e4066Sahrens 
3711fa9e4066Sahrens 	argc -= optind;
3712fa9e4066Sahrens 	argv += optind;
3713fa9e4066Sahrens 
3714fa9e4066Sahrens 	/* check number of arguments */
3715fa9e4066Sahrens 	if (argc < 1) {
3716fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing snapshot argument\n"));
371799653d4eSeschrock 		usage(B_FALSE);
3718fa9e4066Sahrens 	}
3719fa9e4066Sahrens 	if (argc > 1) {
3720fa9e4066Sahrens 		(void) fprintf(stderr, gettext("too many arguments\n"));
372199653d4eSeschrock 		usage(B_FALSE);
3722fa9e4066Sahrens 	}
3723fa9e4066Sahrens 
3724fa9e4066Sahrens 	if (isatty(STDIN_FILENO)) {
3725fa9e4066Sahrens 		(void) fprintf(stderr,
3726fa9e4066Sahrens 		    gettext("Error: Backup stream can not be read "
3727fa9e4066Sahrens 		    "from a terminal.\n"
3728fa9e4066Sahrens 		    "You must redirect standard input.\n"));
3729fa9e4066Sahrens 		return (1);
3730fa9e4066Sahrens 	}
3731fa9e4066Sahrens 
373219b94df9SMatthew Ahrens 	err = zfs_receive(g_zfs, argv[0], &flags, STDIN_FILENO, NULL);
373306eeb2adSek110237 
3734ecd6cf80Smarks 	return (err != 0);
373506eeb2adSek110237 }
373606eeb2adSek110237 
37371af68beaSAlexander Stetsenko /*
37381af68beaSAlexander Stetsenko  * allow/unallow stuff
37391af68beaSAlexander Stetsenko  */
37401af68beaSAlexander Stetsenko /* copied from zfs/sys/dsl_deleg.h */
37411af68beaSAlexander Stetsenko #define	ZFS_DELEG_PERM_CREATE		"create"
37421af68beaSAlexander Stetsenko #define	ZFS_DELEG_PERM_DESTROY		"destroy"
37431af68beaSAlexander Stetsenko #define	ZFS_DELEG_PERM_SNAPSHOT		"snapshot"
37441af68beaSAlexander Stetsenko #define	ZFS_DELEG_PERM_ROLLBACK		"rollback"
37451af68beaSAlexander Stetsenko #define	ZFS_DELEG_PERM_CLONE		"clone"
37461af68beaSAlexander Stetsenko #define	ZFS_DELEG_PERM_PROMOTE		"promote"
37471af68beaSAlexander Stetsenko #define	ZFS_DELEG_PERM_RENAME		"rename"
37481af68beaSAlexander Stetsenko #define	ZFS_DELEG_PERM_MOUNT		"mount"
37491af68beaSAlexander Stetsenko #define	ZFS_DELEG_PERM_SHARE		"share"
37501af68beaSAlexander Stetsenko #define	ZFS_DELEG_PERM_SEND		"send"
37511af68beaSAlexander Stetsenko #define	ZFS_DELEG_PERM_RECEIVE		"receive"
37521af68beaSAlexander Stetsenko #define	ZFS_DELEG_PERM_ALLOW		"allow"
37531af68beaSAlexander Stetsenko #define	ZFS_DELEG_PERM_USERPROP		"userprop"
37541af68beaSAlexander Stetsenko #define	ZFS_DELEG_PERM_VSCAN		"vscan" /* ??? */
37551af68beaSAlexander Stetsenko #define	ZFS_DELEG_PERM_USERQUOTA	"userquota"
37561af68beaSAlexander Stetsenko #define	ZFS_DELEG_PERM_GROUPQUOTA	"groupquota"
37571af68beaSAlexander Stetsenko #define	ZFS_DELEG_PERM_USERUSED		"userused"
37581af68beaSAlexander Stetsenko #define	ZFS_DELEG_PERM_GROUPUSED	"groupused"
37591af68beaSAlexander Stetsenko #define	ZFS_DELEG_PERM_HOLD		"hold"
37601af68beaSAlexander Stetsenko #define	ZFS_DELEG_PERM_RELEASE		"release"
37611af68beaSAlexander Stetsenko #define	ZFS_DELEG_PERM_DIFF		"diff"
37621af68beaSAlexander Stetsenko 
37631af68beaSAlexander Stetsenko #define	ZFS_NUM_DELEG_NOTES ZFS_DELEG_NOTE_NONE
37641af68beaSAlexander Stetsenko 
37651af68beaSAlexander Stetsenko static zfs_deleg_perm_tab_t zfs_deleg_perm_tbl[] = {
37661af68beaSAlexander Stetsenko 	{ ZFS_DELEG_PERM_ALLOW, ZFS_DELEG_NOTE_ALLOW },
37671af68beaSAlexander Stetsenko 	{ ZFS_DELEG_PERM_CLONE, ZFS_DELEG_NOTE_CLONE },
37681af68beaSAlexander Stetsenko 	{ ZFS_DELEG_PERM_CREATE, ZFS_DELEG_NOTE_CREATE },
37691af68beaSAlexander Stetsenko 	{ ZFS_DELEG_PERM_DESTROY, ZFS_DELEG_NOTE_DESTROY },
37701af68beaSAlexander Stetsenko 	{ ZFS_DELEG_PERM_DIFF, ZFS_DELEG_NOTE_DIFF},
37711af68beaSAlexander Stetsenko 	{ ZFS_DELEG_PERM_HOLD, ZFS_DELEG_NOTE_HOLD },
37721af68beaSAlexander Stetsenko 	{ ZFS_DELEG_PERM_MOUNT, ZFS_DELEG_NOTE_MOUNT },
37731af68beaSAlexander Stetsenko 	{ ZFS_DELEG_PERM_PROMOTE, ZFS_DELEG_NOTE_PROMOTE },
37741af68beaSAlexander Stetsenko 	{ ZFS_DELEG_PERM_RECEIVE, ZFS_DELEG_NOTE_RECEIVE },
37751af68beaSAlexander Stetsenko 	{ ZFS_DELEG_PERM_RELEASE, ZFS_DELEG_NOTE_RELEASE },
37761af68beaSAlexander Stetsenko 	{ ZFS_DELEG_PERM_RENAME, ZFS_DELEG_NOTE_RENAME },
37771af68beaSAlexander Stetsenko 	{ ZFS_DELEG_PERM_ROLLBACK, ZFS_DELEG_NOTE_ROLLBACK },
37781af68beaSAlexander Stetsenko 	{ ZFS_DELEG_PERM_SEND, ZFS_DELEG_NOTE_SEND },
37791af68beaSAlexander Stetsenko 	{ ZFS_DELEG_PERM_SHARE, ZFS_DELEG_NOTE_SHARE },
37801af68beaSAlexander Stetsenko 	{ ZFS_DELEG_PERM_SNAPSHOT, ZFS_DELEG_NOTE_SNAPSHOT },
37811af68beaSAlexander Stetsenko 
37821af68beaSAlexander Stetsenko 	{ ZFS_DELEG_PERM_GROUPQUOTA, ZFS_DELEG_NOTE_GROUPQUOTA },
37831af68beaSAlexander Stetsenko 	{ ZFS_DELEG_PERM_GROUPUSED, ZFS_DELEG_NOTE_GROUPUSED },
37841af68beaSAlexander Stetsenko 	{ ZFS_DELEG_PERM_USERPROP, ZFS_DELEG_NOTE_USERPROP },
37851af68beaSAlexander Stetsenko 	{ ZFS_DELEG_PERM_USERQUOTA, ZFS_DELEG_NOTE_USERQUOTA },
37861af68beaSAlexander Stetsenko 	{ ZFS_DELEG_PERM_USERUSED, ZFS_DELEG_NOTE_USERUSED },
37871af68beaSAlexander Stetsenko 	{ NULL, ZFS_DELEG_NOTE_NONE }
37881af68beaSAlexander Stetsenko };
37891af68beaSAlexander Stetsenko 
37901af68beaSAlexander Stetsenko /* permission structure */
37911af68beaSAlexander Stetsenko typedef struct deleg_perm {
37921af68beaSAlexander Stetsenko 	zfs_deleg_who_type_t	dp_who_type;
37931af68beaSAlexander Stetsenko 	const char		*dp_name;
37941af68beaSAlexander Stetsenko 	boolean_t		dp_local;
37951af68beaSAlexander Stetsenko 	boolean_t		dp_descend;
37961af68beaSAlexander Stetsenko } deleg_perm_t;
37971af68beaSAlexander Stetsenko 
37981af68beaSAlexander Stetsenko /* */
37991af68beaSAlexander Stetsenko typedef struct deleg_perm_node {
38001af68beaSAlexander Stetsenko 	deleg_perm_t		dpn_perm;
38011af68beaSAlexander Stetsenko 
38021af68beaSAlexander Stetsenko 	uu_avl_node_t		dpn_avl_node;
38031af68beaSAlexander Stetsenko } deleg_perm_node_t;
38041af68beaSAlexander Stetsenko 
38051af68beaSAlexander Stetsenko typedef struct fs_perm fs_perm_t;
38061af68beaSAlexander Stetsenko 
38071af68beaSAlexander Stetsenko /* permissions set */
38081af68beaSAlexander Stetsenko typedef struct who_perm {
38091af68beaSAlexander Stetsenko 	zfs_deleg_who_type_t	who_type;
38101af68beaSAlexander Stetsenko 	const char		*who_name;		/* id */
38111af68beaSAlexander Stetsenko 	char			who_ug_name[256];	/* user/group name */
38121af68beaSAlexander Stetsenko 	fs_perm_t		*who_fsperm;		/* uplink */
38131af68beaSAlexander Stetsenko 
38141af68beaSAlexander Stetsenko 	uu_avl_t		*who_deleg_perm_avl;	/* permissions */
38151af68beaSAlexander Stetsenko } who_perm_t;
38161af68beaSAlexander Stetsenko 
38171af68beaSAlexander Stetsenko /* */
38181af68beaSAlexander Stetsenko typedef struct who_perm_node {
38191af68beaSAlexander Stetsenko 	who_perm_t	who_perm;
38201af68beaSAlexander Stetsenko 	uu_avl_node_t	who_avl_node;
38211af68beaSAlexander Stetsenko } who_perm_node_t;
38221af68beaSAlexander Stetsenko 
38231af68beaSAlexander Stetsenko typedef struct fs_perm_set fs_perm_set_t;
38241af68beaSAlexander Stetsenko /* fs permissions */
38251af68beaSAlexander Stetsenko struct fs_perm {
38261af68beaSAlexander Stetsenko 	const char		*fsp_name;
38271af68beaSAlexander Stetsenko 
38281af68beaSAlexander Stetsenko 	uu_avl_t		*fsp_sc_avl;	/* sets,create */
38291af68beaSAlexander Stetsenko 	uu_avl_t		*fsp_uge_avl;	/* user,group,everyone */
38301af68beaSAlexander Stetsenko 
38311af68beaSAlexander Stetsenko 	fs_perm_set_t		*fsp_set;	/* uplink */
38321af68beaSAlexander Stetsenko };
38331af68beaSAlexander Stetsenko 
38341af68beaSAlexander Stetsenko /* */
38351af68beaSAlexander Stetsenko typedef struct fs_perm_node {
38361af68beaSAlexander Stetsenko 	fs_perm_t	fspn_fsperm;
38371af68beaSAlexander Stetsenko 	uu_avl_t	*fspn_avl;
38381af68beaSAlexander Stetsenko 
38391af68beaSAlexander Stetsenko 	uu_list_node_t	fspn_list_node;
38401af68beaSAlexander Stetsenko } fs_perm_node_t;
38411af68beaSAlexander Stetsenko 
38421af68beaSAlexander Stetsenko /* top level structure */
38431af68beaSAlexander Stetsenko struct fs_perm_set {
38441af68beaSAlexander Stetsenko 	uu_list_pool_t	*fsps_list_pool;
38451af68beaSAlexander Stetsenko 	uu_list_t	*fsps_list; /* list of fs_perms */
38461af68beaSAlexander Stetsenko 
38471af68beaSAlexander Stetsenko 	uu_avl_pool_t	*fsps_named_set_avl_pool;
38481af68beaSAlexander Stetsenko 	uu_avl_pool_t	*fsps_who_perm_avl_pool;
38491af68beaSAlexander Stetsenko 	uu_avl_pool_t	*fsps_deleg_perm_avl_pool;
38501af68beaSAlexander Stetsenko };
38511af68beaSAlexander Stetsenko 
38521af68beaSAlexander Stetsenko static inline const char *
38531af68beaSAlexander Stetsenko deleg_perm_type(zfs_deleg_note_t note)
38541af68beaSAlexander Stetsenko {
38551af68beaSAlexander Stetsenko 	/* subcommands */
38561af68beaSAlexander Stetsenko 	switch (note) {
38571af68beaSAlexander Stetsenko 		/* SUBCOMMANDS */
38581af68beaSAlexander Stetsenko 		/* OTHER */
38591af68beaSAlexander Stetsenko 	case ZFS_DELEG_NOTE_GROUPQUOTA:
38601af68beaSAlexander Stetsenko 	case ZFS_DELEG_NOTE_GROUPUSED:
38611af68beaSAlexander Stetsenko 	case ZFS_DELEG_NOTE_USERPROP:
38621af68beaSAlexander Stetsenko 	case ZFS_DELEG_NOTE_USERQUOTA:
38631af68beaSAlexander Stetsenko 	case ZFS_DELEG_NOTE_USERUSED:
38641af68beaSAlexander Stetsenko 		/* other */
38651af68beaSAlexander Stetsenko 		return (gettext("other"));
38661af68beaSAlexander Stetsenko 	default:
38671af68beaSAlexander Stetsenko 		return (gettext("subcommand"));
38681af68beaSAlexander Stetsenko 	}
38691af68beaSAlexander Stetsenko }
38701af68beaSAlexander Stetsenko 
38711af68beaSAlexander Stetsenko static int inline
38721af68beaSAlexander Stetsenko who_type2weight(zfs_deleg_who_type_t who_type)
38731af68beaSAlexander Stetsenko {
38741af68beaSAlexander Stetsenko 	int res;
38751af68beaSAlexander Stetsenko 	switch (who_type) {
38761af68beaSAlexander Stetsenko 		case ZFS_DELEG_NAMED_SET_SETS:
38771af68beaSAlexander Stetsenko 		case ZFS_DELEG_NAMED_SET:
38781af68beaSAlexander Stetsenko 			res = 0;
38791af68beaSAlexander Stetsenko 			break;
38801af68beaSAlexander Stetsenko 		case ZFS_DELEG_CREATE_SETS:
38811af68beaSAlexander Stetsenko 		case ZFS_DELEG_CREATE:
38821af68beaSAlexander Stetsenko 			res = 1;
38831af68beaSAlexander Stetsenko 			break;
38841af68beaSAlexander Stetsenko 		case ZFS_DELEG_USER_SETS:
38851af68beaSAlexander Stetsenko 		case ZFS_DELEG_USER:
38861af68beaSAlexander Stetsenko 			res = 2;
38871af68beaSAlexander Stetsenko 			break;
38881af68beaSAlexander Stetsenko 		case ZFS_DELEG_GROUP_SETS:
38891af68beaSAlexander Stetsenko 		case ZFS_DELEG_GROUP:
38901af68beaSAlexander Stetsenko 			res = 3;
38911af68beaSAlexander Stetsenko 			break;
38921af68beaSAlexander Stetsenko 		case ZFS_DELEG_EVERYONE_SETS:
38931af68beaSAlexander Stetsenko 		case ZFS_DELEG_EVERYONE:
38941af68beaSAlexander Stetsenko 			res = 4;
38951af68beaSAlexander Stetsenko 			break;
38961af68beaSAlexander Stetsenko 		default:
38971af68beaSAlexander Stetsenko 			res = -1;
38981af68beaSAlexander Stetsenko 	}
38991af68beaSAlexander Stetsenko 
39001af68beaSAlexander Stetsenko 	return (res);
39011af68beaSAlexander Stetsenko }
39021af68beaSAlexander Stetsenko 
39031af68beaSAlexander Stetsenko /* ARGSUSED */
39041af68beaSAlexander Stetsenko static int
39051af68beaSAlexander Stetsenko who_perm_compare(const void *larg, const void *rarg, void *unused)
39061af68beaSAlexander Stetsenko {
39071af68beaSAlexander Stetsenko 	const who_perm_node_t *l = larg;
39081af68beaSAlexander Stetsenko 	const who_perm_node_t *r = rarg;
39091af68beaSAlexander Stetsenko 	zfs_deleg_who_type_t ltype = l->who_perm.who_type;
39101af68beaSAlexander Stetsenko 	zfs_deleg_who_type_t rtype = r->who_perm.who_type;
39111af68beaSAlexander Stetsenko 	int lweight = who_type2weight(ltype);
39121af68beaSAlexander Stetsenko 	int rweight = who_type2weight(rtype);
39131af68beaSAlexander Stetsenko 	int res = lweight - rweight;
39141af68beaSAlexander Stetsenko 	if (res == 0)
39151af68beaSAlexander Stetsenko 		res = strncmp(l->who_perm.who_name, r->who_perm.who_name,
39161af68beaSAlexander Stetsenko 		    ZFS_MAX_DELEG_NAME-1);
39171af68beaSAlexander Stetsenko 
39181af68beaSAlexander Stetsenko 	if (res == 0)
39191af68beaSAlexander Stetsenko 		return (0);
39201af68beaSAlexander Stetsenko 	if (res > 0)
39211af68beaSAlexander Stetsenko 		return (1);
39221af68beaSAlexander Stetsenko 	else
39231af68beaSAlexander Stetsenko 		return (-1);
39241af68beaSAlexander Stetsenko }
39251af68beaSAlexander Stetsenko 
39261af68beaSAlexander Stetsenko /* ARGSUSED */
39271af68beaSAlexander Stetsenko static int
39281af68beaSAlexander Stetsenko deleg_perm_compare(const void *larg, const void *rarg, void *unused)
39291af68beaSAlexander Stetsenko {
39301af68beaSAlexander Stetsenko 	const deleg_perm_node_t *l = larg;
39311af68beaSAlexander Stetsenko 	const deleg_perm_node_t *r = rarg;
39321af68beaSAlexander Stetsenko 	int res =  strncmp(l->dpn_perm.dp_name, r->dpn_perm.dp_name,
39331af68beaSAlexander Stetsenko 	    ZFS_MAX_DELEG_NAME-1);
39341af68beaSAlexander Stetsenko 
39351af68beaSAlexander Stetsenko 	if (res == 0)
39361af68beaSAlexander Stetsenko 		return (0);
39371af68beaSAlexander Stetsenko 
39381af68beaSAlexander Stetsenko 	if (res > 0)
39391af68beaSAlexander Stetsenko 		return (1);
39401af68beaSAlexander Stetsenko 	else
39411af68beaSAlexander Stetsenko 		return (-1);
39421af68beaSAlexander Stetsenko }
39431af68beaSAlexander Stetsenko 
39441af68beaSAlexander Stetsenko static inline void
39451af68beaSAlexander Stetsenko fs_perm_set_init(fs_perm_set_t *fspset)
39461af68beaSAlexander Stetsenko {
39471af68beaSAlexander Stetsenko 	bzero(fspset, sizeof (fs_perm_set_t));
39481af68beaSAlexander Stetsenko 
39491af68beaSAlexander Stetsenko 	if ((fspset->fsps_list_pool = uu_list_pool_create("fsps_list_pool",
39501af68beaSAlexander Stetsenko 	    sizeof (fs_perm_node_t), offsetof(fs_perm_node_t, fspn_list_node),
39511af68beaSAlexander Stetsenko 	    NULL, UU_DEFAULT)) == NULL)
39521af68beaSAlexander Stetsenko 		nomem();
39531af68beaSAlexander Stetsenko 	if ((fspset->fsps_list = uu_list_create(fspset->fsps_list_pool, NULL,
39541af68beaSAlexander Stetsenko 	    UU_DEFAULT)) == NULL)
39551af68beaSAlexander Stetsenko 		nomem();
39561af68beaSAlexander Stetsenko 
39571af68beaSAlexander Stetsenko 	if ((fspset->fsps_named_set_avl_pool = uu_avl_pool_create(
39581af68beaSAlexander Stetsenko 	    "named_set_avl_pool", sizeof (who_perm_node_t), offsetof(
39591af68beaSAlexander Stetsenko 	    who_perm_node_t, who_avl_node), who_perm_compare,
39601af68beaSAlexander Stetsenko 	    UU_DEFAULT)) == NULL)
39611af68beaSAlexander Stetsenko 		nomem();
39621af68beaSAlexander Stetsenko 
39631af68beaSAlexander Stetsenko 	if ((fspset->fsps_who_perm_avl_pool = uu_avl_pool_create(
39641af68beaSAlexander Stetsenko 	    "who_perm_avl_pool", sizeof (who_perm_node_t), offsetof(
39651af68beaSAlexander Stetsenko 	    who_perm_node_t, who_avl_node), who_perm_compare,
39661af68beaSAlexander Stetsenko 	    UU_DEFAULT)) == NULL)
39671af68beaSAlexander Stetsenko 		nomem();
39681af68beaSAlexander Stetsenko 
39691af68beaSAlexander Stetsenko 	if ((fspset->fsps_deleg_perm_avl_pool = uu_avl_pool_create(
39701af68beaSAlexander Stetsenko 	    "deleg_perm_avl_pool", sizeof (deleg_perm_node_t), offsetof(
39711af68beaSAlexander Stetsenko 	    deleg_perm_node_t, dpn_avl_node), deleg_perm_compare, UU_DEFAULT))
39721af68beaSAlexander Stetsenko 	    == NULL)
39731af68beaSAlexander Stetsenko 		nomem();
39741af68beaSAlexander Stetsenko }
39751af68beaSAlexander Stetsenko 
39761af68beaSAlexander Stetsenko static inline void fs_perm_fini(fs_perm_t *);
39771af68beaSAlexander Stetsenko static inline void who_perm_fini(who_perm_t *);
39781af68beaSAlexander Stetsenko 
39791af68beaSAlexander Stetsenko static inline void
39801af68beaSAlexander Stetsenko fs_perm_set_fini(fs_perm_set_t *fspset)
39811af68beaSAlexander Stetsenko {
39821af68beaSAlexander Stetsenko 	fs_perm_node_t *node = uu_list_first(fspset->fsps_list);
39831af68beaSAlexander Stetsenko 
39841af68beaSAlexander Stetsenko 	while (node != NULL) {
39851af68beaSAlexander Stetsenko 		fs_perm_node_t *next_node =
39861af68beaSAlexander Stetsenko 		    uu_list_next(fspset->fsps_list, node);
39871af68beaSAlexander Stetsenko 		fs_perm_t *fsperm = &node->fspn_fsperm;
39881af68beaSAlexander Stetsenko 		fs_perm_fini(fsperm);
39891af68beaSAlexander Stetsenko 		uu_list_remove(fspset->fsps_list, node);
39901af68beaSAlexander Stetsenko 		free(node);
39911af68beaSAlexander Stetsenko 		node = next_node;
39921af68beaSAlexander Stetsenko 	}
39931af68beaSAlexander Stetsenko 
39941af68beaSAlexander Stetsenko 	uu_avl_pool_destroy(fspset->fsps_named_set_avl_pool);
39951af68beaSAlexander Stetsenko 	uu_avl_pool_destroy(fspset->fsps_who_perm_avl_pool);
39961af68beaSAlexander Stetsenko 	uu_avl_pool_destroy(fspset->fsps_deleg_perm_avl_pool);
39971af68beaSAlexander Stetsenko }
39981af68beaSAlexander Stetsenko 
39991af68beaSAlexander Stetsenko static inline void
40001af68beaSAlexander Stetsenko deleg_perm_init(deleg_perm_t *deleg_perm, zfs_deleg_who_type_t type,
40011af68beaSAlexander Stetsenko     const char *name)
40021af68beaSAlexander Stetsenko {
40031af68beaSAlexander Stetsenko 	deleg_perm->dp_who_type = type;
40041af68beaSAlexander Stetsenko 	deleg_perm->dp_name = name;
40051af68beaSAlexander Stetsenko }
40061af68beaSAlexander Stetsenko 
40071af68beaSAlexander Stetsenko static inline void
40081af68beaSAlexander Stetsenko who_perm_init(who_perm_t *who_perm, fs_perm_t *fsperm,
40091af68beaSAlexander Stetsenko     zfs_deleg_who_type_t type, const char *name)
40101af68beaSAlexander Stetsenko {
40111af68beaSAlexander Stetsenko 	uu_avl_pool_t	*pool;
40121af68beaSAlexander Stetsenko 	pool = fsperm->fsp_set->fsps_deleg_perm_avl_pool;
40131af68beaSAlexander Stetsenko 
40141af68beaSAlexander Stetsenko 	bzero(who_perm, sizeof (who_perm_t));
40151af68beaSAlexander Stetsenko 
40161af68beaSAlexander Stetsenko 	if ((who_perm->who_deleg_perm_avl = uu_avl_create(pool, NULL,
40171af68beaSAlexander Stetsenko 	    UU_DEFAULT)) == NULL)
40181af68beaSAlexander Stetsenko 		nomem();
40191af68beaSAlexander Stetsenko 
40201af68beaSAlexander Stetsenko 	who_perm->who_type = type;
40211af68beaSAlexander Stetsenko 	who_perm->who_name = name;
40221af68beaSAlexander Stetsenko 	who_perm->who_fsperm = fsperm;
40231af68beaSAlexander Stetsenko }
40241af68beaSAlexander Stetsenko 
40251af68beaSAlexander Stetsenko static inline void
40261af68beaSAlexander Stetsenko who_perm_fini(who_perm_t *who_perm)
40271af68beaSAlexander Stetsenko {
40281af68beaSAlexander Stetsenko 	deleg_perm_node_t *node = uu_avl_first(who_perm->who_deleg_perm_avl);
40291af68beaSAlexander Stetsenko 
40301af68beaSAlexander Stetsenko 	while (node != NULL) {
40311af68beaSAlexander Stetsenko 		deleg_perm_node_t *next_node =
40321af68beaSAlexander Stetsenko 		    uu_avl_next(who_perm->who_deleg_perm_avl, node);
40331af68beaSAlexander Stetsenko 
40341af68beaSAlexander Stetsenko 		uu_avl_remove(who_perm->who_deleg_perm_avl, node);
40351af68beaSAlexander Stetsenko 		free(node);
40361af68beaSAlexander Stetsenko 		node = next_node;
40371af68beaSAlexander Stetsenko 	}
40381af68beaSAlexander Stetsenko 
40391af68beaSAlexander Stetsenko 	uu_avl_destroy(who_perm->who_deleg_perm_avl);
40401af68beaSAlexander Stetsenko }
40411af68beaSAlexander Stetsenko 
40421af68beaSAlexander Stetsenko static inline void
40431af68beaSAlexander Stetsenko fs_perm_init(fs_perm_t *fsperm, fs_perm_set_t *fspset, const char *fsname)
40441af68beaSAlexander Stetsenko {
40451af68beaSAlexander Stetsenko 	uu_avl_pool_t	*nset_pool = fspset->fsps_named_set_avl_pool;
40461af68beaSAlexander Stetsenko 	uu_avl_pool_t	*who_pool = fspset->fsps_who_perm_avl_pool;
40471af68beaSAlexander Stetsenko 
40481af68beaSAlexander Stetsenko 	bzero(fsperm, sizeof (fs_perm_t));
40491af68beaSAlexander Stetsenko 
40501af68beaSAlexander Stetsenko 	if ((fsperm->fsp_sc_avl = uu_avl_create(nset_pool, NULL, UU_DEFAULT))
40511af68beaSAlexander Stetsenko 	    == NULL)
40521af68beaSAlexander Stetsenko 		nomem();
40531af68beaSAlexander Stetsenko 
40541af68beaSAlexander Stetsenko 	if ((fsperm->fsp_uge_avl = uu_avl_create(who_pool, NULL, UU_DEFAULT))
40551af68beaSAlexander Stetsenko 	    == NULL)
40561af68beaSAlexander Stetsenko 		nomem();
40571af68beaSAlexander Stetsenko 
40581af68beaSAlexander Stetsenko 	fsperm->fsp_set = fspset;
40591af68beaSAlexander Stetsenko 	fsperm->fsp_name = fsname;
40601af68beaSAlexander Stetsenko }
40611af68beaSAlexander Stetsenko 
40621af68beaSAlexander Stetsenko static inline void
40631af68beaSAlexander Stetsenko fs_perm_fini(fs_perm_t *fsperm)
40641af68beaSAlexander Stetsenko {
40651af68beaSAlexander Stetsenko 	who_perm_node_t *node = uu_avl_first(fsperm->fsp_sc_avl);
40661af68beaSAlexander Stetsenko 	while (node != NULL) {
40671af68beaSAlexander Stetsenko 		who_perm_node_t *next_node = uu_avl_next(fsperm->fsp_sc_avl,
40681af68beaSAlexander Stetsenko 		    node);
40691af68beaSAlexander Stetsenko 		who_perm_t *who_perm = &node->who_perm;
40701af68beaSAlexander Stetsenko 		who_perm_fini(who_perm);
40711af68beaSAlexander Stetsenko 		uu_avl_remove(fsperm->fsp_sc_avl, node);
40721af68beaSAlexander Stetsenko 		free(node);
40731af68beaSAlexander Stetsenko 		node = next_node;
40741af68beaSAlexander Stetsenko 	}
40751af68beaSAlexander Stetsenko 
40761af68beaSAlexander Stetsenko 	node = uu_avl_first(fsperm->fsp_uge_avl);
40771af68beaSAlexander Stetsenko 	while (node != NULL) {
40781af68beaSAlexander Stetsenko 		who_perm_node_t *next_node = uu_avl_next(fsperm->fsp_uge_avl,
40791af68beaSAlexander Stetsenko 		    node);
40801af68beaSAlexander Stetsenko 		who_perm_t *who_perm = &node->who_perm;
40811af68beaSAlexander Stetsenko 		who_perm_fini(who_perm);
40821af68beaSAlexander Stetsenko 		uu_avl_remove(fsperm->fsp_uge_avl, node);
40831af68beaSAlexander Stetsenko 		free(node);
40841af68beaSAlexander Stetsenko 		node = next_node;
40851af68beaSAlexander Stetsenko 	}
40861af68beaSAlexander Stetsenko 
40871af68beaSAlexander Stetsenko 	uu_avl_destroy(fsperm->fsp_sc_avl);
40881af68beaSAlexander Stetsenko 	uu_avl_destroy(fsperm->fsp_uge_avl);
40891af68beaSAlexander Stetsenko }
40901af68beaSAlexander Stetsenko 
40911af68beaSAlexander Stetsenko static void inline
40921af68beaSAlexander Stetsenko set_deleg_perm_node(uu_avl_t *avl, deleg_perm_node_t *node,
40931af68beaSAlexander Stetsenko     zfs_deleg_who_type_t who_type, const char *name, char locality)
40941af68beaSAlexander Stetsenko {
40951af68beaSAlexander Stetsenko 	uu_avl_index_t idx = 0;
40961af68beaSAlexander Stetsenko 
40971af68beaSAlexander Stetsenko 	deleg_perm_node_t *found_node = NULL;
40981af68beaSAlexander Stetsenko 	deleg_perm_t	*deleg_perm = &node->dpn_perm;
40991af68beaSAlexander Stetsenko 
41001af68beaSAlexander Stetsenko 	deleg_perm_init(deleg_perm, who_type, name);
41011af68beaSAlexander Stetsenko 
41021af68beaSAlexander Stetsenko 	if ((found_node = uu_avl_find(avl, node, NULL, &idx))
41031af68beaSAlexander Stetsenko 	    == NULL)
41041af68beaSAlexander Stetsenko 		uu_avl_insert(avl, node, idx);
41051af68beaSAlexander Stetsenko 	else {
41061af68beaSAlexander Stetsenko 		node = found_node;
41071af68beaSAlexander Stetsenko 		deleg_perm = &node->dpn_perm;
41081af68beaSAlexander Stetsenko 	}
41091af68beaSAlexander Stetsenko 
41101af68beaSAlexander Stetsenko 
41111af68beaSAlexander Stetsenko 	switch (locality) {
41121af68beaSAlexander Stetsenko 	case ZFS_DELEG_LOCAL:
41131af68beaSAlexander Stetsenko 		deleg_perm->dp_local = B_TRUE;
41141af68beaSAlexander Stetsenko 		break;
41151af68beaSAlexander Stetsenko 	case ZFS_DELEG_DESCENDENT:
41161af68beaSAlexander Stetsenko 		deleg_perm->dp_descend = B_TRUE;
41171af68beaSAlexander Stetsenko 		break;
41181af68beaSAlexander Stetsenko 	case ZFS_DELEG_NA:
41191af68beaSAlexander Stetsenko 		break;
41201af68beaSAlexander Stetsenko 	default:
41211af68beaSAlexander Stetsenko 		assert(B_FALSE); /* invalid locality */
41221af68beaSAlexander Stetsenko 	}
41231af68beaSAlexander Stetsenko }
41241af68beaSAlexander Stetsenko 
41251af68beaSAlexander Stetsenko static inline int
41261af68beaSAlexander Stetsenko parse_who_perm(who_perm_t *who_perm, nvlist_t *nvl, char locality)
41271af68beaSAlexander Stetsenko {
41281af68beaSAlexander Stetsenko 	nvpair_t *nvp = NULL;
41291af68beaSAlexander Stetsenko 	fs_perm_set_t *fspset = who_perm->who_fsperm->fsp_set;
41301af68beaSAlexander Stetsenko 	uu_avl_t *avl = who_perm->who_deleg_perm_avl;
41311af68beaSAlexander Stetsenko 	zfs_deleg_who_type_t who_type = who_perm->who_type;
41321af68beaSAlexander Stetsenko 
41331af68beaSAlexander Stetsenko 	while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
41341af68beaSAlexander Stetsenko 		const char *name = nvpair_name(nvp);
41351af68beaSAlexander Stetsenko 		data_type_t type = nvpair_type(nvp);
41361af68beaSAlexander Stetsenko 		uu_avl_pool_t *avl_pool = fspset->fsps_deleg_perm_avl_pool;
41371af68beaSAlexander Stetsenko 		deleg_perm_node_t *node =
41381af68beaSAlexander Stetsenko 		    safe_malloc(sizeof (deleg_perm_node_t));
41391af68beaSAlexander Stetsenko 
41401af68beaSAlexander Stetsenko 		assert(type == DATA_TYPE_BOOLEAN);
41411af68beaSAlexander Stetsenko 
41421af68beaSAlexander Stetsenko 		uu_avl_node_init(node, &node->dpn_avl_node, avl_pool);
41431af68beaSAlexander Stetsenko 		set_deleg_perm_node(avl, node, who_type, name, locality);
41441af68beaSAlexander Stetsenko 	}
41451af68beaSAlexander Stetsenko 
41461af68beaSAlexander Stetsenko 	return (0);
41471af68beaSAlexander Stetsenko }
41481af68beaSAlexander Stetsenko 
41491af68beaSAlexander Stetsenko static inline int
41501af68beaSAlexander Stetsenko parse_fs_perm(fs_perm_t *fsperm, nvlist_t *nvl)
41511af68beaSAlexander Stetsenko {
41521af68beaSAlexander Stetsenko 	nvpair_t *nvp = NULL;
41531af68beaSAlexander Stetsenko 	fs_perm_set_t *fspset = fsperm->fsp_set;
41541af68beaSAlexander Stetsenko 
41551af68beaSAlexander Stetsenko 	while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
41561af68beaSAlexander Stetsenko 		nvlist_t *nvl2 = NULL;
41571af68beaSAlexander Stetsenko 		const char *name = nvpair_name(nvp);
41581af68beaSAlexander Stetsenko 		uu_avl_t *avl = NULL;
41591af68beaSAlexander Stetsenko 		uu_avl_pool_t *avl_pool;
41601af68beaSAlexander Stetsenko 		zfs_deleg_who_type_t perm_type = name[0];
41611af68beaSAlexander Stetsenko 		char perm_locality = name[1];
41621af68beaSAlexander Stetsenko 		const char *perm_name = name + 3;
41631af68beaSAlexander Stetsenko 		boolean_t is_set = B_TRUE;
41641af68beaSAlexander Stetsenko 		who_perm_t *who_perm = NULL;
41651af68beaSAlexander Stetsenko 
41661af68beaSAlexander Stetsenko 		assert('$' == name[2]);
41671af68beaSAlexander Stetsenko 
41681af68beaSAlexander Stetsenko 		if (nvpair_value_nvlist(nvp, &nvl2) != 0)
41691af68beaSAlexander Stetsenko 			return (-1);
41701af68beaSAlexander Stetsenko 
41711af68beaSAlexander Stetsenko 		switch (perm_type) {
41721af68beaSAlexander Stetsenko 		case ZFS_DELEG_CREATE:
41731af68beaSAlexander Stetsenko 		case ZFS_DELEG_CREATE_SETS:
41741af68beaSAlexander Stetsenko 		case ZFS_DELEG_NAMED_SET:
41751af68beaSAlexander Stetsenko 		case ZFS_DELEG_NAMED_SET_SETS:
41761af68beaSAlexander Stetsenko 			avl_pool = fspset->fsps_named_set_avl_pool;
41771af68beaSAlexander Stetsenko 			avl = fsperm->fsp_sc_avl;
41781af68beaSAlexander Stetsenko 			break;
41791af68beaSAlexander Stetsenko 		case ZFS_DELEG_USER:
41801af68beaSAlexander Stetsenko 		case ZFS_DELEG_USER_SETS:
41811af68beaSAlexander Stetsenko 		case ZFS_DELEG_GROUP:
41821af68beaSAlexander Stetsenko 		case ZFS_DELEG_GROUP_SETS:
41831af68beaSAlexander Stetsenko 		case ZFS_DELEG_EVERYONE:
41841af68beaSAlexander Stetsenko 		case ZFS_DELEG_EVERYONE_SETS:
41851af68beaSAlexander Stetsenko 			avl_pool = fspset->fsps_who_perm_avl_pool;
41861af68beaSAlexander Stetsenko 			avl = fsperm->fsp_uge_avl;
41871af68beaSAlexander Stetsenko 			break;
41881af68beaSAlexander Stetsenko 		}
41891af68beaSAlexander Stetsenko 
41901af68beaSAlexander Stetsenko 		if (is_set) {
41911af68beaSAlexander Stetsenko 			who_perm_node_t *found_node = NULL;
41921af68beaSAlexander Stetsenko 			who_perm_node_t *node = safe_malloc(
41931af68beaSAlexander Stetsenko 			    sizeof (who_perm_node_t));
41941af68beaSAlexander Stetsenko 			who_perm = &node->who_perm;
41951af68beaSAlexander Stetsenko 			uu_avl_index_t idx = 0;
41961af68beaSAlexander Stetsenko 
41971af68beaSAlexander Stetsenko 			uu_avl_node_init(node, &node->who_avl_node, avl_pool);
41981af68beaSAlexander Stetsenko 			who_perm_init(who_perm, fsperm, perm_type, perm_name);
41991af68beaSAlexander Stetsenko 
42001af68beaSAlexander Stetsenko 			if ((found_node = uu_avl_find(avl, node, NULL, &idx))
42011af68beaSAlexander Stetsenko 			    == NULL) {
42021af68beaSAlexander Stetsenko 				if (avl == fsperm->fsp_uge_avl) {
42031af68beaSAlexander Stetsenko 					uid_t rid = 0;
42041af68beaSAlexander Stetsenko 					struct passwd *p = NULL;
42051af68beaSAlexander Stetsenko 					struct group *g = NULL;
42061af68beaSAlexander Stetsenko 					const char *nice_name = NULL;
42071af68beaSAlexander Stetsenko 
42081af68beaSAlexander Stetsenko 					switch (perm_type) {
42091af68beaSAlexander Stetsenko 					case ZFS_DELEG_USER_SETS:
42101af68beaSAlexander Stetsenko 					case ZFS_DELEG_USER:
42111af68beaSAlexander Stetsenko 						rid = atoi(perm_name);
42121af68beaSAlexander Stetsenko 						p = getpwuid(rid);
42131af68beaSAlexander Stetsenko 						if (p)
42141af68beaSAlexander Stetsenko 							nice_name = p->pw_name;
42151af68beaSAlexander Stetsenko 						break;
42161af68beaSAlexander Stetsenko 					case ZFS_DELEG_GROUP_SETS:
42171af68beaSAlexander Stetsenko 					case ZFS_DELEG_GROUP:
42181af68beaSAlexander Stetsenko 						rid = atoi(perm_name);
42191af68beaSAlexander Stetsenko 						g = getgrgid(rid);
42201af68beaSAlexander Stetsenko 						if (g)
42211af68beaSAlexander Stetsenko 							nice_name = g->gr_name;
42221af68beaSAlexander Stetsenko 						break;
42231af68beaSAlexander Stetsenko 					}
42241af68beaSAlexander Stetsenko 
42251af68beaSAlexander Stetsenko 					if (nice_name != NULL)
42261af68beaSAlexander Stetsenko 						(void) strlcpy(
42271af68beaSAlexander Stetsenko 						    node->who_perm.who_ug_name,
42281af68beaSAlexander Stetsenko 						    nice_name, 256);
42291af68beaSAlexander Stetsenko 				}
42301af68beaSAlexander Stetsenko 
42311af68beaSAlexander Stetsenko 				uu_avl_insert(avl, node, idx);
42321af68beaSAlexander Stetsenko 			} else {
42331af68beaSAlexander Stetsenko 				node = found_node;
42341af68beaSAlexander Stetsenko 				who_perm = &node->who_perm;
42351af68beaSAlexander Stetsenko 			}
42361af68beaSAlexander Stetsenko 		}
42371af68beaSAlexander Stetsenko 
42381af68beaSAlexander Stetsenko 		(void) parse_who_perm(who_perm, nvl2, perm_locality);
42391af68beaSAlexander Stetsenko 	}
42401af68beaSAlexander Stetsenko 
42411af68beaSAlexander Stetsenko 	return (0);
42421af68beaSAlexander Stetsenko }
42431af68beaSAlexander Stetsenko 
42441af68beaSAlexander Stetsenko static inline int
42451af68beaSAlexander Stetsenko parse_fs_perm_set(fs_perm_set_t *fspset, nvlist_t *nvl)
42461af68beaSAlexander Stetsenko {
42471af68beaSAlexander Stetsenko 	nvpair_t *nvp = NULL;
42481af68beaSAlexander Stetsenko 	uu_avl_index_t idx = 0;
42491af68beaSAlexander Stetsenko 
42501af68beaSAlexander Stetsenko 	while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
42511af68beaSAlexander Stetsenko 		nvlist_t *nvl2 = NULL;
42521af68beaSAlexander Stetsenko 		const char *fsname = nvpair_name(nvp);
42531af68beaSAlexander Stetsenko 		data_type_t type = nvpair_type(nvp);
42541af68beaSAlexander Stetsenko 		fs_perm_t *fsperm = NULL;
42551af68beaSAlexander Stetsenko 		fs_perm_node_t *node = safe_malloc(sizeof (fs_perm_node_t));
42561af68beaSAlexander Stetsenko 		if (node == NULL)
42571af68beaSAlexander Stetsenko 			nomem();
42581af68beaSAlexander Stetsenko 
42591af68beaSAlexander Stetsenko 		fsperm = &node->fspn_fsperm;
42601af68beaSAlexander Stetsenko 
42611af68beaSAlexander Stetsenko 		assert(DATA_TYPE_NVLIST == type);
42621af68beaSAlexander Stetsenko 
42631af68beaSAlexander Stetsenko 		uu_list_node_init(node, &node->fspn_list_node,
42641af68beaSAlexander Stetsenko 		    fspset->fsps_list_pool);
42651af68beaSAlexander Stetsenko 
42661af68beaSAlexander Stetsenko 		idx = uu_list_numnodes(fspset->fsps_list);
42671af68beaSAlexander Stetsenko 		fs_perm_init(fsperm, fspset, fsname);
42681af68beaSAlexander Stetsenko 
42691af68beaSAlexander Stetsenko 		if (nvpair_value_nvlist(nvp, &nvl2) != 0)
42701af68beaSAlexander Stetsenko 			return (-1);
42711af68beaSAlexander Stetsenko 
42721af68beaSAlexander Stetsenko 		(void) parse_fs_perm(fsperm, nvl2);
42731af68beaSAlexander Stetsenko 
42741af68beaSAlexander Stetsenko 		uu_list_insert(fspset->fsps_list, node, idx);
42751af68beaSAlexander Stetsenko 	}
42761af68beaSAlexander Stetsenko 
42771af68beaSAlexander Stetsenko 	return (0);
42781af68beaSAlexander Stetsenko }
42791af68beaSAlexander Stetsenko 
42801af68beaSAlexander Stetsenko static inline const char *
42811af68beaSAlexander Stetsenko deleg_perm_comment(zfs_deleg_note_t note)
42821af68beaSAlexander Stetsenko {
42831af68beaSAlexander Stetsenko 	const char *str = "";
42841af68beaSAlexander Stetsenko 
42851af68beaSAlexander Stetsenko 	/* subcommands */
42861af68beaSAlexander Stetsenko 	switch (note) {
42871af68beaSAlexander Stetsenko 		/* SUBCOMMANDS */
42881af68beaSAlexander Stetsenko 	case ZFS_DELEG_NOTE_ALLOW:
42891af68beaSAlexander Stetsenko 		str = gettext("Must also have the permission that is being"
42901af68beaSAlexander Stetsenko 		    "\n\t\t\t\tallowed");
42911af68beaSAlexander Stetsenko 		break;
42921af68beaSAlexander Stetsenko 	case ZFS_DELEG_NOTE_CLONE:
42931af68beaSAlexander Stetsenko 		str = gettext("Must also have the 'create' ability and 'mount'"
42941af68beaSAlexander Stetsenko 		    "\n\t\t\t\tability in the origin file system");
42951af68beaSAlexander Stetsenko 		break;
42961af68beaSAlexander Stetsenko 	case ZFS_DELEG_NOTE_CREATE:
42971af68beaSAlexander Stetsenko 		str = gettext("Must also have the 'mount' ability");
42981af68beaSAlexander Stetsenko 		break;
42991af68beaSAlexander Stetsenko 	case ZFS_DELEG_NOTE_DESTROY:
43001af68beaSAlexander Stetsenko 		str = gettext("Must also have the 'mount' ability");
43011af68beaSAlexander Stetsenko 		break;
43021af68beaSAlexander Stetsenko 	case ZFS_DELEG_NOTE_DIFF:
43031af68beaSAlexander Stetsenko 		str = gettext("Allows lookup of paths within a dataset;"
43041af68beaSAlexander Stetsenko 		    "\n\t\t\t\tgiven an object number. Ordinary users need this"
43051af68beaSAlexander Stetsenko 		    "\n\t\t\t\tin order to use zfs diff");
43061af68beaSAlexander Stetsenko 		break;
43071af68beaSAlexander Stetsenko 	case ZFS_DELEG_NOTE_HOLD:
43081af68beaSAlexander Stetsenko 		str = gettext("Allows adding a user hold to a snapshot");
43091af68beaSAlexander Stetsenko 		break;
43101af68beaSAlexander Stetsenko 	case ZFS_DELEG_NOTE_MOUNT:
43111af68beaSAlexander Stetsenko 		str = gettext("Allows mount/umount of ZFS datasets");
43121af68beaSAlexander Stetsenko 		break;
43131af68beaSAlexander Stetsenko 	case ZFS_DELEG_NOTE_PROMOTE:
43141af68beaSAlexander Stetsenko 		str = gettext("Must also have the 'mount'\n\t\t\t\tand"
43151af68beaSAlexander Stetsenko 		    " 'promote' ability in the origin file system");
43161af68beaSAlexander Stetsenko 		break;
43171af68beaSAlexander Stetsenko 	case ZFS_DELEG_NOTE_RECEIVE:
43181af68beaSAlexander Stetsenko 		str = gettext("Must also have the 'mount' and 'create'"
43191af68beaSAlexander Stetsenko 		    " ability");
43201af68beaSAlexander Stetsenko 		break;
43211af68beaSAlexander Stetsenko 	case ZFS_DELEG_NOTE_RELEASE:
43221af68beaSAlexander Stetsenko 		str = gettext("Allows releasing a user hold which\n\t\t\t\t"
43231af68beaSAlexander Stetsenko 		    "might destroy the snapshot");
43241af68beaSAlexander Stetsenko 		break;
43251af68beaSAlexander Stetsenko 	case ZFS_DELEG_NOTE_RENAME:
43261af68beaSAlexander Stetsenko 		str = gettext("Must also have the 'mount' and 'create'"
43271af68beaSAlexander Stetsenko 		    "\n\t\t\t\tability in the new parent");
43281af68beaSAlexander Stetsenko 		break;
43291af68beaSAlexander Stetsenko 	case ZFS_DELEG_NOTE_ROLLBACK:
43301af68beaSAlexander Stetsenko 		str = gettext("");
43311af68beaSAlexander Stetsenko 		break;
43321af68beaSAlexander Stetsenko 	case ZFS_DELEG_NOTE_SEND:
43331af68beaSAlexander Stetsenko 		str = gettext("");
43341af68beaSAlexander Stetsenko 		break;
43351af68beaSAlexander Stetsenko 	case ZFS_DELEG_NOTE_SHARE:
43361af68beaSAlexander Stetsenko 		str = gettext("Allows sharing file systems over NFS or SMB"
43371af68beaSAlexander Stetsenko 		    "\n\t\t\t\tprotocols");
43381af68beaSAlexander Stetsenko 		break;
43391af68beaSAlexander Stetsenko 	case ZFS_DELEG_NOTE_SNAPSHOT:
43401af68beaSAlexander Stetsenko 		str = gettext("");
43411af68beaSAlexander Stetsenko 		break;
43421af68beaSAlexander Stetsenko /*
43431af68beaSAlexander Stetsenko  *	case ZFS_DELEG_NOTE_VSCAN:
43441af68beaSAlexander Stetsenko  *		str = gettext("");
43451af68beaSAlexander Stetsenko  *		break;
43461af68beaSAlexander Stetsenko  */
43471af68beaSAlexander Stetsenko 		/* OTHER */
43481af68beaSAlexander Stetsenko 	case ZFS_DELEG_NOTE_GROUPQUOTA:
43491af68beaSAlexander Stetsenko 		str = gettext("Allows accessing any groupquota@... property");
43501af68beaSAlexander Stetsenko 		break;
43511af68beaSAlexander Stetsenko 	case ZFS_DELEG_NOTE_GROUPUSED:
43521af68beaSAlexander Stetsenko 		str = gettext("Allows reading any groupused@... property");
43531af68beaSAlexander Stetsenko 		break;
43541af68beaSAlexander Stetsenko 	case ZFS_DELEG_NOTE_USERPROP:
43551af68beaSAlexander Stetsenko 		str = gettext("Allows changing any user property");
43561af68beaSAlexander Stetsenko 		break;
43571af68beaSAlexander Stetsenko 	case ZFS_DELEG_NOTE_USERQUOTA:
43581af68beaSAlexander Stetsenko 		str = gettext("Allows accessing any userquota@... property");
43591af68beaSAlexander Stetsenko 		break;
43601af68beaSAlexander Stetsenko 	case ZFS_DELEG_NOTE_USERUSED:
43611af68beaSAlexander Stetsenko 		str = gettext("Allows reading any userused@... property");
43621af68beaSAlexander Stetsenko 		break;
43631af68beaSAlexander Stetsenko 		/* other */
43641af68beaSAlexander Stetsenko 	default:
43651af68beaSAlexander Stetsenko 		str = "";
43661af68beaSAlexander Stetsenko 	}
43671af68beaSAlexander Stetsenko 
43681af68beaSAlexander Stetsenko 	return (str);
43691af68beaSAlexander Stetsenko }
43701af68beaSAlexander Stetsenko 
43711af68beaSAlexander Stetsenko struct allow_opts {
43721af68beaSAlexander Stetsenko 	boolean_t local;
43731af68beaSAlexander Stetsenko 	boolean_t descend;
43741af68beaSAlexander Stetsenko 	boolean_t user;
43751af68beaSAlexander Stetsenko 	boolean_t group;
43761af68beaSAlexander Stetsenko 	boolean_t everyone;
43771af68beaSAlexander Stetsenko 	boolean_t create;
43781af68beaSAlexander Stetsenko 	boolean_t set;
43791af68beaSAlexander Stetsenko 	boolean_t recursive; /* unallow only */
43801af68beaSAlexander Stetsenko 	boolean_t prt_usage;
43811af68beaSAlexander Stetsenko 
43821af68beaSAlexander Stetsenko 	boolean_t prt_perms;
43831af68beaSAlexander Stetsenko 	char *who;
43841af68beaSAlexander Stetsenko 	char *perms;
43851af68beaSAlexander Stetsenko 	const char *dataset;
43861af68beaSAlexander Stetsenko };
43871af68beaSAlexander Stetsenko 
43881af68beaSAlexander Stetsenko static inline int
43891af68beaSAlexander Stetsenko prop_cmp(const void *a, const void *b)
43901af68beaSAlexander Stetsenko {
43911af68beaSAlexander Stetsenko 	const char *str1 = *(const char **)a;
43921af68beaSAlexander Stetsenko 	const char *str2 = *(const char **)b;
43931af68beaSAlexander Stetsenko 	return (strcmp(str1, str2));
43941af68beaSAlexander Stetsenko }
43951af68beaSAlexander Stetsenko 
43961af68beaSAlexander Stetsenko static void
43971af68beaSAlexander Stetsenko allow_usage(boolean_t un, boolean_t requested, const char *msg)
43981af68beaSAlexander Stetsenko {
43991af68beaSAlexander Stetsenko 	const char *opt_desc[] = {
44001af68beaSAlexander Stetsenko 		"-h", gettext("show this help message and exit"),
44011af68beaSAlexander Stetsenko 		"-l", gettext("set permission locally"),
44021af68beaSAlexander Stetsenko 		"-d", gettext("set permission for descents"),
44031af68beaSAlexander Stetsenko 		"-u", gettext("set permission for user"),
44041af68beaSAlexander Stetsenko 		"-g", gettext("set permission for group"),
44051af68beaSAlexander Stetsenko 		"-e", gettext("set permission for everyone"),
44061af68beaSAlexander Stetsenko 		"-c", gettext("set create time permission"),
44071af68beaSAlexander Stetsenko 		"-s", gettext("define permission set"),
44081af68beaSAlexander Stetsenko 		/* unallow only */
44091af68beaSAlexander Stetsenko 		"-r", gettext("remove permissions recursively"),
44101af68beaSAlexander Stetsenko 	};
44111af68beaSAlexander Stetsenko 	size_t unallow_size = sizeof (opt_desc) / sizeof (char *);
44121af68beaSAlexander Stetsenko 	size_t allow_size = unallow_size - 2;
44131af68beaSAlexander Stetsenko 	const char *props[ZFS_NUM_PROPS];
44141af68beaSAlexander Stetsenko 	int i;
44151af68beaSAlexander Stetsenko 	size_t count = 0;
44161af68beaSAlexander Stetsenko 	FILE *fp = requested ? stdout : stderr;
44171af68beaSAlexander Stetsenko 	zprop_desc_t *pdtbl = zfs_prop_get_table();
44181af68beaSAlexander Stetsenko 	const char *fmt = gettext("%-16s %-14s\t%s\n");
44191af68beaSAlexander Stetsenko 
44201af68beaSAlexander Stetsenko 	(void) fprintf(fp, gettext("Usage: %s\n"), get_usage(un ? HELP_UNALLOW :
44211af68beaSAlexander Stetsenko 	    HELP_ALLOW));
44221af68beaSAlexander Stetsenko 	(void) fprintf(fp, gettext("Options:\n"));
44231af68beaSAlexander Stetsenko 	for (int i = 0; i < (un ? unallow_size : allow_size); i++) {
44241af68beaSAlexander Stetsenko 		const char *opt = opt_desc[i++];
44251af68beaSAlexander Stetsenko 		const char *optdsc = opt_desc[i];
44261af68beaSAlexander Stetsenko 		(void) fprintf(fp, gettext("  %-10s  %s\n"), opt, optdsc);
44271af68beaSAlexander Stetsenko 	}
44281af68beaSAlexander Stetsenko 
44291af68beaSAlexander Stetsenko 	(void) fprintf(fp, gettext("\nThe following permissions are "
44301af68beaSAlexander Stetsenko 	    "supported:\n\n"));
44311af68beaSAlexander Stetsenko 	(void) fprintf(fp, fmt, gettext("NAME"), gettext("TYPE"),
44321af68beaSAlexander Stetsenko 	    gettext("NOTES"));
44331af68beaSAlexander Stetsenko 	for (i = 0; i < ZFS_NUM_DELEG_NOTES; i++) {
44341af68beaSAlexander Stetsenko 		const char *perm_name = zfs_deleg_perm_tbl[i].z_perm;
44351af68beaSAlexander Stetsenko 		zfs_deleg_note_t perm_note = zfs_deleg_perm_tbl[i].z_note;
44361af68beaSAlexander Stetsenko 		const char *perm_type = deleg_perm_type(perm_note);
44371af68beaSAlexander Stetsenko 		const char *perm_comment = deleg_perm_comment(perm_note);
44381af68beaSAlexander Stetsenko 		(void) fprintf(fp, fmt, perm_name, perm_type, perm_comment);
44391af68beaSAlexander Stetsenko 	}
44401af68beaSAlexander Stetsenko 
44411af68beaSAlexander Stetsenko 	for (i = 0; i < ZFS_NUM_PROPS; i++) {
44421af68beaSAlexander Stetsenko 		zprop_desc_t *pd = &pdtbl[i];
44431af68beaSAlexander Stetsenko 		if (pd->pd_visible != B_TRUE)
44441af68beaSAlexander Stetsenko 			continue;
44451af68beaSAlexander Stetsenko 
44461af68beaSAlexander Stetsenko 		if (pd->pd_attr == PROP_READONLY)
44471af68beaSAlexander Stetsenko 			continue;
44481af68beaSAlexander Stetsenko 
44491af68beaSAlexander Stetsenko 		props[count++] = pd->pd_name;
44501af68beaSAlexander Stetsenko 	}
44511af68beaSAlexander Stetsenko 	props[count] = NULL;
44521af68beaSAlexander Stetsenko 
44531af68beaSAlexander Stetsenko 	qsort(props, count, sizeof (char *), prop_cmp);
44541af68beaSAlexander Stetsenko 
44551af68beaSAlexander Stetsenko 	for (i = 0; i < count; i++)
44561af68beaSAlexander Stetsenko 		(void) fprintf(fp, fmt, props[i], gettext("property"), "");
44571af68beaSAlexander Stetsenko 
44581af68beaSAlexander Stetsenko 	if (msg != NULL)
44591af68beaSAlexander Stetsenko 		(void) fprintf(fp, gettext("\nzfs: error: %s"), msg);
44601af68beaSAlexander Stetsenko 
44611af68beaSAlexander Stetsenko 	exit(requested ? 0 : 2);
44621af68beaSAlexander Stetsenko }
44631af68beaSAlexander Stetsenko 
44641af68beaSAlexander Stetsenko static inline const char *
44651af68beaSAlexander Stetsenko munge_args(int argc, char **argv, boolean_t un, size_t expected_argc,
44661af68beaSAlexander Stetsenko     char **permsp)
44671af68beaSAlexander Stetsenko {
44681af68beaSAlexander Stetsenko 	if (un && argc == expected_argc - 1)
44691af68beaSAlexander Stetsenko 		*permsp = NULL;
44701af68beaSAlexander Stetsenko 	else if (argc == expected_argc)
44711af68beaSAlexander Stetsenko 		*permsp = argv[argc - 2];
44721af68beaSAlexander Stetsenko 	else
44731af68beaSAlexander Stetsenko 		allow_usage(un, B_FALSE,
44741af68beaSAlexander Stetsenko 		    gettext("wrong number of parameters\n"));
44751af68beaSAlexander Stetsenko 
44761af68beaSAlexander Stetsenko 	return (argv[argc - 1]);
44771af68beaSAlexander Stetsenko }
44781af68beaSAlexander Stetsenko 
44791af68beaSAlexander Stetsenko static void
44801af68beaSAlexander Stetsenko parse_allow_args(int argc, char **argv, boolean_t un, struct allow_opts *opts)
44811af68beaSAlexander Stetsenko {
44821af68beaSAlexander Stetsenko 	int uge_sum = opts->user + opts->group + opts->everyone;
44831af68beaSAlexander Stetsenko 	int csuge_sum = opts->create + opts->set + uge_sum;
44841af68beaSAlexander Stetsenko 	int ldcsuge_sum = csuge_sum + opts->local + opts->descend;
44851af68beaSAlexander Stetsenko 	int all_sum = un ? ldcsuge_sum + opts->recursive : ldcsuge_sum;
44861af68beaSAlexander Stetsenko 
44871af68beaSAlexander Stetsenko 	if (uge_sum > 1)
44881af68beaSAlexander Stetsenko 		allow_usage(un, B_FALSE,
44891af68beaSAlexander Stetsenko 		    gettext("-u, -g, and -e are mutually exclusive\n"));
44901af68beaSAlexander Stetsenko 
44911af68beaSAlexander Stetsenko 	if (opts->prt_usage)
44921af68beaSAlexander Stetsenko 		if (argc == 0 && all_sum == 0)
44931af68beaSAlexander Stetsenko 			allow_usage(un, B_TRUE, NULL);
44941af68beaSAlexander Stetsenko 		else
44951af68beaSAlexander Stetsenko 			usage(B_FALSE);
44961af68beaSAlexander Stetsenko 
44971af68beaSAlexander Stetsenko 	if (opts->set) {
44981af68beaSAlexander Stetsenko 		if (csuge_sum > 1)
44991af68beaSAlexander Stetsenko 			allow_usage(un, B_FALSE,
45001af68beaSAlexander Stetsenko 			    gettext("invalid options combined with -s\n"));
45011af68beaSAlexander Stetsenko 
45021af68beaSAlexander Stetsenko 		opts->dataset = munge_args(argc, argv, un, 3, &opts->perms);
45031af68beaSAlexander Stetsenko 		if (argv[0][0] != '@')
45041af68beaSAlexander Stetsenko 			allow_usage(un, B_FALSE,
45051af68beaSAlexander Stetsenko 			    gettext("invalid set name: missing '@' prefix\n"));
45061af68beaSAlexander Stetsenko 		opts->who = argv[0];
45071af68beaSAlexander Stetsenko 	} else if (opts->create) {
45081af68beaSAlexander Stetsenko 		if (ldcsuge_sum > 1)
45091af68beaSAlexander Stetsenko 			allow_usage(un, B_FALSE,
45101af68beaSAlexander Stetsenko 			    gettext("invalid options combined with -c\n"));
45111af68beaSAlexander Stetsenko 		opts->dataset = munge_args(argc, argv, un, 2, &opts->perms);
45121af68beaSAlexander Stetsenko 	} else if (opts->everyone) {
45131af68beaSAlexander Stetsenko 		if (csuge_sum > 1)
45141af68beaSAlexander Stetsenko 			allow_usage(un, B_FALSE,
45151af68beaSAlexander Stetsenko 			    gettext("invalid options combined with -e\n"));
45161af68beaSAlexander Stetsenko 		opts->dataset = munge_args(argc, argv, un, 2, &opts->perms);
45171af68beaSAlexander Stetsenko 	} else if (uge_sum == 0 && argc > 0 && strcmp(argv[0], "everyone")
45181af68beaSAlexander Stetsenko 	    == 0) {
45191af68beaSAlexander Stetsenko 		opts->everyone = B_TRUE;
45201af68beaSAlexander Stetsenko 		argc--;
45211af68beaSAlexander Stetsenko 		argv++;
45221af68beaSAlexander Stetsenko 		opts->dataset = munge_args(argc, argv, un, 2, &opts->perms);
4523c560ed2bSAlexander Eremin 	} else if (argc == 1 && !un) {
45241af68beaSAlexander Stetsenko 		opts->prt_perms = B_TRUE;
45251af68beaSAlexander Stetsenko 		opts->dataset = argv[argc-1];
45261af68beaSAlexander Stetsenko 	} else {
45271af68beaSAlexander Stetsenko 		opts->dataset = munge_args(argc, argv, un, 3, &opts->perms);
45281af68beaSAlexander Stetsenko 		opts->who = argv[0];
45291af68beaSAlexander Stetsenko 	}
45301af68beaSAlexander Stetsenko 
45311af68beaSAlexander Stetsenko 	if (!opts->local && !opts->descend) {
45321af68beaSAlexander Stetsenko 		opts->local = B_TRUE;
45331af68beaSAlexander Stetsenko 		opts->descend = B_TRUE;
45341af68beaSAlexander Stetsenko 	}
45351af68beaSAlexander Stetsenko }
45361af68beaSAlexander Stetsenko 
45371af68beaSAlexander Stetsenko static void
45381af68beaSAlexander Stetsenko store_allow_perm(zfs_deleg_who_type_t type, boolean_t local, boolean_t descend,
45391af68beaSAlexander Stetsenko     const char *who, char *perms, nvlist_t *top_nvl)
45401af68beaSAlexander Stetsenko {
45411af68beaSAlexander Stetsenko 	int i;
45421af68beaSAlexander Stetsenko 	char ld[2] = { '\0', '\0' };
45431af68beaSAlexander Stetsenko 	char who_buf[ZFS_MAXNAMELEN+32];
45441af68beaSAlexander Stetsenko 	char base_type;
45451af68beaSAlexander Stetsenko 	char set_type;
45461af68beaSAlexander Stetsenko 	nvlist_t *base_nvl = NULL;
45471af68beaSAlexander Stetsenko 	nvlist_t *set_nvl = NULL;
45481af68beaSAlexander Stetsenko 	nvlist_t *nvl;
45491af68beaSAlexander Stetsenko 
45501af68beaSAlexander Stetsenko 	if (nvlist_alloc(&base_nvl, NV_UNIQUE_NAME, 0) != 0)
45511af68beaSAlexander Stetsenko 		nomem();
45521af68beaSAlexander Stetsenko 	if (nvlist_alloc(&set_nvl, NV_UNIQUE_NAME, 0) !=  0)
45531af68beaSAlexander Stetsenko 		nomem();
45541af68beaSAlexander Stetsenko 
45551af68beaSAlexander Stetsenko 	switch (type) {
45561af68beaSAlexander Stetsenko 	case ZFS_DELEG_NAMED_SET_SETS:
45571af68beaSAlexander Stetsenko 	case ZFS_DELEG_NAMED_SET:
45581af68beaSAlexander Stetsenko 		set_type = ZFS_DELEG_NAMED_SET_SETS;
45591af68beaSAlexander Stetsenko 		base_type = ZFS_DELEG_NAMED_SET;
45601af68beaSAlexander Stetsenko 		ld[0] = ZFS_DELEG_NA;
45611af68beaSAlexander Stetsenko 		break;
45621af68beaSAlexander Stetsenko 	case ZFS_DELEG_CREATE_SETS:
45631af68beaSAlexander Stetsenko 	case ZFS_DELEG_CREATE:
45641af68beaSAlexander Stetsenko 		set_type = ZFS_DELEG_CREATE_SETS;
45651af68beaSAlexander Stetsenko 		base_type = ZFS_DELEG_CREATE;
45661af68beaSAlexander Stetsenko 		ld[0] = ZFS_DELEG_NA;
45671af68beaSAlexander Stetsenko 		break;
45681af68beaSAlexander Stetsenko 	case ZFS_DELEG_USER_SETS:
45691af68beaSAlexander Stetsenko 	case ZFS_DELEG_USER:
45701af68beaSAlexander Stetsenko 		set_type = ZFS_DELEG_USER_SETS;
45711af68beaSAlexander Stetsenko 		base_type = ZFS_DELEG_USER;
45721af68beaSAlexander Stetsenko 		if (local)
45731af68beaSAlexander Stetsenko 			ld[0] = ZFS_DELEG_LOCAL;
45741af68beaSAlexander Stetsenko 		if (descend)
45751af68beaSAlexander Stetsenko 			ld[1] = ZFS_DELEG_DESCENDENT;
45761af68beaSAlexander Stetsenko 		break;
45771af68beaSAlexander Stetsenko 	case ZFS_DELEG_GROUP_SETS:
45781af68beaSAlexander Stetsenko 	case ZFS_DELEG_GROUP:
45791af68beaSAlexander Stetsenko 		set_type = ZFS_DELEG_GROUP_SETS;
45801af68beaSAlexander Stetsenko 		base_type = ZFS_DELEG_GROUP;
45811af68beaSAlexander Stetsenko 		if (local)
45821af68beaSAlexander Stetsenko 			ld[0] = ZFS_DELEG_LOCAL;
45831af68beaSAlexander Stetsenko 		if (descend)
45841af68beaSAlexander Stetsenko 			ld[1] = ZFS_DELEG_DESCENDENT;
45851af68beaSAlexander Stetsenko 		break;
45861af68beaSAlexander Stetsenko 	case ZFS_DELEG_EVERYONE_SETS:
45871af68beaSAlexander Stetsenko 	case ZFS_DELEG_EVERYONE:
45881af68beaSAlexander Stetsenko 		set_type = ZFS_DELEG_EVERYONE_SETS;
45891af68beaSAlexander Stetsenko 		base_type = ZFS_DELEG_EVERYONE;
45901af68beaSAlexander Stetsenko 		if (local)
45911af68beaSAlexander Stetsenko 			ld[0] = ZFS_DELEG_LOCAL;
45921af68beaSAlexander Stetsenko 		if (descend)
45931af68beaSAlexander Stetsenko 			ld[1] = ZFS_DELEG_DESCENDENT;
45941af68beaSAlexander Stetsenko 	}
45951af68beaSAlexander Stetsenko 
45961af68beaSAlexander Stetsenko 	if (perms != NULL) {
45971af68beaSAlexander Stetsenko 		char *curr = perms;
45981af68beaSAlexander Stetsenko 		char *end = curr + strlen(perms);
45991af68beaSAlexander Stetsenko 
46001af68beaSAlexander Stetsenko 		while (curr < end) {
46011af68beaSAlexander Stetsenko 			char *delim = strchr(curr, ',');
46021af68beaSAlexander Stetsenko 			if (delim == NULL)
46031af68beaSAlexander Stetsenko 				delim = end;
46041af68beaSAlexander Stetsenko 			else
46051af68beaSAlexander Stetsenko 				*delim = '\0';
46061af68beaSAlexander Stetsenko 
46071af68beaSAlexander Stetsenko 			if (curr[0] == '@')
46081af68beaSAlexander Stetsenko 				nvl = set_nvl;
46091af68beaSAlexander Stetsenko 			else
46101af68beaSAlexander Stetsenko 				nvl = base_nvl;
46111af68beaSAlexander Stetsenko 
46121af68beaSAlexander Stetsenko 			(void) nvlist_add_boolean(nvl, curr);
46131af68beaSAlexander Stetsenko 			if (delim != end)
46141af68beaSAlexander Stetsenko 				*delim = ',';
46151af68beaSAlexander Stetsenko 			curr = delim + 1;
46161af68beaSAlexander Stetsenko 		}
46171af68beaSAlexander Stetsenko 
46181af68beaSAlexander Stetsenko 		for (i = 0; i < 2; i++) {
46191af68beaSAlexander Stetsenko 			char locality = ld[i];
46201af68beaSAlexander Stetsenko 			if (locality == 0)
46211af68beaSAlexander Stetsenko 				continue;
46221af68beaSAlexander Stetsenko 
46231af68beaSAlexander Stetsenko 			if (!nvlist_empty(base_nvl)) {
46241af68beaSAlexander Stetsenko 				if (who != NULL)
46251af68beaSAlexander Stetsenko 					(void) snprintf(who_buf,
46261af68beaSAlexander Stetsenko 					    sizeof (who_buf), "%c%c$%s",
46271af68beaSAlexander Stetsenko 					    base_type, locality, who);
46281af68beaSAlexander Stetsenko 				else
46291af68beaSAlexander Stetsenko 					(void) snprintf(who_buf,
46301af68beaSAlexander Stetsenko 					    sizeof (who_buf), "%c%c$",
46311af68beaSAlexander Stetsenko 					    base_type, locality);
46321af68beaSAlexander Stetsenko 
46331af68beaSAlexander Stetsenko 				(void) nvlist_add_nvlist(top_nvl, who_buf,
46341af68beaSAlexander Stetsenko 				    base_nvl);
46351af68beaSAlexander Stetsenko 			}
46361af68beaSAlexander Stetsenko 
46371af68beaSAlexander Stetsenko 
46381af68beaSAlexander Stetsenko 			if (!nvlist_empty(set_nvl)) {
46391af68beaSAlexander Stetsenko 				if (who != NULL)
46401af68beaSAlexander Stetsenko 					(void) snprintf(who_buf,
46411af68beaSAlexander Stetsenko 					    sizeof (who_buf), "%c%c$%s",
46421af68beaSAlexander Stetsenko 					    set_type, locality, who);
46431af68beaSAlexander Stetsenko 				else
46441af68beaSAlexander Stetsenko 					(void) snprintf(who_buf,
46451af68beaSAlexander Stetsenko 					    sizeof (who_buf), "%c%c$",
46461af68beaSAlexander Stetsenko 					    set_type, locality);
46471af68beaSAlexander Stetsenko 
46481af68beaSAlexander Stetsenko 				(void) nvlist_add_nvlist(top_nvl, who_buf,
46491af68beaSAlexander Stetsenko 				    set_nvl);
46501af68beaSAlexander Stetsenko 			}
46511af68beaSAlexander Stetsenko 		}
46521af68beaSAlexander Stetsenko 	} else {
46531af68beaSAlexander Stetsenko 		for (i = 0; i < 2; i++) {
46541af68beaSAlexander Stetsenko 			char locality = ld[i];
46551af68beaSAlexander Stetsenko 			if (locality == 0)
46561af68beaSAlexander Stetsenko 				continue;
46571af68beaSAlexander Stetsenko 
46581af68beaSAlexander Stetsenko 			if (who != NULL)
46591af68beaSAlexander Stetsenko 				(void) snprintf(who_buf, sizeof (who_buf),
46601af68beaSAlexander Stetsenko 				    "%c%c$%s", base_type, locality, who);
46611af68beaSAlexander Stetsenko 			else
46621af68beaSAlexander Stetsenko 				(void) snprintf(who_buf, sizeof (who_buf),
46631af68beaSAlexander Stetsenko 				    "%c%c$", base_type, locality);
46641af68beaSAlexander Stetsenko 			(void) nvlist_add_boolean(top_nvl, who_buf);
46651af68beaSAlexander Stetsenko 
46661af68beaSAlexander Stetsenko 			if (who != NULL)
46671af68beaSAlexander Stetsenko 				(void) snprintf(who_buf, sizeof (who_buf),
46681af68beaSAlexander Stetsenko 				    "%c%c$%s", set_type, locality, who);
46691af68beaSAlexander Stetsenko 			else
46701af68beaSAlexander Stetsenko 				(void) snprintf(who_buf, sizeof (who_buf),
46711af68beaSAlexander Stetsenko 				    "%c%c$", set_type, locality);
46721af68beaSAlexander Stetsenko 			(void) nvlist_add_boolean(top_nvl, who_buf);
46731af68beaSAlexander Stetsenko 		}
46741af68beaSAlexander Stetsenko 	}
46751af68beaSAlexander Stetsenko }
46761af68beaSAlexander Stetsenko 
46771af68beaSAlexander Stetsenko static int
46781af68beaSAlexander Stetsenko construct_fsacl_list(boolean_t un, struct allow_opts *opts, nvlist_t **nvlp)
46791af68beaSAlexander Stetsenko {
46801af68beaSAlexander Stetsenko 	if (nvlist_alloc(nvlp, NV_UNIQUE_NAME, 0) != 0)
46811af68beaSAlexander Stetsenko 		nomem();
46821af68beaSAlexander Stetsenko 
46831af68beaSAlexander Stetsenko 	if (opts->set) {
46841af68beaSAlexander Stetsenko 		store_allow_perm(ZFS_DELEG_NAMED_SET, opts->local,
46851af68beaSAlexander Stetsenko 		    opts->descend, opts->who, opts->perms, *nvlp);
46861af68beaSAlexander Stetsenko 	} else if (opts->create) {
46871af68beaSAlexander Stetsenko 		store_allow_perm(ZFS_DELEG_CREATE, opts->local,
46881af68beaSAlexander Stetsenko 		    opts->descend, NULL, opts->perms, *nvlp);
46891af68beaSAlexander Stetsenko 	} else if (opts->everyone) {
46901af68beaSAlexander Stetsenko 		store_allow_perm(ZFS_DELEG_EVERYONE, opts->local,
46911af68beaSAlexander Stetsenko 		    opts->descend, NULL, opts->perms, *nvlp);
46921af68beaSAlexander Stetsenko 	} else {
46931af68beaSAlexander Stetsenko 		char *curr = opts->who;
46941af68beaSAlexander Stetsenko 		char *end = curr + strlen(curr);
46951af68beaSAlexander Stetsenko 
46961af68beaSAlexander Stetsenko 		while (curr < end) {
46971af68beaSAlexander Stetsenko 			const char *who;
46981af68beaSAlexander Stetsenko 			zfs_deleg_who_type_t who_type;
46991af68beaSAlexander Stetsenko 			char *endch;
47001af68beaSAlexander Stetsenko 			char *delim = strchr(curr, ',');
47011af68beaSAlexander Stetsenko 			char errbuf[256];
47021af68beaSAlexander Stetsenko 			char id[64];
47031af68beaSAlexander Stetsenko 			struct passwd *p = NULL;
47041af68beaSAlexander Stetsenko 			struct group *g = NULL;
47051af68beaSAlexander Stetsenko 
47061af68beaSAlexander Stetsenko 			uid_t rid;
47071af68beaSAlexander Stetsenko 			if (delim == NULL)
47081af68beaSAlexander Stetsenko 				delim = end;
47091af68beaSAlexander Stetsenko 			else
47101af68beaSAlexander Stetsenko 				*delim = '\0';
47111af68beaSAlexander Stetsenko 
47121af68beaSAlexander Stetsenko 			rid = (uid_t)strtol(curr, &endch, 0);
47131af68beaSAlexander Stetsenko 			if (opts->user) {
47141af68beaSAlexander Stetsenko 				who_type = ZFS_DELEG_USER;
47151af68beaSAlexander Stetsenko 				if (*endch != '\0')
47161af68beaSAlexander Stetsenko 					p = getpwnam(curr);
47171af68beaSAlexander Stetsenko 				else
47181af68beaSAlexander Stetsenko 					p = getpwuid(rid);
47191af68beaSAlexander Stetsenko 
47201af68beaSAlexander Stetsenko 				if (p != NULL)
47211af68beaSAlexander Stetsenko 					rid = p->pw_uid;
47221af68beaSAlexander Stetsenko 				else {
47231af68beaSAlexander Stetsenko 					(void) snprintf(errbuf, 256, gettext(
47241af68beaSAlexander Stetsenko 					    "invalid user %s"), curr);
47251af68beaSAlexander Stetsenko 					allow_usage(un, B_TRUE, errbuf);
47261af68beaSAlexander Stetsenko 				}
47271af68beaSAlexander Stetsenko 			} else if (opts->group) {
47281af68beaSAlexander Stetsenko 				who_type = ZFS_DELEG_GROUP;
47291af68beaSAlexander Stetsenko 				if (*endch != '\0')
47301af68beaSAlexander Stetsenko 					g = getgrnam(curr);
47311af68beaSAlexander Stetsenko 				else
47321af68beaSAlexander Stetsenko 					g = getgrgid(rid);
47331af68beaSAlexander Stetsenko 
47341af68beaSAlexander Stetsenko 				if (g != NULL)
47351af68beaSAlexander Stetsenko 					rid = g->gr_gid;
47361af68beaSAlexander Stetsenko 				else {
47371af68beaSAlexander Stetsenko 					(void) snprintf(errbuf, 256, gettext(
47381af68beaSAlexander Stetsenko 					    "invalid group %s"),  curr);
47391af68beaSAlexander Stetsenko 					allow_usage(un, B_TRUE, errbuf);
47401af68beaSAlexander Stetsenko 				}
47411af68beaSAlexander Stetsenko 			} else {
47421af68beaSAlexander Stetsenko 				if (*endch != '\0') {
47431af68beaSAlexander Stetsenko 					p = getpwnam(curr);
47441af68beaSAlexander Stetsenko 				} else {
47451af68beaSAlexander Stetsenko 					p = getpwuid(rid);
47461af68beaSAlexander Stetsenko 				}
47471af68beaSAlexander Stetsenko 
47481af68beaSAlexander Stetsenko 				if (p == NULL)
47491af68beaSAlexander Stetsenko 					if (*endch != '\0') {
47501af68beaSAlexander Stetsenko 						g = getgrnam(curr);
47511af68beaSAlexander Stetsenko 					} else {
47521af68beaSAlexander Stetsenko 						g = getgrgid(rid);
47531af68beaSAlexander Stetsenko 					}
47541af68beaSAlexander Stetsenko 
47551af68beaSAlexander Stetsenko 				if (p != NULL) {
47561af68beaSAlexander Stetsenko 					who_type = ZFS_DELEG_USER;
47571af68beaSAlexander Stetsenko 					rid = p->pw_uid;
47581af68beaSAlexander Stetsenko 				} else if (g != NULL) {
47591af68beaSAlexander Stetsenko 					who_type = ZFS_DELEG_GROUP;
47601af68beaSAlexander Stetsenko 					rid = g->gr_gid;
47611af68beaSAlexander Stetsenko 				} else {
47621af68beaSAlexander Stetsenko 					(void) snprintf(errbuf, 256, gettext(
47631af68beaSAlexander Stetsenko 					    "invalid user/group %s"), curr);
47641af68beaSAlexander Stetsenko 					allow_usage(un, B_TRUE, errbuf);
47651af68beaSAlexander Stetsenko 				}
47661af68beaSAlexander Stetsenko 			}
47671af68beaSAlexander Stetsenko 
47681af68beaSAlexander Stetsenko 			(void) sprintf(id, "%u", rid);
47691af68beaSAlexander Stetsenko 			who = id;
47701af68beaSAlexander Stetsenko 
47711af68beaSAlexander Stetsenko 			store_allow_perm(who_type, opts->local,
47721af68beaSAlexander Stetsenko 			    opts->descend, who, opts->perms, *nvlp);
47731af68beaSAlexander Stetsenko 			curr = delim + 1;
47741af68beaSAlexander Stetsenko 		}
47751af68beaSAlexander Stetsenko 	}
47761af68beaSAlexander Stetsenko 
47771af68beaSAlexander Stetsenko 	return (0);
47781af68beaSAlexander Stetsenko }
47791af68beaSAlexander Stetsenko 
47801af68beaSAlexander Stetsenko static void
47811af68beaSAlexander Stetsenko print_set_creat_perms(uu_avl_t *who_avl)
47821af68beaSAlexander Stetsenko {
47831af68beaSAlexander Stetsenko 	const char *sc_title[] = {
47841af68beaSAlexander Stetsenko 		gettext("Permission sets:\n"),
47851af68beaSAlexander Stetsenko 		gettext("Create time permissions:\n"),
47861af68beaSAlexander Stetsenko 		NULL
47871af68beaSAlexander Stetsenko 	};
47881af68beaSAlexander Stetsenko 	const char **title_ptr = sc_title;
47891af68beaSAlexander Stetsenko 	who_perm_node_t *who_node = NULL;
47901af68beaSAlexander Stetsenko 	int prev_weight = -1;
47911af68beaSAlexander Stetsenko 
47921af68beaSAlexander Stetsenko 	for (who_node = uu_avl_first(who_avl); who_node != NULL;
47931af68beaSAlexander Stetsenko 	    who_node = uu_avl_next(who_avl, who_node)) {
47941af68beaSAlexander Stetsenko 		uu_avl_t *avl = who_node->who_perm.who_deleg_perm_avl;
47951af68beaSAlexander Stetsenko 		zfs_deleg_who_type_t who_type = who_node->who_perm.who_type;
47961af68beaSAlexander Stetsenko 		const char *who_name = who_node->who_perm.who_name;
47971af68beaSAlexander Stetsenko 		int weight = who_type2weight(who_type);
47981af68beaSAlexander Stetsenko 		boolean_t first = B_TRUE;
47991af68beaSAlexander Stetsenko 		deleg_perm_node_t *deleg_node;
48001af68beaSAlexander Stetsenko 
48011af68beaSAlexander Stetsenko 		if (prev_weight != weight) {
48021af68beaSAlexander Stetsenko 			(void) printf(*title_ptr++);
48031af68beaSAlexander Stetsenko 			prev_weight = weight;
48041af68beaSAlexander Stetsenko 		}
48051af68beaSAlexander Stetsenko 
48061af68beaSAlexander Stetsenko 		if (who_name == NULL || strnlen(who_name, 1) == 0)
48071af68beaSAlexander Stetsenko 			(void) printf("\t");
48081af68beaSAlexander Stetsenko 		else
48091af68beaSAlexander Stetsenko 			(void) printf("\t%s ", who_name);
48101af68beaSAlexander Stetsenko 
48111af68beaSAlexander Stetsenko 		for (deleg_node = uu_avl_first(avl); deleg_node != NULL;
48121af68beaSAlexander Stetsenko 		    deleg_node = uu_avl_next(avl, deleg_node)) {
48131af68beaSAlexander Stetsenko 			if (first) {
48141af68beaSAlexander Stetsenko 				(void) printf("%s",
48151af68beaSAlexander Stetsenko 				    deleg_node->dpn_perm.dp_name);
48161af68beaSAlexander Stetsenko 				first = B_FALSE;
48171af68beaSAlexander Stetsenko 			} else
48181af68beaSAlexander Stetsenko 				(void) printf(",%s",
48191af68beaSAlexander Stetsenko 				    deleg_node->dpn_perm.dp_name);
48201af68beaSAlexander Stetsenko 		}
48211af68beaSAlexander Stetsenko 
48221af68beaSAlexander Stetsenko 		(void) printf("\n");
48231af68beaSAlexander Stetsenko 	}
48241af68beaSAlexander Stetsenko }
48251af68beaSAlexander Stetsenko 
48261af68beaSAlexander Stetsenko static void inline
48271af68beaSAlexander Stetsenko print_uge_deleg_perms(uu_avl_t *who_avl, boolean_t local, boolean_t descend,
48281af68beaSAlexander Stetsenko     const char *title)
48291af68beaSAlexander Stetsenko {
48301af68beaSAlexander Stetsenko 	who_perm_node_t *who_node = NULL;
48311af68beaSAlexander Stetsenko 	boolean_t prt_title = B_TRUE;
48321af68beaSAlexander Stetsenko 	uu_avl_walk_t *walk;
48331af68beaSAlexander Stetsenko 
48341af68beaSAlexander Stetsenko 	if ((walk = uu_avl_walk_start(who_avl, UU_WALK_ROBUST)) == NULL)
48351af68beaSAlexander Stetsenko 		nomem();
48361af68beaSAlexander Stetsenko 
48371af68beaSAlexander Stetsenko 	while ((who_node = uu_avl_walk_next(walk)) != NULL) {
48381af68beaSAlexander Stetsenko 		const char *who_name = who_node->who_perm.who_name;
48391af68beaSAlexander Stetsenko 		const char *nice_who_name = who_node->who_perm.who_ug_name;
48401af68beaSAlexander Stetsenko 		uu_avl_t *avl = who_node->who_perm.who_deleg_perm_avl;
48411af68beaSAlexander Stetsenko 		zfs_deleg_who_type_t who_type = who_node->who_perm.who_type;
48421af68beaSAlexander Stetsenko 		char delim = ' ';
48431af68beaSAlexander Stetsenko 		deleg_perm_node_t *deleg_node;
48441af68beaSAlexander Stetsenko 		boolean_t prt_who = B_TRUE;
48451af68beaSAlexander Stetsenko 
48461af68beaSAlexander Stetsenko 		for (deleg_node = uu_avl_first(avl);
48471af68beaSAlexander Stetsenko 		    deleg_node != NULL;
48481af68beaSAlexander Stetsenko 		    deleg_node = uu_avl_next(avl, deleg_node)) {
48491af68beaSAlexander Stetsenko 			if (local != deleg_node->dpn_perm.dp_local ||
48501af68beaSAlexander Stetsenko 			    descend != deleg_node->dpn_perm.dp_descend)
48511af68beaSAlexander Stetsenko 				continue;
48521af68beaSAlexander Stetsenko 
48531af68beaSAlexander Stetsenko 			if (prt_who) {
48541af68beaSAlexander Stetsenko 				const char *who = NULL;
48551af68beaSAlexander Stetsenko 				if (prt_title) {
48561af68beaSAlexander Stetsenko 					prt_title = B_FALSE;
48571af68beaSAlexander Stetsenko 					(void) printf(title);
48581af68beaSAlexander Stetsenko 				}
48591af68beaSAlexander Stetsenko 
48601af68beaSAlexander Stetsenko 				switch (who_type) {
48611af68beaSAlexander Stetsenko 				case ZFS_DELEG_USER_SETS:
48621af68beaSAlexander Stetsenko 				case ZFS_DELEG_USER:
48631af68beaSAlexander Stetsenko 					who = gettext("user");
48641af68beaSAlexander Stetsenko 					if (nice_who_name)
48651af68beaSAlexander Stetsenko 						who_name  = nice_who_name;
48661af68beaSAlexander Stetsenko 					break;
48671af68beaSAlexander Stetsenko 				case ZFS_DELEG_GROUP_SETS:
48681af68beaSAlexander Stetsenko 				case ZFS_DELEG_GROUP:
48691af68beaSAlexander Stetsenko 					who = gettext("group");
48701af68beaSAlexander Stetsenko 					if (nice_who_name)
48711af68beaSAlexander Stetsenko 						who_name  = nice_who_name;
48721af68beaSAlexander Stetsenko 					break;
48731af68beaSAlexander Stetsenko 				case ZFS_DELEG_EVERYONE_SETS:
48741af68beaSAlexander Stetsenko 				case ZFS_DELEG_EVERYONE:
48751af68beaSAlexander Stetsenko 					who = gettext("everyone");
48761af68beaSAlexander Stetsenko 					who_name = NULL;
48771af68beaSAlexander Stetsenko 				}
48781af68beaSAlexander Stetsenko 
48791af68beaSAlexander Stetsenko 				prt_who = B_FALSE;
48801af68beaSAlexander Stetsenko 				if (who_name == NULL)
48811af68beaSAlexander Stetsenko 					(void) printf("\t%s", who);
48821af68beaSAlexander Stetsenko 				else
48831af68beaSAlexander Stetsenko 					(void) printf("\t%s %s", who, who_name);
48841af68beaSAlexander Stetsenko 			}
48851af68beaSAlexander Stetsenko 
48861af68beaSAlexander Stetsenko 			(void) printf("%c%s", delim,
48871af68beaSAlexander Stetsenko 			    deleg_node->dpn_perm.dp_name);
48881af68beaSAlexander Stetsenko 			delim = ',';
48891af68beaSAlexander Stetsenko 		}
48901af68beaSAlexander Stetsenko 
48911af68beaSAlexander Stetsenko 		if (!prt_who)
48921af68beaSAlexander Stetsenko 			(void) printf("\n");
48931af68beaSAlexander Stetsenko 	}
48941af68beaSAlexander Stetsenko 
48951af68beaSAlexander Stetsenko 	uu_avl_walk_end(walk);
48961af68beaSAlexander Stetsenko }
48971af68beaSAlexander Stetsenko 
48981af68beaSAlexander Stetsenko static void
48991af68beaSAlexander Stetsenko print_fs_perms(fs_perm_set_t *fspset)
49001af68beaSAlexander Stetsenko {
49011af68beaSAlexander Stetsenko 	fs_perm_node_t *node = NULL;
49021af68beaSAlexander Stetsenko 	char buf[ZFS_MAXNAMELEN+32];
49031af68beaSAlexander Stetsenko 	const char *dsname = buf;
49041af68beaSAlexander Stetsenko 
49051af68beaSAlexander Stetsenko 	for (node = uu_list_first(fspset->fsps_list); node != NULL;
49061af68beaSAlexander Stetsenko 	    node = uu_list_next(fspset->fsps_list, node)) {
49071af68beaSAlexander Stetsenko 		uu_avl_t *sc_avl = node->fspn_fsperm.fsp_sc_avl;
49081af68beaSAlexander Stetsenko 		uu_avl_t *uge_avl = node->fspn_fsperm.fsp_uge_avl;
49091af68beaSAlexander Stetsenko 		int left = 0;
49101af68beaSAlexander Stetsenko 
49111af68beaSAlexander Stetsenko 		(void) snprintf(buf, ZFS_MAXNAMELEN+32,
49121af68beaSAlexander Stetsenko 		    gettext("---- Permissions on %s "),
49131af68beaSAlexander Stetsenko 		    node->fspn_fsperm.fsp_name);
49141af68beaSAlexander Stetsenko 		(void) printf(dsname);
49151af68beaSAlexander Stetsenko 		left = 70 - strlen(buf);
49161af68beaSAlexander Stetsenko 		while (left-- > 0)
49171af68beaSAlexander Stetsenko 			(void) printf("-");
49181af68beaSAlexander Stetsenko 		(void) printf("\n");
49191af68beaSAlexander Stetsenko 
49201af68beaSAlexander Stetsenko 		print_set_creat_perms(sc_avl);
49211af68beaSAlexander Stetsenko 		print_uge_deleg_perms(uge_avl, B_TRUE, B_FALSE,
49221af68beaSAlexander Stetsenko 		    gettext("Local permissions:\n"));
49231af68beaSAlexander Stetsenko 		print_uge_deleg_perms(uge_avl, B_FALSE, B_TRUE,
49241af68beaSAlexander Stetsenko 		    gettext("Descendent permissions:\n"));
49251af68beaSAlexander Stetsenko 		print_uge_deleg_perms(uge_avl, B_TRUE, B_TRUE,
49261af68beaSAlexander Stetsenko 		    gettext("Local+Descendent permissions:\n"));
49271af68beaSAlexander Stetsenko 	}
49281af68beaSAlexander Stetsenko }
49291af68beaSAlexander Stetsenko 
49301af68beaSAlexander Stetsenko static fs_perm_set_t fs_perm_set = { NULL, NULL, NULL, NULL };
49311af68beaSAlexander Stetsenko 
49321af68beaSAlexander Stetsenko struct deleg_perms {
49331af68beaSAlexander Stetsenko 	boolean_t un;
49341af68beaSAlexander Stetsenko 	nvlist_t *nvl;
49351af68beaSAlexander Stetsenko };
49361af68beaSAlexander Stetsenko 
49371af68beaSAlexander Stetsenko static int
49381af68beaSAlexander Stetsenko set_deleg_perms(zfs_handle_t *zhp, void *data)
49391af68beaSAlexander Stetsenko {
49401af68beaSAlexander Stetsenko 	struct deleg_perms *perms = (struct deleg_perms *)data;
49411af68beaSAlexander Stetsenko 	zfs_type_t zfs_type = zfs_get_type(zhp);
49421af68beaSAlexander Stetsenko 
49431af68beaSAlexander Stetsenko 	if (zfs_type != ZFS_TYPE_FILESYSTEM && zfs_type != ZFS_TYPE_VOLUME)
49441af68beaSAlexander Stetsenko 		return (0);
49451af68beaSAlexander Stetsenko 
49461af68beaSAlexander Stetsenko 	return (zfs_set_fsacl(zhp, perms->un, perms->nvl));
49471af68beaSAlexander Stetsenko }
49481af68beaSAlexander Stetsenko 
49491af68beaSAlexander Stetsenko static int
49501af68beaSAlexander Stetsenko zfs_do_allow_unallow_impl(int argc, char **argv, boolean_t un)
49511af68beaSAlexander Stetsenko {
49521af68beaSAlexander Stetsenko 	zfs_handle_t *zhp;
49531af68beaSAlexander Stetsenko 	nvlist_t *perm_nvl = NULL;
49541af68beaSAlexander Stetsenko 	nvlist_t *update_perm_nvl = NULL;
49551af68beaSAlexander Stetsenko 	int error = 1;
49561af68beaSAlexander Stetsenko 	int c;
49571af68beaSAlexander Stetsenko 	struct allow_opts opts = { 0 };
49581af68beaSAlexander Stetsenko 
49591af68beaSAlexander Stetsenko 	const char *optstr = un ? "ldugecsrh" : "ldugecsh";
49601af68beaSAlexander Stetsenko 
49611af68beaSAlexander Stetsenko 	/* check opts */
49621af68beaSAlexander Stetsenko 	while ((c = getopt(argc, argv, optstr)) != -1) {
49631af68beaSAlexander Stetsenko 		switch (c) {
49641af68beaSAlexander Stetsenko 		case 'l':
49651af68beaSAlexander Stetsenko 			opts.local = B_TRUE;
49661af68beaSAlexander Stetsenko 			break;
49671af68beaSAlexander Stetsenko 		case 'd':
49681af68beaSAlexander Stetsenko 			opts.descend = B_TRUE;
49691af68beaSAlexander Stetsenko 			break;
49701af68beaSAlexander Stetsenko 		case 'u':
49711af68beaSAlexander Stetsenko 			opts.user = B_TRUE;
49721af68beaSAlexander Stetsenko 			break;
49731af68beaSAlexander Stetsenko 		case 'g':
49741af68beaSAlexander Stetsenko 			opts.group = B_TRUE;
49751af68beaSAlexander Stetsenko 			break;
49761af68beaSAlexander Stetsenko 		case 'e':
49771af68beaSAlexander Stetsenko 			opts.everyone = B_TRUE;
49781af68beaSAlexander Stetsenko 			break;
49791af68beaSAlexander Stetsenko 		case 's':
49801af68beaSAlexander Stetsenko 			opts.set = B_TRUE;
49811af68beaSAlexander Stetsenko 			break;
49821af68beaSAlexander Stetsenko 		case 'c':
49831af68beaSAlexander Stetsenko 			opts.create = B_TRUE;
49841af68beaSAlexander Stetsenko 			break;
49851af68beaSAlexander Stetsenko 		case 'r':
49861af68beaSAlexander Stetsenko 			opts.recursive = B_TRUE;
49871af68beaSAlexander Stetsenko 			break;
49881af68beaSAlexander Stetsenko 		case ':':
49891af68beaSAlexander Stetsenko 			(void) fprintf(stderr, gettext("missing argument for "
49901af68beaSAlexander Stetsenko 			    "'%c' option\n"), optopt);
49911af68beaSAlexander Stetsenko 			usage(B_FALSE);
49921af68beaSAlexander Stetsenko 			break;
49931af68beaSAlexander Stetsenko 		case 'h':
49941af68beaSAlexander Stetsenko 			opts.prt_usage = B_TRUE;
49951af68beaSAlexander Stetsenko 			break;
49961af68beaSAlexander Stetsenko 		case '?':
49971af68beaSAlexander Stetsenko 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
49981af68beaSAlexander Stetsenko 			    optopt);
49991af68beaSAlexander Stetsenko 			usage(B_FALSE);
50001af68beaSAlexander Stetsenko 		}
50011af68beaSAlexander Stetsenko 	}
50021af68beaSAlexander Stetsenko 
50031af68beaSAlexander Stetsenko 	argc -= optind;
50041af68beaSAlexander Stetsenko 	argv += optind;
50051af68beaSAlexander Stetsenko 
50061af68beaSAlexander Stetsenko 	/* check arguments */
50071af68beaSAlexander Stetsenko 	parse_allow_args(argc, argv, un, &opts);
50081af68beaSAlexander Stetsenko 
50091af68beaSAlexander Stetsenko 	/* try to open the dataset */
5010a640714eSAlexander Eremin 	if ((zhp = zfs_open(g_zfs, opts.dataset, ZFS_TYPE_FILESYSTEM |
5011a640714eSAlexander Eremin 	    ZFS_TYPE_VOLUME)) == NULL) {
5012a640714eSAlexander Eremin 		(void) fprintf(stderr, "Failed to open dataset: %s\n",
50131af68beaSAlexander Stetsenko 		    opts.dataset);
50141af68beaSAlexander Stetsenko 		return (-1);
50151af68beaSAlexander Stetsenko 	}
50161af68beaSAlexander Stetsenko 
50171af68beaSAlexander Stetsenko 	if (zfs_get_fsacl(zhp, &perm_nvl) != 0)
50181af68beaSAlexander Stetsenko 		goto cleanup2;
50191af68beaSAlexander Stetsenko 
50201af68beaSAlexander Stetsenko 	fs_perm_set_init(&fs_perm_set);
50211af68beaSAlexander Stetsenko 	if (parse_fs_perm_set(&fs_perm_set, perm_nvl) != 0) {
5022a640714eSAlexander Eremin 		(void) fprintf(stderr, "Failed to parse fsacl permissions\n");
50231af68beaSAlexander Stetsenko 		goto cleanup1;
50241af68beaSAlexander Stetsenko 	}
50251af68beaSAlexander Stetsenko 
50261af68beaSAlexander Stetsenko 	if (opts.prt_perms)
50271af68beaSAlexander Stetsenko 		print_fs_perms(&fs_perm_set);
50281af68beaSAlexander Stetsenko 	else {
50291af68beaSAlexander Stetsenko 		(void) construct_fsacl_list(un, &opts, &update_perm_nvl);
50301af68beaSAlexander Stetsenko 		if (zfs_set_fsacl(zhp, un, update_perm_nvl) != 0)
50311af68beaSAlexander Stetsenko 			goto cleanup0;
50321af68beaSAlexander Stetsenko 
50331af68beaSAlexander Stetsenko 		if (un && opts.recursive) {
50341af68beaSAlexander Stetsenko 			struct deleg_perms data = { un, update_perm_nvl };
50351af68beaSAlexander Stetsenko 			if (zfs_iter_filesystems(zhp, set_deleg_perms,
50361af68beaSAlexander Stetsenko 			    &data) != 0)
50371af68beaSAlexander Stetsenko 				goto cleanup0;
50381af68beaSAlexander Stetsenko 		}
50391af68beaSAlexander Stetsenko 	}
50401af68beaSAlexander Stetsenko 
50411af68beaSAlexander Stetsenko 	error = 0;
50421af68beaSAlexander Stetsenko 
50431af68beaSAlexander Stetsenko cleanup0:
50441af68beaSAlexander Stetsenko 	nvlist_free(perm_nvl);
50451af68beaSAlexander Stetsenko 	if (update_perm_nvl != NULL)
50461af68beaSAlexander Stetsenko 		nvlist_free(update_perm_nvl);
50471af68beaSAlexander Stetsenko cleanup1:
50481af68beaSAlexander Stetsenko 	fs_perm_set_fini(&fs_perm_set);
50491af68beaSAlexander Stetsenko cleanup2:
50501af68beaSAlexander Stetsenko 	zfs_close(zhp);
50511af68beaSAlexander Stetsenko 
50521af68beaSAlexander Stetsenko 	return (error);
50531af68beaSAlexander Stetsenko }
50541af68beaSAlexander Stetsenko 
50551af68beaSAlexander Stetsenko /*
50561af68beaSAlexander Stetsenko  * zfs allow [-r] [-t] <tag> <snap> ...
50571af68beaSAlexander Stetsenko  *
50581af68beaSAlexander Stetsenko  *	-r	Recursively hold
50591af68beaSAlexander Stetsenko  *	-t	Temporary hold (hidden option)
50601af68beaSAlexander Stetsenko  *
50611af68beaSAlexander Stetsenko  * Apply a user-hold with the given tag to the list of snapshots.
50621af68beaSAlexander Stetsenko  */
50631af68beaSAlexander Stetsenko static int
50641af68beaSAlexander Stetsenko zfs_do_allow(int argc, char **argv)
50651af68beaSAlexander Stetsenko {
50661af68beaSAlexander Stetsenko 	return (zfs_do_allow_unallow_impl(argc, argv, B_FALSE));
50671af68beaSAlexander Stetsenko }
50681af68beaSAlexander Stetsenko 
50691af68beaSAlexander Stetsenko /*
50701af68beaSAlexander Stetsenko  * zfs unallow [-r] [-t] <tag> <snap> ...
50711af68beaSAlexander Stetsenko  *
50721af68beaSAlexander Stetsenko  *	-r	Recursively hold
50731af68beaSAlexander Stetsenko  *	-t	Temporary hold (hidden option)
50741af68beaSAlexander Stetsenko  *
50751af68beaSAlexander Stetsenko  * Apply a user-hold with the given tag to the list of snapshots.
50761af68beaSAlexander Stetsenko  */
50771af68beaSAlexander Stetsenko static int
50781af68beaSAlexander Stetsenko zfs_do_unallow(int argc, char **argv)
50791af68beaSAlexander Stetsenko {
50801af68beaSAlexander Stetsenko 	return (zfs_do_allow_unallow_impl(argc, argv, B_TRUE));
50811af68beaSAlexander Stetsenko }
50821af68beaSAlexander Stetsenko 
5083842727c2SChris Kirby static int
5084842727c2SChris Kirby zfs_do_hold_rele_impl(int argc, char **argv, boolean_t holding)
5085842727c2SChris Kirby {
5086842727c2SChris Kirby 	int errors = 0;
5087842727c2SChris Kirby 	int i;
5088842727c2SChris Kirby 	const char *tag;
5089842727c2SChris Kirby 	boolean_t recursive = B_FALSE;
5090ca45db41SChris Kirby 	boolean_t temphold = B_FALSE;
5091ca45db41SChris Kirby 	const char *opts = holding ? "rt" : "r";
5092842727c2SChris Kirby 	int c;
5093842727c2SChris Kirby 
5094842727c2SChris Kirby 	/* check options */
5095ca45db41SChris Kirby 	while ((c = getopt(argc, argv, opts)) != -1) {
5096842727c2SChris Kirby 		switch (c) {
5097842727c2SChris Kirby 		case 'r':
5098842727c2SChris Kirby 			recursive = B_TRUE;
5099842727c2SChris Kirby 			break;
5100ca45db41SChris Kirby 		case 't':
5101ca45db41SChris Kirby 			temphold = B_TRUE;
5102ca45db41SChris Kirby 			break;
5103842727c2SChris Kirby 		case '?':
5104842727c2SChris Kirby 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
5105842727c2SChris Kirby 			    optopt);
5106842727c2SChris Kirby 			usage(B_FALSE);
5107842727c2SChris Kirby 		}
5108842727c2SChris Kirby 	}
5109842727c2SChris Kirby 
5110842727c2SChris Kirby 	argc -= optind;
5111842727c2SChris Kirby 	argv += optind;
5112842727c2SChris Kirby 
5113842727c2SChris Kirby 	/* check number of arguments */
5114842727c2SChris Kirby 	if (argc < 2)
5115842727c2SChris Kirby 		usage(B_FALSE);
5116842727c2SChris Kirby 
5117842727c2SChris Kirby 	tag = argv[0];
5118842727c2SChris Kirby 	--argc;
5119842727c2SChris Kirby 	++argv;
5120842727c2SChris Kirby 
5121ca45db41SChris Kirby 	if (holding && tag[0] == '.') {
5122842727c2SChris Kirby 		/* tags starting with '.' are reserved for libzfs */
5123ca45db41SChris Kirby 		(void) fprintf(stderr, gettext("tag may not start with '.'\n"));
5124842727c2SChris Kirby 		usage(B_FALSE);
5125842727c2SChris Kirby 	}
5126842727c2SChris Kirby 
5127842727c2SChris Kirby 	for (i = 0; i < argc; ++i) {
5128842727c2SChris Kirby 		zfs_handle_t *zhp;
5129842727c2SChris Kirby 		char parent[ZFS_MAXNAMELEN];
5130842727c2SChris Kirby 		const char *delim;
5131842727c2SChris Kirby 		char *path = argv[i];
5132842727c2SChris Kirby 
5133842727c2SChris Kirby 		delim = strchr(path, '@');
5134842727c2SChris Kirby 		if (delim == NULL) {
5135842727c2SChris Kirby 			(void) fprintf(stderr,
5136842727c2SChris Kirby 			    gettext("'%s' is not a snapshot\n"), path);
5137842727c2SChris Kirby 			++errors;
5138842727c2SChris Kirby 			continue;
5139842727c2SChris Kirby 		}
5140842727c2SChris Kirby 		(void) strncpy(parent, path, delim - path);
5141842727c2SChris Kirby 		parent[delim - path] = '\0';
5142842727c2SChris Kirby 
5143842727c2SChris Kirby 		zhp = zfs_open(g_zfs, parent,
5144842727c2SChris Kirby 		    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
5145842727c2SChris Kirby 		if (zhp == NULL) {
5146842727c2SChris Kirby 			++errors;
5147842727c2SChris Kirby 			continue;
5148842727c2SChris Kirby 		}
5149ca45db41SChris Kirby 		if (holding) {
5150ca45db41SChris Kirby 			if (zfs_hold(zhp, delim+1, tag, recursive,
5151a7f53a56SChris Kirby 			    temphold, B_FALSE, -1, 0, 0) != 0)
5152842727c2SChris Kirby 				++errors;
5153ca45db41SChris Kirby 		} else {
5154ca45db41SChris Kirby 			if (zfs_release(zhp, delim+1, tag, recursive) != 0)
5155ca45db41SChris Kirby 				++errors;
5156ca45db41SChris Kirby 		}
5157842727c2SChris Kirby 		zfs_close(zhp);
5158842727c2SChris Kirby 	}
5159842727c2SChris Kirby 
5160842727c2SChris Kirby 	return (errors != 0);
5161842727c2SChris Kirby }
5162842727c2SChris Kirby 
5163842727c2SChris Kirby /*
5164ca45db41SChris Kirby  * zfs hold [-r] [-t] <tag> <snap> ...
5165842727c2SChris Kirby  *
5166842727c2SChris Kirby  *	-r	Recursively hold
5167ca45db41SChris Kirby  *	-t	Temporary hold (hidden option)
5168842727c2SChris Kirby  *
5169842727c2SChris Kirby  * Apply a user-hold with the given tag to the list of snapshots.
5170842727c2SChris Kirby  */
5171842727c2SChris Kirby static int
5172842727c2SChris Kirby zfs_do_hold(int argc, char **argv)
5173842727c2SChris Kirby {
5174842727c2SChris Kirby 	return (zfs_do_hold_rele_impl(argc, argv, B_TRUE));
5175842727c2SChris Kirby }
5176842727c2SChris Kirby 
5177842727c2SChris Kirby /*
5178842727c2SChris Kirby  * zfs release [-r] <tag> <snap> ...
5179842727c2SChris Kirby  *
5180842727c2SChris Kirby  *	-r	Recursively release
5181842727c2SChris Kirby  *
5182842727c2SChris Kirby  * Release a user-hold with the given tag from the list of snapshots.
5183842727c2SChris Kirby  */
5184842727c2SChris Kirby static int
5185842727c2SChris Kirby zfs_do_release(int argc, char **argv)
5186842727c2SChris Kirby {
5187842727c2SChris Kirby 	return (zfs_do_hold_rele_impl(argc, argv, B_FALSE));
5188842727c2SChris Kirby }
5189842727c2SChris Kirby 
51901af68beaSAlexander Stetsenko typedef struct holds_cbdata {
51911af68beaSAlexander Stetsenko 	boolean_t	cb_recursive;
51921af68beaSAlexander Stetsenko 	const char	*cb_snapname;
51931af68beaSAlexander Stetsenko 	nvlist_t	**cb_nvlp;
51941af68beaSAlexander Stetsenko 	size_t		cb_max_namelen;
51951af68beaSAlexander Stetsenko 	size_t		cb_max_taglen;
51961af68beaSAlexander Stetsenko } holds_cbdata_t;
51971af68beaSAlexander Stetsenko 
51981af68beaSAlexander Stetsenko #define	STRFTIME_FMT_STR "%a %b %e %k:%M %Y"
51991af68beaSAlexander Stetsenko #define	DATETIME_BUF_LEN (32)
52001af68beaSAlexander Stetsenko /*
52011af68beaSAlexander Stetsenko  *
52021af68beaSAlexander Stetsenko  */
52031af68beaSAlexander Stetsenko static void
52041af68beaSAlexander Stetsenko print_holds(boolean_t scripted, size_t nwidth, size_t tagwidth, nvlist_t *nvl)
52051af68beaSAlexander Stetsenko {
52061af68beaSAlexander Stetsenko 	int i;
52071af68beaSAlexander Stetsenko 	nvpair_t *nvp = NULL;
52081af68beaSAlexander Stetsenko 	char *hdr_cols[] = { "NAME", "TAG", "TIMESTAMP" };
52091af68beaSAlexander Stetsenko 	const char *col;
52101af68beaSAlexander Stetsenko 
52111af68beaSAlexander Stetsenko 	if (!scripted) {
52121af68beaSAlexander Stetsenko 		for (i = 0; i < 3; i++) {
52131af68beaSAlexander Stetsenko 			col = gettext(hdr_cols[i]);
52141af68beaSAlexander Stetsenko 			if (i < 2)
52151af68beaSAlexander Stetsenko 				(void) printf("%-*s  ", i ? tagwidth : nwidth,
52161af68beaSAlexander Stetsenko 				    col);
52171af68beaSAlexander Stetsenko 			else
52181af68beaSAlexander Stetsenko 				(void) printf("%s\n", col);
52191af68beaSAlexander Stetsenko 		}
52201af68beaSAlexander Stetsenko 	}
52211af68beaSAlexander Stetsenko 
52221af68beaSAlexander Stetsenko 	while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
52231af68beaSAlexander Stetsenko 		char *zname = nvpair_name(nvp);
52241af68beaSAlexander Stetsenko 		nvlist_t *nvl2;
52251af68beaSAlexander Stetsenko 		nvpair_t *nvp2 = NULL;
52261af68beaSAlexander Stetsenko 		(void) nvpair_value_nvlist(nvp, &nvl2);
52271af68beaSAlexander Stetsenko 		while ((nvp2 = nvlist_next_nvpair(nvl2, nvp2)) != NULL) {
52281af68beaSAlexander Stetsenko 			char tsbuf[DATETIME_BUF_LEN];
52291af68beaSAlexander Stetsenko 			char *tagname = nvpair_name(nvp2);
52301af68beaSAlexander Stetsenko 			uint64_t val = 0;
52311af68beaSAlexander Stetsenko 			time_t time;
52321af68beaSAlexander Stetsenko 			struct tm t;
52331af68beaSAlexander Stetsenko 			char sep = scripted ? '\t' : ' ';
52341af68beaSAlexander Stetsenko 			size_t sepnum = scripted ? 1 : 2;
52351af68beaSAlexander Stetsenko 
52361af68beaSAlexander Stetsenko 			(void) nvpair_value_uint64(nvp2, &val);
52371af68beaSAlexander Stetsenko 			time = (time_t)val;
52381af68beaSAlexander Stetsenko 			(void) localtime_r(&time, &t);
52391af68beaSAlexander Stetsenko 			(void) strftime(tsbuf, DATETIME_BUF_LEN,
52401af68beaSAlexander Stetsenko 			    gettext(STRFTIME_FMT_STR), &t);
52411af68beaSAlexander Stetsenko 
52421af68beaSAlexander Stetsenko 			(void) printf("%-*s%*c%-*s%*c%s\n", nwidth, zname,
52431af68beaSAlexander Stetsenko 			    sepnum, sep, tagwidth, tagname, sepnum, sep, tsbuf);
52441af68beaSAlexander Stetsenko 		}
52451af68beaSAlexander Stetsenko 	}
52461af68beaSAlexander Stetsenko }
52471af68beaSAlexander Stetsenko 
52481af68beaSAlexander Stetsenko /*
52491af68beaSAlexander Stetsenko  * Generic callback function to list a dataset or snapshot.
52501af68beaSAlexander Stetsenko  */
52511af68beaSAlexander Stetsenko static int
52521af68beaSAlexander Stetsenko holds_callback(zfs_handle_t *zhp, void *data)
52531af68beaSAlexander Stetsenko {
52541af68beaSAlexander Stetsenko 	holds_cbdata_t *cbp = data;
52551af68beaSAlexander Stetsenko 	nvlist_t *top_nvl = *cbp->cb_nvlp;
52561af68beaSAlexander Stetsenko 	nvlist_t *nvl = NULL;
52571af68beaSAlexander Stetsenko 	nvpair_t *nvp = NULL;
52581af68beaSAlexander Stetsenko 	const char *zname = zfs_get_name(zhp);
52591af68beaSAlexander Stetsenko 	size_t znamelen = strnlen(zname, ZFS_MAXNAMELEN);
52601af68beaSAlexander Stetsenko 
52611af68beaSAlexander Stetsenko 	if (cbp->cb_recursive) {
52621af68beaSAlexander Stetsenko 		const char *snapname;
52631af68beaSAlexander Stetsenko 		char *delim  = strchr(zname, '@');
52641af68beaSAlexander Stetsenko 		if (delim == NULL)
52651af68beaSAlexander Stetsenko 			return (0);
52661af68beaSAlexander Stetsenko 
52671af68beaSAlexander Stetsenko 		snapname = delim + 1;
52681af68beaSAlexander Stetsenko 		if (strcmp(cbp->cb_snapname, snapname))
52691af68beaSAlexander Stetsenko 			return (0);
52701af68beaSAlexander Stetsenko 	}
52711af68beaSAlexander Stetsenko 
52721af68beaSAlexander Stetsenko 	if (zfs_get_holds(zhp, &nvl) != 0)
52731af68beaSAlexander Stetsenko 		return (-1);
52741af68beaSAlexander Stetsenko 
52751af68beaSAlexander Stetsenko 	if (znamelen > cbp->cb_max_namelen)
52761af68beaSAlexander Stetsenko 		cbp->cb_max_namelen  = znamelen;
52771af68beaSAlexander Stetsenko 
52781af68beaSAlexander Stetsenko 	while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
52791af68beaSAlexander Stetsenko 		const char *tag = nvpair_name(nvp);
52801af68beaSAlexander Stetsenko 		size_t taglen = strnlen(tag, MAXNAMELEN);
52811af68beaSAlexander Stetsenko 		if (taglen > cbp->cb_max_taglen)
52821af68beaSAlexander Stetsenko 			cbp->cb_max_taglen  = taglen;
52831af68beaSAlexander Stetsenko 	}
52841af68beaSAlexander Stetsenko 
52851af68beaSAlexander Stetsenko 	return (nvlist_add_nvlist(top_nvl, zname, nvl));
52861af68beaSAlexander Stetsenko }
52871af68beaSAlexander Stetsenko 
52881af68beaSAlexander Stetsenko /*
52891af68beaSAlexander Stetsenko  * zfs holds [-r] <snap> ...
52901af68beaSAlexander Stetsenko  *
52911af68beaSAlexander Stetsenko  *	-r	Recursively hold
52921af68beaSAlexander Stetsenko  */
52931af68beaSAlexander Stetsenko static int
52941af68beaSAlexander Stetsenko zfs_do_holds(int argc, char **argv)
52951af68beaSAlexander Stetsenko {
52961af68beaSAlexander Stetsenko 	int errors = 0;
52971af68beaSAlexander Stetsenko 	int c;
52981af68beaSAlexander Stetsenko 	int i;
52991af68beaSAlexander Stetsenko 	boolean_t scripted = B_FALSE;
53001af68beaSAlexander Stetsenko 	boolean_t recursive = B_FALSE;
53011af68beaSAlexander Stetsenko 	const char *opts = "rH";
53021af68beaSAlexander Stetsenko 	nvlist_t *nvl;
53031af68beaSAlexander Stetsenko 
53041af68beaSAlexander Stetsenko 	int types = ZFS_TYPE_SNAPSHOT;
53051af68beaSAlexander Stetsenko 	holds_cbdata_t cb = { 0 };
53061af68beaSAlexander Stetsenko 
53071af68beaSAlexander Stetsenko 	int limit = 0;
530805c998d6SRichard Lowe 	int ret = 0;
53091af68beaSAlexander Stetsenko 	int flags = 0;
53101af68beaSAlexander Stetsenko 
53111af68beaSAlexander Stetsenko 	/* check options */
53121af68beaSAlexander Stetsenko 	while ((c = getopt(argc, argv, opts)) != -1) {
53131af68beaSAlexander Stetsenko 		switch (c) {
53141af68beaSAlexander Stetsenko 		case 'r':
53151af68beaSAlexander Stetsenko 			recursive = B_TRUE;
53161af68beaSAlexander Stetsenko 			break;
53171af68beaSAlexander Stetsenko 		case 'H':
53181af68beaSAlexander Stetsenko 			scripted = B_TRUE;
53191af68beaSAlexander Stetsenko 			break;
53201af68beaSAlexander Stetsenko 		case '?':
53211af68beaSAlexander Stetsenko 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
53221af68beaSAlexander Stetsenko 			    optopt);
53231af68beaSAlexander Stetsenko 			usage(B_FALSE);
53241af68beaSAlexander Stetsenko 		}
53251af68beaSAlexander Stetsenko 	}
53261af68beaSAlexander Stetsenko 
53271af68beaSAlexander Stetsenko 	if (recursive) {
53281af68beaSAlexander Stetsenko 		types |= ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME;
53291af68beaSAlexander Stetsenko 		flags |= ZFS_ITER_RECURSE;
53301af68beaSAlexander Stetsenko 	}
53311af68beaSAlexander Stetsenko 
53321af68beaSAlexander Stetsenko 	argc -= optind;
53331af68beaSAlexander Stetsenko 	argv += optind;
53341af68beaSAlexander Stetsenko 
53351af68beaSAlexander Stetsenko 	/* check number of arguments */
53361af68beaSAlexander Stetsenko 	if (argc < 1)
53371af68beaSAlexander Stetsenko 		usage(B_FALSE);
53381af68beaSAlexander Stetsenko 
53391af68beaSAlexander Stetsenko 	if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0)
53401af68beaSAlexander Stetsenko 		nomem();
53411af68beaSAlexander Stetsenko 
53421af68beaSAlexander Stetsenko 	for (i = 0; i < argc; ++i) {
53431af68beaSAlexander Stetsenko 		char *snapshot = argv[i];
53441af68beaSAlexander Stetsenko 		const char *delim;
53451af68beaSAlexander Stetsenko 		const char *snapname;
53461af68beaSAlexander Stetsenko 
53471af68beaSAlexander Stetsenko 		delim = strchr(snapshot, '@');
53481af68beaSAlexander Stetsenko 		if (delim == NULL) {
53491af68beaSAlexander Stetsenko 			(void) fprintf(stderr,
53501af68beaSAlexander Stetsenko 			    gettext("'%s' is not a snapshot\n"), snapshot);
53511af68beaSAlexander Stetsenko 			++errors;
53521af68beaSAlexander Stetsenko 			continue;
53531af68beaSAlexander Stetsenko 		}
53541af68beaSAlexander Stetsenko 		snapname = delim + 1;
53551af68beaSAlexander Stetsenko 		if (recursive)
53561af68beaSAlexander Stetsenko 			snapshot[delim - snapshot] = '\0';
53571af68beaSAlexander Stetsenko 
53581af68beaSAlexander Stetsenko 		cb.cb_recursive = recursive;
53591af68beaSAlexander Stetsenko 		cb.cb_snapname = snapname;
53601af68beaSAlexander Stetsenko 		cb.cb_nvlp = &nvl;
53611af68beaSAlexander Stetsenko 
53621af68beaSAlexander Stetsenko 		/*
53631af68beaSAlexander Stetsenko 		 *  1. collect holds data, set format options
53641af68beaSAlexander Stetsenko 		 */
53651af68beaSAlexander Stetsenko 		ret = zfs_for_each(argc, argv, flags, types, NULL, NULL, limit,
53661af68beaSAlexander Stetsenko 		    holds_callback, &cb);
53671af68beaSAlexander Stetsenko 		if (ret != 0)
53681af68beaSAlexander Stetsenko 			++errors;
53691af68beaSAlexander Stetsenko 	}
53701af68beaSAlexander Stetsenko 
53711af68beaSAlexander Stetsenko 	/*
53721af68beaSAlexander Stetsenko 	 *  2. print holds data
53731af68beaSAlexander Stetsenko 	 */
53741af68beaSAlexander Stetsenko 	print_holds(scripted, cb.cb_max_namelen, cb.cb_max_taglen, nvl);
53751af68beaSAlexander Stetsenko 
53761af68beaSAlexander Stetsenko 	if (nvlist_empty(nvl))
53771af68beaSAlexander Stetsenko 		(void) printf(gettext("no datasets available\n"));
53781af68beaSAlexander Stetsenko 
53791af68beaSAlexander Stetsenko 	nvlist_free(nvl);
53801af68beaSAlexander Stetsenko 
53811af68beaSAlexander Stetsenko 	return (0 != errors);
53821af68beaSAlexander Stetsenko }
53831af68beaSAlexander Stetsenko 
5384dae68f5eSmmusante #define	CHECK_SPINNER 30
5385dae68f5eSmmusante #define	SPINNER_TIME 3		/* seconds */
5386dae68f5eSmmusante #define	MOUNT_TIME 5		/* seconds */
5387dae68f5eSmmusante 
53887f7322feSeschrock static int
5389f3861e1aSahl get_one_dataset(zfs_handle_t *zhp, void *data)
53907f7322feSeschrock {
5391a8b6ddafSMark J Musante 	static char *spin[] = { "-", "\\", "|", "/" };
5392dae68f5eSmmusante 	static int spinval = 0;
5393dae68f5eSmmusante 	static int spincheck = 0;
5394dae68f5eSmmusante 	static time_t last_spin_time = (time_t)0;
53959d9a58e3SEric Taylor 	get_all_cb_t *cbp = data;
5396f3861e1aSahl 	zfs_type_t type = zfs_get_type(zhp);
53977f7322feSeschrock 
5398dae68f5eSmmusante 	if (cbp->cb_verbose) {
5399dae68f5eSmmusante 		if (--spincheck < 0) {
5400dae68f5eSmmusante 			time_t now = time(NULL);
5401dae68f5eSmmusante 			if (last_spin_time + SPINNER_TIME < now) {
5402a8b6ddafSMark J Musante 				update_progress(spin[spinval++ % 4]);
5403dae68f5eSmmusante 				last_spin_time = now;
5404dae68f5eSmmusante 			}
5405dae68f5eSmmusante 			spincheck = CHECK_SPINNER;
5406dae68f5eSmmusante 		}
5407dae68f5eSmmusante 	}
5408dae68f5eSmmusante 
54097f7322feSeschrock 	/*
5410f3861e1aSahl 	 * Interate over any nested datasets.
54117f7322feSeschrock 	 */
54129d9a58e3SEric Taylor 	if (zfs_iter_filesystems(zhp, get_one_dataset, data) != 0) {
54133ccfa83cSahrens 		zfs_close(zhp);
5414f3861e1aSahl 		return (1);
5415f3861e1aSahl 	}
5416f3861e1aSahl 
5417f3861e1aSahl 	/*
5418f3861e1aSahl 	 * Skip any datasets whose type does not match.
5419f3861e1aSahl 	 */
54209d9a58e3SEric Taylor 	if ((type & ZFS_TYPE_FILESYSTEM) == 0) {
54217f7322feSeschrock 		zfs_close(zhp);
54227f7322feSeschrock 		return (0);
54237f7322feSeschrock 	}
54249d9a58e3SEric Taylor 	libzfs_add_handle(cbp, zhp);
54259d9a58e3SEric Taylor 	assert(cbp->cb_used <= cbp->cb_alloc);
54267f7322feSeschrock 
5427f3861e1aSahl 	return (0);
54287f7322feSeschrock }
54297f7322feSeschrock 
54307f7322feSeschrock static void
54319d9a58e3SEric Taylor get_all_datasets(zfs_handle_t ***dslist, size_t *count, boolean_t verbose)
54327f7322feSeschrock {
54339d9a58e3SEric Taylor 	get_all_cb_t cb = { 0 };
5434dae68f5eSmmusante 	cb.cb_verbose = verbose;
54359d9a58e3SEric Taylor 	cb.cb_getone = get_one_dataset;
5436dae68f5eSmmusante 
5437a8b6ddafSMark J Musante 	if (verbose)
5438a8b6ddafSMark J Musante 		set_progress_header(gettext("Reading ZFS config"));
5439f3861e1aSahl 	(void) zfs_iter_root(g_zfs, get_one_dataset, &cb);
54407f7322feSeschrock 
5441f3861e1aSahl 	*dslist = cb.cb_handles;
54427f7322feSeschrock 	*count = cb.cb_used;
5443dae68f5eSmmusante 
5444a8b6ddafSMark J Musante 	if (verbose)
5445a8b6ddafSMark J Musante 		finish_progress(gettext("done."));
54467f7322feSeschrock }
54477f7322feSeschrock 
5448fa9e4066Sahrens /*
5449fa9e4066Sahrens  * Generic callback for sharing or mounting filesystems.  Because the code is so
5450fa9e4066Sahrens  * similar, we have a common function with an extra parameter to determine which
5451fa9e4066Sahrens  * mode we are using.
5452fa9e4066Sahrens  */
5453fa9e4066Sahrens #define	OP_SHARE	0x1
5454fa9e4066Sahrens #define	OP_MOUNT	0x2
5455fa9e4066Sahrens 
5456fa9e4066Sahrens /*
5457f3861e1aSahl  * Share or mount a dataset.
5458fa9e4066Sahrens  */
5459fa9e4066Sahrens static int
5460da6c28aaSamw share_mount_one(zfs_handle_t *zhp, int op, int flags, char *protocol,
5461da6c28aaSamw     boolean_t explicit, const char *options)
5462fa9e4066Sahrens {
5463fa9e4066Sahrens 	char mountpoint[ZFS_MAXPROPLEN];
5464fa9e4066Sahrens 	char shareopts[ZFS_MAXPROPLEN];
5465da6c28aaSamw 	char smbshareopts[ZFS_MAXPROPLEN];
5466f3861e1aSahl 	const char *cmdname = op == OP_SHARE ? "share" : "mount";
5467fa9e4066Sahrens 	struct mnttab mnt;
5468e9dbad6fSeschrock 	uint64_t zoned, canmount;
5469da6c28aaSamw 	boolean_t shared_nfs, shared_smb;
5470fa9e4066Sahrens 
54719d9a58e3SEric Taylor 	assert(zfs_get_type(zhp) & ZFS_TYPE_FILESYSTEM);
5472fa9e4066Sahrens 
5473fa9e4066Sahrens 	/*
5474f3861e1aSahl 	 * Check to make sure we can mount/share this dataset.  If we
5475f3861e1aSahl 	 * are in the global zone and the filesystem is exported to a
5476f3861e1aSahl 	 * local zone, or if we are in a local zone and the
5477f3861e1aSahl 	 * filesystem is not exported, then it is an error.
5478fa9e4066Sahrens 	 */
5479fa9e4066Sahrens 	zoned = zfs_prop_get_int(zhp, ZFS_PROP_ZONED);
5480fa9e4066Sahrens 
5481fa9e4066Sahrens 	if (zoned && getzoneid() == GLOBAL_ZONEID) {
5482f3861e1aSahl 		if (!explicit)
5483fa9e4066Sahrens 			return (0);
5484fa9e4066Sahrens 
5485f3861e1aSahl 		(void) fprintf(stderr, gettext("cannot %s '%s': "
5486f3861e1aSahl 		    "dataset is exported to a local zone\n"), cmdname,
5487f3861e1aSahl 		    zfs_get_name(zhp));
5488fa9e4066Sahrens 		return (1);
5489fa9e4066Sahrens 
5490fa9e4066Sahrens 	} else if (!zoned && getzoneid() != GLOBAL_ZONEID) {
5491f3861e1aSahl 		if (!explicit)
5492fa9e4066Sahrens 			return (0);
5493fa9e4066Sahrens 
5494f3861e1aSahl 		(void) fprintf(stderr, gettext("cannot %s '%s': "
5495f3861e1aSahl 		    "permission denied\n"), cmdname,
5496f3861e1aSahl 		    zfs_get_name(zhp));
5497fa9e4066Sahrens 		return (1);
5498fa9e4066Sahrens 	}
5499fa9e4066Sahrens 
5500fa9e4066Sahrens 	/*
5501f3861e1aSahl 	 * Ignore any filesystems which don't apply to us. This
5502f3861e1aSahl 	 * includes those with a legacy mountpoint, or those with
5503f3861e1aSahl 	 * legacy share options.
5504fa9e4066Sahrens 	 */
5505fa9e4066Sahrens 	verify(zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint,
550699653d4eSeschrock 	    sizeof (mountpoint), NULL, NULL, 0, B_FALSE) == 0);
5507fa9e4066Sahrens 	verify(zfs_prop_get(zhp, ZFS_PROP_SHARENFS, shareopts,
550899653d4eSeschrock 	    sizeof (shareopts), NULL, NULL, 0, B_FALSE) == 0);
5509da6c28aaSamw 	verify(zfs_prop_get(zhp, ZFS_PROP_SHARESMB, smbshareopts,
5510da6c28aaSamw 	    sizeof (smbshareopts), NULL, NULL, 0, B_FALSE) == 0);
5511fa9e4066Sahrens 
5512da6c28aaSamw 	if (op == OP_SHARE && strcmp(shareopts, "off") == 0 &&
5513da6c28aaSamw 	    strcmp(smbshareopts, "off") == 0) {
5514f3861e1aSahl 		if (!explicit)
5515fa9e4066Sahrens 			return (0);
5516fa9e4066Sahrens 
5517fa9e4066Sahrens 		(void) fprintf(stderr, gettext("cannot share '%s': "
5518fa9e4066Sahrens 		    "legacy share\n"), zfs_get_name(zhp));
5519fa9e4066Sahrens 		(void) fprintf(stderr, gettext("use share(1M) to "
5520deb8317bSMark J Musante 		    "share this filesystem, or set "
5521deb8317bSMark J Musante 		    "sharenfs property on\n"));
5522fa9e4066Sahrens 		return (1);
5523fa9e4066Sahrens 	}
5524fa9e4066Sahrens 
5525fa9e4066Sahrens 	/*
5526f3861e1aSahl 	 * We cannot share or mount legacy filesystems. If the
5527f3861e1aSahl 	 * shareopts is non-legacy but the mountpoint is legacy, we
5528f3861e1aSahl 	 * treat it as a legacy share.
5529fa9e4066Sahrens 	 */
5530fa9e4066Sahrens 	if (strcmp(mountpoint, "legacy") == 0) {
5531f3861e1aSahl 		if (!explicit)
5532fa9e4066Sahrens 			return (0);
5533fa9e4066Sahrens 
5534fa9e4066Sahrens 		(void) fprintf(stderr, gettext("cannot %s '%s': "
5535fa9e4066Sahrens 		    "legacy mountpoint\n"), cmdname, zfs_get_name(zhp));
55363cb34c60Sahrens 		(void) fprintf(stderr, gettext("use %s(1M) to "
55373cb34c60Sahrens 		    "%s this filesystem\n"), cmdname, cmdname);
5538fa9e4066Sahrens 		return (1);
5539fa9e4066Sahrens 	}
5540fa9e4066Sahrens 
5541fa9e4066Sahrens 	if (strcmp(mountpoint, "none") == 0) {
5542f3861e1aSahl 		if (!explicit)
5543fa9e4066Sahrens 			return (0);
5544fa9e4066Sahrens 
5545fa9e4066Sahrens 		(void) fprintf(stderr, gettext("cannot %s '%s': no "
5546fa9e4066Sahrens 		    "mountpoint set\n"), cmdname, zfs_get_name(zhp));
5547fa9e4066Sahrens 		return (1);
5548fa9e4066Sahrens 	}
5549fa9e4066Sahrens 
5550a227b7f4Shs24103 	/*
5551a227b7f4Shs24103 	 * canmount	explicit	outcome
5552a227b7f4Shs24103 	 * on		no		pass through
5553a227b7f4Shs24103 	 * on		yes		pass through
5554a227b7f4Shs24103 	 * off		no		return 0
5555a227b7f4Shs24103 	 * off		yes		display error, return 1
5556a227b7f4Shs24103 	 * noauto	no		return 0
5557a227b7f4Shs24103 	 * noauto	yes		pass through
5558a227b7f4Shs24103 	 */
5559deb8317bSMark J Musante 	canmount = zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT);
5560a227b7f4Shs24103 	if (canmount == ZFS_CANMOUNT_OFF) {
5561f3861e1aSahl 		if (!explicit)
5562e9dbad6fSeschrock 			return (0);
5563e9dbad6fSeschrock 
5564f3861e1aSahl 		(void) fprintf(stderr, gettext("cannot %s '%s': "
5565f3861e1aSahl 		    "'canmount' property is set to 'off'\n"), cmdname,
5566f3861e1aSahl 		    zfs_get_name(zhp));
5567e9dbad6fSeschrock 		return (1);
5568a227b7f4Shs24103 	} else if (canmount == ZFS_CANMOUNT_NOAUTO && !explicit) {
5569a227b7f4Shs24103 		return (0);
5570e9dbad6fSeschrock 	}
5571e9dbad6fSeschrock 
5572fa9e4066Sahrens 	/*
5573f3861e1aSahl 	 * At this point, we have verified that the mountpoint and/or
5574f3861e1aSahl 	 * shareopts are appropriate for auto management. If the
5575f3861e1aSahl 	 * filesystem is already mounted or shared, return (failing
5576f3861e1aSahl 	 * for explicit requests); otherwise mount or share the
5577f3861e1aSahl 	 * filesystem.
5578fa9e4066Sahrens 	 */
5579f3861e1aSahl 	switch (op) {
5580fa9e4066Sahrens 	case OP_SHARE:
5581da6c28aaSamw 
5582da6c28aaSamw 		shared_nfs = zfs_is_shared_nfs(zhp, NULL);
5583da6c28aaSamw 		shared_smb = zfs_is_shared_smb(zhp, NULL);
5584da6c28aaSamw 
5585da6c28aaSamw 		if (shared_nfs && shared_smb ||
5586da6c28aaSamw 		    (shared_nfs && strcmp(shareopts, "on") == 0 &&
5587da6c28aaSamw 		    strcmp(smbshareopts, "off") == 0) ||
5588da6c28aaSamw 		    (shared_smb && strcmp(smbshareopts, "on") == 0 &&
5589da6c28aaSamw 		    strcmp(shareopts, "off") == 0)) {
5590f3861e1aSahl 			if (!explicit)
5591f3861e1aSahl 				return (0);
5592f3861e1aSahl 
5593fa9e4066Sahrens 			(void) fprintf(stderr, gettext("cannot share "
5594fa9e4066Sahrens 			    "'%s': filesystem already shared\n"),
5595fa9e4066Sahrens 			    zfs_get_name(zhp));
5596fa9e4066Sahrens 			return (1);
5597fa9e4066Sahrens 		}
5598fa9e4066Sahrens 
5599fa9e4066Sahrens 		if (!zfs_is_mounted(zhp, NULL) &&
5600fa9e4066Sahrens 		    zfs_mount(zhp, NULL, 0) != 0)
5601fa9e4066Sahrens 			return (1);
5602fa9e4066Sahrens 
5603da6c28aaSamw 		if (protocol == NULL) {
5604da6c28aaSamw 			if (zfs_shareall(zhp) != 0)
5605fa9e4066Sahrens 				return (1);
5606da6c28aaSamw 		} else if (strcmp(protocol, "nfs") == 0) {
5607da6c28aaSamw 			if (zfs_share_nfs(zhp))
5608da6c28aaSamw 				return (1);
5609da6c28aaSamw 		} else if (strcmp(protocol, "smb") == 0) {
5610da6c28aaSamw 			if (zfs_share_smb(zhp))
5611da6c28aaSamw 				return (1);
5612da6c28aaSamw 		} else {
5613da6c28aaSamw 			(void) fprintf(stderr, gettext("cannot share "
5614da6c28aaSamw 			    "'%s': invalid share type '%s' "
5615da6c28aaSamw 			    "specified\n"),
5616da6c28aaSamw 			    zfs_get_name(zhp), protocol);
5617da6c28aaSamw 			return (1);
5618da6c28aaSamw 		}
5619da6c28aaSamw 
5620fa9e4066Sahrens 		break;
5621fa9e4066Sahrens 
5622fa9e4066Sahrens 	case OP_MOUNT:
5623f3861e1aSahl 		if (options == NULL)
5624f3861e1aSahl 			mnt.mnt_mntopts = "";
5625f3861e1aSahl 		else
5626f3861e1aSahl 			mnt.mnt_mntopts = (char *)options;
5627f3861e1aSahl 
5628f3861e1aSahl 		if (!hasmntopt(&mnt, MNTOPT_REMOUNT) &&
5629f3861e1aSahl 		    zfs_is_mounted(zhp, NULL)) {
5630f3861e1aSahl 			if (!explicit)
5631f3861e1aSahl 				return (0);
5632f3861e1aSahl 
5633f3861e1aSahl 			(void) fprintf(stderr, gettext("cannot mount "
5634f3861e1aSahl 			    "'%s': filesystem already mounted\n"),
5635f3861e1aSahl 			    zfs_get_name(zhp));
5636f3861e1aSahl 			return (1);
5637f3861e1aSahl 		}
5638f3861e1aSahl 
5639f3861e1aSahl 		if (zfs_mount(zhp, options, flags) != 0)
5640fa9e4066Sahrens 			return (1);
5641fa9e4066Sahrens 		break;
5642fa9e4066Sahrens 	}
5643f3861e1aSahl 
5644fa9e4066Sahrens 	return (0);
5645fa9e4066Sahrens }
5646fa9e4066Sahrens 
5647dae68f5eSmmusante /*
5648dae68f5eSmmusante  * Reports progress in the form "(current/total)".  Not thread-safe.
5649dae68f5eSmmusante  */
5650dae68f5eSmmusante static void
5651dae68f5eSmmusante report_mount_progress(int current, int total)
5652dae68f5eSmmusante {
5653a8b6ddafSMark J Musante 	static time_t last_progress_time = 0;
5654dae68f5eSmmusante 	time_t now = time(NULL);
5655a8b6ddafSMark J Musante 	char info[32];
5656dae68f5eSmmusante 
5657dae68f5eSmmusante 	/* report 1..n instead of 0..n-1 */
5658dae68f5eSmmusante 	++current;
5659dae68f5eSmmusante 
5660dae68f5eSmmusante 	/* display header if we're here for the first time */
5661dae68f5eSmmusante 	if (current == 1) {
5662a8b6ddafSMark J Musante 		set_progress_header(gettext("Mounting ZFS filesystems"));
56633cb34c60Sahrens 	} else if (current != total && last_progress_time + MOUNT_TIME >= now) {
56643cb34c60Sahrens 		/* too soon to report again */
56653cb34c60Sahrens 		return;
56663cb34c60Sahrens 	}
5667dae68f5eSmmusante 
5668dae68f5eSmmusante 	last_progress_time = now;
5669dae68f5eSmmusante 
5670a8b6ddafSMark J Musante 	(void) sprintf(info, "(%d/%d)", current, total);
5671dae68f5eSmmusante 
5672a8b6ddafSMark J Musante 	if (current == total)
5673a8b6ddafSMark J Musante 		finish_progress(info);
5674a8b6ddafSMark J Musante 	else
5675a8b6ddafSMark J Musante 		update_progress(info);
5676dae68f5eSmmusante }
5677dae68f5eSmmusante 
5678c6ef114fSmmusante static void
5679c6ef114fSmmusante append_options(char *mntopts, char *newopts)
5680c6ef114fSmmusante {
5681c6ef114fSmmusante 	int len = strlen(mntopts);
5682c6ef114fSmmusante 
5683c6ef114fSmmusante 	/* original length plus new string to append plus 1 for the comma */
5684c6ef114fSmmusante 	if (len + 1 + strlen(newopts) >= MNT_LINE_MAX) {
5685c6ef114fSmmusante 		(void) fprintf(stderr, gettext("the opts argument for "
5686c6ef114fSmmusante 		    "'%c' option is too long (more than %d chars)\n"),
5687c6ef114fSmmusante 		    "-o", MNT_LINE_MAX);
5688c6ef114fSmmusante 		usage(B_FALSE);
5689c6ef114fSmmusante 	}
5690c6ef114fSmmusante 
5691c6ef114fSmmusante 	if (*mntopts)
5692c6ef114fSmmusante 		mntopts[len++] = ',';
5693c6ef114fSmmusante 
5694c6ef114fSmmusante 	(void) strcpy(&mntopts[len], newopts);
5695c6ef114fSmmusante }
5696c6ef114fSmmusante 
5697fa9e4066Sahrens static int
5698f3861e1aSahl share_mount(int op, int argc, char **argv)
5699fa9e4066Sahrens {
5700fa9e4066Sahrens 	int do_all = 0;
5701dae68f5eSmmusante 	boolean_t verbose = B_FALSE;
570216299908Slling 	int c, ret = 0;
5703c6ef114fSmmusante 	char *options = NULL;
57049d9a58e3SEric Taylor 	int flags = 0;
5705fa9e4066Sahrens 
5706fa9e4066Sahrens 	/* check options */
5707dae68f5eSmmusante 	while ((c = getopt(argc, argv, op == OP_MOUNT ? ":avo:O" : "a"))
5708fa9e4066Sahrens 	    != -1) {
5709fa9e4066Sahrens 		switch (c) {
5710fa9e4066Sahrens 		case 'a':
5711fa9e4066Sahrens 			do_all = 1;
5712fa9e4066Sahrens 			break;
5713dae68f5eSmmusante 		case 'v':
5714dae68f5eSmmusante 			verbose = B_TRUE;
5715dae68f5eSmmusante 			break;
5716fa9e4066Sahrens 		case 'o':
5717c6ef114fSmmusante 			if (*optarg == '\0') {
5718c6ef114fSmmusante 				(void) fprintf(stderr, gettext("empty mount "
5719c6ef114fSmmusante 				    "options (-o) specified\n"));
5720ce5e3b86Srm160521 				usage(B_FALSE);
5721c6ef114fSmmusante 			}
5722c6ef114fSmmusante 
5723c6ef114fSmmusante 			if (options == NULL)
5724c6ef114fSmmusante 				options = safe_malloc(MNT_LINE_MAX + 1);
5725c6ef114fSmmusante 
5726c6ef114fSmmusante 			/* option validation is done later */
5727c6ef114fSmmusante 			append_options(options, optarg);
5728ce5e3b86Srm160521 			break;
5729ce5e3b86Srm160521 
5730fa9e4066Sahrens 		case 'O':
5731f3861e1aSahl 			flags |= MS_OVERLAY;
5732fa9e4066Sahrens 			break;
5733fa9e4066Sahrens 		case ':':
5734fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing argument for "
5735fa9e4066Sahrens 			    "'%c' option\n"), optopt);
573699653d4eSeschrock 			usage(B_FALSE);
5737fa9e4066Sahrens 			break;
5738fa9e4066Sahrens 		case '?':
5739fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
5740fa9e4066Sahrens 			    optopt);
574199653d4eSeschrock 			usage(B_FALSE);
5742fa9e4066Sahrens 		}
5743fa9e4066Sahrens 	}
5744fa9e4066Sahrens 
5745fa9e4066Sahrens 	argc -= optind;
5746fa9e4066Sahrens 	argv += optind;
5747fa9e4066Sahrens 
5748fa9e4066Sahrens 	/* check number of arguments */
5749fa9e4066Sahrens 	if (do_all) {
5750f3861e1aSahl 		zfs_handle_t **dslist = NULL;
57517f7322feSeschrock 		size_t i, count = 0;
5752da6c28aaSamw 		char *protocol = NULL;
57537f7322feSeschrock 
57549d9a58e3SEric Taylor 		if (op == OP_SHARE && argc > 0) {
57559d9a58e3SEric Taylor 			if (strcmp(argv[0], "nfs") != 0 &&
57569d9a58e3SEric Taylor 			    strcmp(argv[0], "smb") != 0) {
5757f3861e1aSahl 				(void) fprintf(stderr, gettext("share type "
5758ab003da8SJim Dunham 				    "must be 'nfs' or 'smb'\n"));
5759f3861e1aSahl 				usage(B_FALSE);
5760f3861e1aSahl 			}
5761da6c28aaSamw 			protocol = argv[0];
5762f3861e1aSahl 			argc--;
5763f3861e1aSahl 			argv++;
5764f3861e1aSahl 		}
5765f3861e1aSahl 
5766fa9e4066Sahrens 		if (argc != 0) {
5767fa9e4066Sahrens 			(void) fprintf(stderr, gettext("too many arguments\n"));
576899653d4eSeschrock 			usage(B_FALSE);
5769fa9e4066Sahrens 		}
5770fa9e4066Sahrens 
5771a8b6ddafSMark J Musante 		start_progress_timer();
57729d9a58e3SEric Taylor 		get_all_datasets(&dslist, &count, verbose);
57737f7322feSeschrock 
57747f7322feSeschrock 		if (count == 0)
57757f7322feSeschrock 			return (0);
57767f7322feSeschrock 
57779d9a58e3SEric Taylor 		qsort(dslist, count, sizeof (void *), libzfs_dataset_cmp);
57787f7322feSeschrock 
57797f7322feSeschrock 		for (i = 0; i < count; i++) {
5780dae68f5eSmmusante 			if (verbose)
5781dae68f5eSmmusante 				report_mount_progress(i, count);
5782dae68f5eSmmusante 
5783da6c28aaSamw 			if (share_mount_one(dslist[i], op, flags, protocol,
5784da6c28aaSamw 			    B_FALSE, options) != 0)
578555b04f29Slling 				ret = 1;
5786f3861e1aSahl 			zfs_close(dslist[i]);
57877f7322feSeschrock 		}
57887f7322feSeschrock 
5789f3861e1aSahl 		free(dslist);
5790fa9e4066Sahrens 	} else if (argc == 0) {
5791fa9e4066Sahrens 		struct mnttab entry;
5792fa9e4066Sahrens 
5793ce5e3b86Srm160521 		if ((op == OP_SHARE) || (options != NULL)) {
5794fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing filesystem "
5795ce5e3b86Srm160521 			    "argument (specify -a for all)\n"));
579699653d4eSeschrock 			usage(B_FALSE);
5797fa9e4066Sahrens 		}
5798fa9e4066Sahrens 
5799fa9e4066Sahrens 		/*
5800fa9e4066Sahrens 		 * When mount is given no arguments, go through /etc/mnttab and
5801fa9e4066Sahrens 		 * display any active ZFS mounts.  We hide any snapshots, since
5802fa9e4066Sahrens 		 * they are controlled automatically.
5803fa9e4066Sahrens 		 */
5804fa9e4066Sahrens 		rewind(mnttab_file);
5805fa9e4066Sahrens 		while (getmntent(mnttab_file, &entry) == 0) {
5806fa9e4066Sahrens 			if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0 ||
5807fa9e4066Sahrens 			    strchr(entry.mnt_special, '@') != NULL)
5808fa9e4066Sahrens 				continue;
5809fa9e4066Sahrens 
5810fa9e4066Sahrens 			(void) printf("%-30s  %s\n", entry.mnt_special,
5811fa9e4066Sahrens 			    entry.mnt_mountp);
5812fa9e4066Sahrens 		}
5813fa9e4066Sahrens 
5814fa9e4066Sahrens 	} else {
5815fa9e4066Sahrens 		zfs_handle_t *zhp;
5816fa9e4066Sahrens 
5817fa9e4066Sahrens 		if (argc > 1) {
5818fa9e4066Sahrens 			(void) fprintf(stderr,
5819fa9e4066Sahrens 			    gettext("too many arguments\n"));
582099653d4eSeschrock 			usage(B_FALSE);
5821fa9e4066Sahrens 		}
5822fa9e4066Sahrens 
58239d9a58e3SEric Taylor 		if ((zhp = zfs_open(g_zfs, argv[0],
58249d9a58e3SEric Taylor 		    ZFS_TYPE_FILESYSTEM)) == NULL) {
5825fa9e4066Sahrens 			ret = 1;
5826f3861e1aSahl 		} else {
5827da6c28aaSamw 			ret = share_mount_one(zhp, op, flags, NULL, B_TRUE,
5828f3861e1aSahl 			    options);
5829fa9e4066Sahrens 			zfs_close(zhp);
5830fa9e4066Sahrens 		}
5831fa9e4066Sahrens 	}
5832fa9e4066Sahrens 
5833fa9e4066Sahrens 	return (ret);
5834fa9e4066Sahrens }
5835fa9e4066Sahrens 
5836fa9e4066Sahrens /*
5837ab003da8SJim Dunham  * zfs mount -a [nfs]
5838fa9e4066Sahrens  * zfs mount filesystem
5839fa9e4066Sahrens  *
5840fa9e4066Sahrens  * Mount all filesystems, or mount the given filesystem.
5841fa9e4066Sahrens  */
5842fa9e4066Sahrens static int
5843fa9e4066Sahrens zfs_do_mount(int argc, char **argv)
5844fa9e4066Sahrens {
5845f3861e1aSahl 	return (share_mount(OP_MOUNT, argc, argv));
5846fa9e4066Sahrens }
5847fa9e4066Sahrens 
5848fa9e4066Sahrens /*
5849ab003da8SJim Dunham  * zfs share -a [nfs | smb]
5850fa9e4066Sahrens  * zfs share filesystem
5851fa9e4066Sahrens  *
5852fa9e4066Sahrens  * Share all filesystems, or share the given filesystem.
5853fa9e4066Sahrens  */
5854fa9e4066Sahrens static int
5855fa9e4066Sahrens zfs_do_share(int argc, char **argv)
5856fa9e4066Sahrens {
5857f3861e1aSahl 	return (share_mount(OP_SHARE, argc, argv));
5858fa9e4066Sahrens }
5859fa9e4066Sahrens 
5860fa9e4066Sahrens typedef struct unshare_unmount_node {
5861fa9e4066Sahrens 	zfs_handle_t	*un_zhp;
5862fa9e4066Sahrens 	char		*un_mountp;
5863fa9e4066Sahrens 	uu_avl_node_t	un_avlnode;
5864fa9e4066Sahrens } unshare_unmount_node_t;
5865fa9e4066Sahrens 
5866fa9e4066Sahrens /* ARGSUSED */
5867fa9e4066Sahrens static int
5868fa9e4066Sahrens unshare_unmount_compare(const void *larg, const void *rarg, void *unused)
5869fa9e4066Sahrens {
5870fa9e4066Sahrens 	const unshare_unmount_node_t *l = larg;
5871fa9e4066Sahrens 	const unshare_unmount_node_t *r = rarg;
5872fa9e4066Sahrens 
5873fa9e4066Sahrens 	return (strcmp(l->un_mountp, r->un_mountp));
5874fa9e4066Sahrens }
5875fa9e4066Sahrens 
5876fa9e4066Sahrens /*
5877fa9e4066Sahrens  * Convenience routine used by zfs_do_umount() and manual_unmount().  Given an
5878fa9e4066Sahrens  * absolute path, find the entry /etc/mnttab, verify that its a ZFS filesystem,
5879fa9e4066Sahrens  * and unmount it appropriately.
5880fa9e4066Sahrens  */
5881fa9e4066Sahrens static int
5882f3861e1aSahl unshare_unmount_path(int op, char *path, int flags, boolean_t is_manual)
5883fa9e4066Sahrens {
5884fa9e4066Sahrens 	zfs_handle_t *zhp;
588505c998d6SRichard Lowe 	int ret = 0;
5886fa9e4066Sahrens 	struct stat64 statbuf;
5887fa9e4066Sahrens 	struct extmnttab entry;
5888f3861e1aSahl 	const char *cmdname = (op == OP_SHARE) ? "unshare" : "unmount";
5889c6ef114fSmmusante 	ino_t path_inode;
5890fa9e4066Sahrens 
5891fa9e4066Sahrens 	/*
5892fa9e4066Sahrens 	 * Search for the path in /etc/mnttab.  Rather than looking for the
5893fa9e4066Sahrens 	 * specific path, which can be fooled by non-standard paths (i.e. ".."
5894fa9e4066Sahrens 	 * or "//"), we stat() the path and search for the corresponding
5895fa9e4066Sahrens 	 * (major,minor) device pair.
5896fa9e4066Sahrens 	 */
5897fa9e4066Sahrens 	if (stat64(path, &statbuf) != 0) {
5898fa9e4066Sahrens 		(void) fprintf(stderr, gettext("cannot %s '%s': %s\n"),
5899fa9e4066Sahrens 		    cmdname, path, strerror(errno));
5900fa9e4066Sahrens 		return (1);
5901fa9e4066Sahrens 	}
5902c6ef114fSmmusante 	path_inode = statbuf.st_ino;
5903fa9e4066Sahrens 
5904fa9e4066Sahrens 	/*
5905fa9e4066Sahrens 	 * Search for the given (major,minor) pair in the mount table.
5906fa9e4066Sahrens 	 */
5907fa9e4066Sahrens 	rewind(mnttab_file);
5908fa9e4066Sahrens 	while ((ret = getextmntent(mnttab_file, &entry, 0)) == 0) {
5909fa9e4066Sahrens 		if (entry.mnt_major == major(statbuf.st_dev) &&
5910fa9e4066Sahrens 		    entry.mnt_minor == minor(statbuf.st_dev))
5911fa9e4066Sahrens 			break;
5912fa9e4066Sahrens 	}
5913fa9e4066Sahrens 	if (ret != 0) {
591411022c7cStimh 		if (op == OP_SHARE) {
5915fa9e4066Sahrens 			(void) fprintf(stderr, gettext("cannot %s '%s': not "
5916fa9e4066Sahrens 			    "currently mounted\n"), cmdname, path);
5917fa9e4066Sahrens 			return (1);
5918fa9e4066Sahrens 		}
591911022c7cStimh 		(void) fprintf(stderr, gettext("warning: %s not in mnttab\n"),
592011022c7cStimh 		    path);
592111022c7cStimh 		if ((ret = umount2(path, flags)) != 0)
592211022c7cStimh 			(void) fprintf(stderr, gettext("%s: %s\n"), path,
592311022c7cStimh 			    strerror(errno));
592411022c7cStimh 		return (ret != 0);
592511022c7cStimh 	}
5926fa9e4066Sahrens 
5927fa9e4066Sahrens 	if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0) {
5928fa9e4066Sahrens 		(void) fprintf(stderr, gettext("cannot %s '%s': not a ZFS "
5929fa9e4066Sahrens 		    "filesystem\n"), cmdname, path);
5930fa9e4066Sahrens 		return (1);
5931fa9e4066Sahrens 	}
5932fa9e4066Sahrens 
593399653d4eSeschrock 	if ((zhp = zfs_open(g_zfs, entry.mnt_special,
593499653d4eSeschrock 	    ZFS_TYPE_FILESYSTEM)) == NULL)
5935fa9e4066Sahrens 		return (1);
5936fa9e4066Sahrens 
5937c6ef114fSmmusante 	ret = 1;
5938d72c03d9SSachin Gaikwad 	if (stat64(entry.mnt_mountp, &statbuf) != 0) {
5939d72c03d9SSachin Gaikwad 		(void) fprintf(stderr, gettext("cannot %s '%s': %s\n"),
5940d72c03d9SSachin Gaikwad 		    cmdname, path, strerror(errno));
5941d72c03d9SSachin Gaikwad 		goto out;
5942d72c03d9SSachin Gaikwad 	} else if (statbuf.st_ino != path_inode) {
5943d72c03d9SSachin Gaikwad 		(void) fprintf(stderr, gettext("cannot "
5944d72c03d9SSachin Gaikwad 		    "%s '%s': not a mountpoint\n"), cmdname, path);
5945d72c03d9SSachin Gaikwad 		goto out;
5946d72c03d9SSachin Gaikwad 	}
5947d72c03d9SSachin Gaikwad 
5948c6ef114fSmmusante 	if (op == OP_SHARE) {
5949c6ef114fSmmusante 		char nfs_mnt_prop[ZFS_MAXPROPLEN];
5950c6ef114fSmmusante 		char smbshare_prop[ZFS_MAXPROPLEN];
5951c6ef114fSmmusante 
5952c6ef114fSmmusante 		verify(zfs_prop_get(zhp, ZFS_PROP_SHARENFS, nfs_mnt_prop,
5953da6c28aaSamw 		    sizeof (nfs_mnt_prop), NULL, NULL, 0, B_FALSE) == 0);
5954c6ef114fSmmusante 		verify(zfs_prop_get(zhp, ZFS_PROP_SHARESMB, smbshare_prop,
5955da6c28aaSamw 		    sizeof (smbshare_prop), NULL, NULL, 0, B_FALSE) == 0);
5956fa9e4066Sahrens 
5957da6c28aaSamw 		if (strcmp(nfs_mnt_prop, "off") == 0 &&
5958da6c28aaSamw 		    strcmp(smbshare_prop, "off") == 0) {
5959fa9e4066Sahrens 			(void) fprintf(stderr, gettext("cannot unshare "
5960fa9e4066Sahrens 			    "'%s': legacy share\n"), path);
5961fa9e4066Sahrens 			(void) fprintf(stderr, gettext("use "
5962fa9e4066Sahrens 			    "unshare(1M) to unshare this filesystem\n"));
5963da6c28aaSamw 		} else if (!zfs_is_shared(zhp)) {
5964fa9e4066Sahrens 			(void) fprintf(stderr, gettext("cannot unshare '%s': "
5965fa9e4066Sahrens 			    "not currently shared\n"), path);
5966fa9e4066Sahrens 		} else {
5967da6c28aaSamw 			ret = zfs_unshareall_bypath(zhp, path);
5968fa9e4066Sahrens 		}
5969fa9e4066Sahrens 	} else {
5970c6ef114fSmmusante 		char mtpt_prop[ZFS_MAXPROPLEN];
5971c6ef114fSmmusante 
5972c6ef114fSmmusante 		verify(zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mtpt_prop,
5973c6ef114fSmmusante 		    sizeof (mtpt_prop), NULL, NULL, 0, B_FALSE) == 0);
5974c6ef114fSmmusante 
5975d72c03d9SSachin Gaikwad 		if (is_manual) {
59766b90ca48Slling 			ret = zfs_unmount(zhp, NULL, flags);
5977c6ef114fSmmusante 		} else if (strcmp(mtpt_prop, "legacy") == 0) {
5978fa9e4066Sahrens 			(void) fprintf(stderr, gettext("cannot unmount "
5979fa9e4066Sahrens 			    "'%s': legacy mountpoint\n"),
5980fa9e4066Sahrens 			    zfs_get_name(zhp));
5981fa9e4066Sahrens 			(void) fprintf(stderr, gettext("use umount(1M) "
5982fa9e4066Sahrens 			    "to unmount this filesystem\n"));
5983fa9e4066Sahrens 		} else {
5984fa9e4066Sahrens 			ret = zfs_unmountall(zhp, flags);
5985fa9e4066Sahrens 		}
5986fa9e4066Sahrens 	}
5987fa9e4066Sahrens 
5988d72c03d9SSachin Gaikwad out:
5989fa9e4066Sahrens 	zfs_close(zhp);
5990fa9e4066Sahrens 
5991fa9e4066Sahrens 	return (ret != 0);
5992fa9e4066Sahrens }
5993fa9e4066Sahrens 
5994fa9e4066Sahrens /*
5995fa9e4066Sahrens  * Generic callback for unsharing or unmounting a filesystem.
5996fa9e4066Sahrens  */
5997fa9e4066Sahrens static int
5998f3861e1aSahl unshare_unmount(int op, int argc, char **argv)
5999fa9e4066Sahrens {
6000fa9e4066Sahrens 	int do_all = 0;
6001fa9e4066Sahrens 	int flags = 0;
6002fa9e4066Sahrens 	int ret = 0;
60039d9a58e3SEric Taylor 	int c;
6004fa9e4066Sahrens 	zfs_handle_t *zhp;
6005ab003da8SJim Dunham 	char nfs_mnt_prop[ZFS_MAXPROPLEN];
6006da6c28aaSamw 	char sharesmb[ZFS_MAXPROPLEN];
6007fa9e4066Sahrens 
6008fa9e4066Sahrens 	/* check options */
6009f3861e1aSahl 	while ((c = getopt(argc, argv, op == OP_SHARE ? "a" : "af")) != -1) {
6010fa9e4066Sahrens 		switch (c) {
6011fa9e4066Sahrens 		case 'a':
6012fa9e4066Sahrens 			do_all = 1;
6013fa9e4066Sahrens 			break;
6014fa9e4066Sahrens 		case 'f':
6015fa9e4066Sahrens 			flags = MS_FORCE;
6016fa9e4066Sahrens 			break;
6017fa9e4066Sahrens 		case '?':
6018fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
6019fa9e4066Sahrens 			    optopt);
602099653d4eSeschrock 			usage(B_FALSE);
6021fa9e4066Sahrens 		}
6022fa9e4066Sahrens 	}
6023fa9e4066Sahrens 
6024fa9e4066Sahrens 	argc -= optind;
6025fa9e4066Sahrens 	argv += optind;
6026fa9e4066Sahrens 
6027fa9e4066Sahrens 	if (do_all) {
6028fa9e4066Sahrens 		/*
6029fa9e4066Sahrens 		 * We could make use of zfs_for_each() to walk all datasets in
6030fa9e4066Sahrens 		 * the system, but this would be very inefficient, especially
6031fa9e4066Sahrens 		 * since we would have to linearly search /etc/mnttab for each
6032fa9e4066Sahrens 		 * one.  Instead, do one pass through /etc/mnttab looking for
6033fa9e4066Sahrens 		 * zfs entries and call zfs_unmount() for each one.
6034fa9e4066Sahrens 		 *
6035fa9e4066Sahrens 		 * Things get a little tricky if the administrator has created
6036fa9e4066Sahrens 		 * mountpoints beneath other ZFS filesystems.  In this case, we
6037fa9e4066Sahrens 		 * have to unmount the deepest filesystems first.  To accomplish
6038fa9e4066Sahrens 		 * this, we place all the mountpoints in an AVL tree sorted by
6039fa9e4066Sahrens 		 * the special type (dataset name), and walk the result in
6040fa9e4066Sahrens 		 * reverse to make sure to get any snapshots first.
6041fa9e4066Sahrens 		 */
6042fa9e4066Sahrens 		struct mnttab entry;
6043fa9e4066Sahrens 		uu_avl_pool_t *pool;
6044fa9e4066Sahrens 		uu_avl_t *tree;
6045fa9e4066Sahrens 		unshare_unmount_node_t *node;
6046fa9e4066Sahrens 		uu_avl_index_t idx;
6047fa9e4066Sahrens 		uu_avl_walk_t *walk;
6048fa9e4066Sahrens 
6049f3861e1aSahl 		if (argc != 0) {
6050f3861e1aSahl 			(void) fprintf(stderr, gettext("too many arguments\n"));
6051f3861e1aSahl 			usage(B_FALSE);
6052f3861e1aSahl 		}
6053f3861e1aSahl 
6054a8b6ddafSMark J Musante 		if (((pool = uu_avl_pool_create("unmount_pool",
6055fa9e4066Sahrens 		    sizeof (unshare_unmount_node_t),
6056fa9e4066Sahrens 		    offsetof(unshare_unmount_node_t, un_avlnode),
6057a8b6ddafSMark J Musante 		    unshare_unmount_compare, UU_DEFAULT)) == NULL) ||
6058a8b6ddafSMark J Musante 		    ((tree = uu_avl_create(pool, NULL, UU_DEFAULT)) == NULL))
6059a8b6ddafSMark J Musante 			nomem();
6060fa9e4066Sahrens 
6061fa9e4066Sahrens 		rewind(mnttab_file);
6062fa9e4066Sahrens 		while (getmntent(mnttab_file, &entry) == 0) {
6063fa9e4066Sahrens 
6064fa9e4066Sahrens 			/* ignore non-ZFS entries */
6065fa9e4066Sahrens 			if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0)
6066fa9e4066Sahrens 				continue;
6067fa9e4066Sahrens 
6068fa9e4066Sahrens 			/* ignore snapshots */
6069fa9e4066Sahrens 			if (strchr(entry.mnt_special, '@') != NULL)
6070fa9e4066Sahrens 				continue;
6071fa9e4066Sahrens 
607299653d4eSeschrock 			if ((zhp = zfs_open(g_zfs, entry.mnt_special,
6073fa9e4066Sahrens 			    ZFS_TYPE_FILESYSTEM)) == NULL) {
6074fa9e4066Sahrens 				ret = 1;
6075fa9e4066Sahrens 				continue;
6076fa9e4066Sahrens 			}
6077fa9e4066Sahrens 
6078da6c28aaSamw 			switch (op) {
6079da6c28aaSamw 			case OP_SHARE:
6080da6c28aaSamw 				verify(zfs_prop_get(zhp, ZFS_PROP_SHARENFS,
6081ab003da8SJim Dunham 				    nfs_mnt_prop,
6082ab003da8SJim Dunham 				    sizeof (nfs_mnt_prop),
6083da6c28aaSamw 				    NULL, NULL, 0, B_FALSE) == 0);
6084ab003da8SJim Dunham 				if (strcmp(nfs_mnt_prop, "off") != 0)
6085da6c28aaSamw 					break;
6086da6c28aaSamw 				verify(zfs_prop_get(zhp, ZFS_PROP_SHARESMB,
6087ab003da8SJim Dunham 				    nfs_mnt_prop,
6088ab003da8SJim Dunham 				    sizeof (nfs_mnt_prop),
6089da6c28aaSamw 				    NULL, NULL, 0, B_FALSE) == 0);
6090ab003da8SJim Dunham 				if (strcmp(nfs_mnt_prop, "off") == 0)
6091fa9e4066Sahrens 					continue;
6092da6c28aaSamw 				break;
6093da6c28aaSamw 			case OP_MOUNT:
6094da6c28aaSamw 				/* Ignore legacy mounts */
6095da6c28aaSamw 				verify(zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT,
6096ab003da8SJim Dunham 				    nfs_mnt_prop,
6097ab003da8SJim Dunham 				    sizeof (nfs_mnt_prop),
6098da6c28aaSamw 				    NULL, NULL, 0, B_FALSE) == 0);
6099ab003da8SJim Dunham 				if (strcmp(nfs_mnt_prop, "legacy") == 0)
6100da6c28aaSamw 					continue;
6101a227b7f4Shs24103 				/* Ignore canmount=noauto mounts */
6102a227b7f4Shs24103 				if (zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT) ==
6103a227b7f4Shs24103 				    ZFS_CANMOUNT_NOAUTO)
6104a227b7f4Shs24103 					continue;
6105da6c28aaSamw 			default:
6106da6c28aaSamw 				break;
6107fa9e4066Sahrens 			}
6108fa9e4066Sahrens 
6109fa9e4066Sahrens 			node = safe_malloc(sizeof (unshare_unmount_node_t));
6110fa9e4066Sahrens 			node->un_zhp = zhp;
6111a8b6ddafSMark J Musante 			node->un_mountp = safe_strdup(entry.mnt_mountp);
6112fa9e4066Sahrens 
6113fa9e4066Sahrens 			uu_avl_node_init(node, &node->un_avlnode, pool);
6114fa9e4066Sahrens 
6115fa9e4066Sahrens 			if (uu_avl_find(tree, node, NULL, &idx) == NULL) {
6116fa9e4066Sahrens 				uu_avl_insert(tree, node, idx);
6117fa9e4066Sahrens 			} else {
6118fa9e4066Sahrens 				zfs_close(node->un_zhp);
6119fa9e4066Sahrens 				free(node->un_mountp);
6120fa9e4066Sahrens 				free(node);
6121fa9e4066Sahrens 			}
6122fa9e4066Sahrens 		}
6123fa9e4066Sahrens 
6124fa9e4066Sahrens 		/*
6125fa9e4066Sahrens 		 * Walk the AVL tree in reverse, unmounting each filesystem and
6126fa9e4066Sahrens 		 * removing it from the AVL tree in the process.
6127fa9e4066Sahrens 		 */
6128fa9e4066Sahrens 		if ((walk = uu_avl_walk_start(tree,
6129a8b6ddafSMark J Musante 		    UU_WALK_REVERSE | UU_WALK_ROBUST)) == NULL)
6130a8b6ddafSMark J Musante 			nomem();
6131fa9e4066Sahrens 
6132fa9e4066Sahrens 		while ((node = uu_avl_walk_next(walk)) != NULL) {
6133fa9e4066Sahrens 			uu_avl_remove(tree, node);
6134fa9e4066Sahrens 
6135f3861e1aSahl 			switch (op) {
6136fa9e4066Sahrens 			case OP_SHARE:
6137da6c28aaSamw 				if (zfs_unshareall_bypath(node->un_zhp,
6138fa9e4066Sahrens 				    node->un_mountp) != 0)
6139fa9e4066Sahrens 					ret = 1;
6140fa9e4066Sahrens 				break;
6141fa9e4066Sahrens 
6142fa9e4066Sahrens 			case OP_MOUNT:
6143fa9e4066Sahrens 				if (zfs_unmount(node->un_zhp,
6144fa9e4066Sahrens 				    node->un_mountp, flags) != 0)
6145fa9e4066Sahrens 					ret = 1;
6146fa9e4066Sahrens 				break;
6147fa9e4066Sahrens 			}
6148fa9e4066Sahrens 
6149fa9e4066Sahrens 			zfs_close(node->un_zhp);
6150fa9e4066Sahrens 			free(node->un_mountp);
6151fa9e4066Sahrens 			free(node);
6152fa9e4066Sahrens 		}
6153fa9e4066Sahrens 
6154fa9e4066Sahrens 		uu_avl_walk_end(walk);
6155fa9e4066Sahrens 		uu_avl_destroy(tree);
6156fa9e4066Sahrens 		uu_avl_pool_destroy(pool);
6157f3861e1aSahl 
6158fa9e4066Sahrens 	} else {
6159f3861e1aSahl 		if (argc != 1) {
6160f3861e1aSahl 			if (argc == 0)
6161f3861e1aSahl 				(void) fprintf(stderr,
6162f3861e1aSahl 				    gettext("missing filesystem argument\n"));
6163f3861e1aSahl 			else
6164f3861e1aSahl 				(void) fprintf(stderr,
6165f3861e1aSahl 				    gettext("too many arguments\n"));
6166f3861e1aSahl 			usage(B_FALSE);
6167f3861e1aSahl 		}
6168f3861e1aSahl 
6169fa9e4066Sahrens 		/*
6170fa9e4066Sahrens 		 * We have an argument, but it may be a full path or a ZFS
6171fa9e4066Sahrens 		 * filesystem.  Pass full paths off to unmount_path() (shared by
6172fa9e4066Sahrens 		 * manual_unmount), otherwise open the filesystem and pass to
6173fa9e4066Sahrens 		 * zfs_unmount().
6174fa9e4066Sahrens 		 */
6175fa9e4066Sahrens 		if (argv[0][0] == '/')
6176f3861e1aSahl 			return (unshare_unmount_path(op, argv[0],
617799653d4eSeschrock 			    flags, B_FALSE));
6178fa9e4066Sahrens 
61799d9a58e3SEric Taylor 		if ((zhp = zfs_open(g_zfs, argv[0],
61809d9a58e3SEric Taylor 		    ZFS_TYPE_FILESYSTEM)) == NULL)
6181fa9e4066Sahrens 			return (1);
6182fa9e4066Sahrens 
6183f3861e1aSahl 		verify(zfs_prop_get(zhp, op == OP_SHARE ?
6184da6c28aaSamw 		    ZFS_PROP_SHARENFS : ZFS_PROP_MOUNTPOINT,
6185ab003da8SJim Dunham 		    nfs_mnt_prop, sizeof (nfs_mnt_prop), NULL,
6186da6c28aaSamw 		    NULL, 0, B_FALSE) == 0);
6187fa9e4066Sahrens 
6188f3861e1aSahl 		switch (op) {
6189fa9e4066Sahrens 		case OP_SHARE:
6190da6c28aaSamw 			verify(zfs_prop_get(zhp, ZFS_PROP_SHARENFS,
6191ab003da8SJim Dunham 			    nfs_mnt_prop,
6192ab003da8SJim Dunham 			    sizeof (nfs_mnt_prop),
6193da6c28aaSamw 			    NULL, NULL, 0, B_FALSE) == 0);
6194da6c28aaSamw 			verify(zfs_prop_get(zhp, ZFS_PROP_SHARESMB,
6195da6c28aaSamw 			    sharesmb, sizeof (sharesmb), NULL, NULL,
6196da6c28aaSamw 			    0, B_FALSE) == 0);
6197da6c28aaSamw 
6198ab003da8SJim Dunham 			if (strcmp(nfs_mnt_prop, "off") == 0 &&
6199da6c28aaSamw 			    strcmp(sharesmb, "off") == 0) {
6200f3861e1aSahl 				(void) fprintf(stderr, gettext("cannot "
6201f3861e1aSahl 				    "unshare '%s': legacy share\n"),
6202fa9e4066Sahrens 				    zfs_get_name(zhp));
6203f3861e1aSahl 				(void) fprintf(stderr, gettext("use "
6204f3861e1aSahl 				    "unshare(1M) to unshare this "
6205f3861e1aSahl 				    "filesystem\n"));
6206fa9e4066Sahrens 				ret = 1;
6207da6c28aaSamw 			} else if (!zfs_is_shared(zhp)) {
6208f3861e1aSahl 				(void) fprintf(stderr, gettext("cannot "
6209f3861e1aSahl 				    "unshare '%s': not currently "
6210f3861e1aSahl 				    "shared\n"), zfs_get_name(zhp));
6211f3861e1aSahl 				ret = 1;
6212da6c28aaSamw 			} else if (zfs_unshareall(zhp) != 0) {
6213fa9e4066Sahrens 				ret = 1;
6214fa9e4066Sahrens 			}
6215fa9e4066Sahrens 			break;
6216fa9e4066Sahrens 
6217fa9e4066Sahrens 		case OP_MOUNT:
6218ab003da8SJim Dunham 			if (strcmp(nfs_mnt_prop, "legacy") == 0) {
6219f3861e1aSahl 				(void) fprintf(stderr, gettext("cannot "
6220f3861e1aSahl 				    "unmount '%s': legacy "
6221f3861e1aSahl 				    "mountpoint\n"), zfs_get_name(zhp));
6222f3861e1aSahl 				(void) fprintf(stderr, gettext("use "
6223f3861e1aSahl 				    "umount(1M) to unmount this "
6224f3861e1aSahl 				    "filesystem\n"));
6225fa9e4066Sahrens 				ret = 1;
6226fa9e4066Sahrens 			} else if (!zfs_is_mounted(zhp, NULL)) {
6227f3861e1aSahl 				(void) fprintf(stderr, gettext("cannot "
6228f3861e1aSahl 				    "unmount '%s': not currently "
6229f3861e1aSahl 				    "mounted\n"),
6230fa9e4066Sahrens 				    zfs_get_name(zhp));
6231fa9e4066Sahrens 				ret = 1;
6232fa9e4066Sahrens 			} else if (zfs_unmountall(zhp, flags) != 0) {
6233fa9e4066Sahrens 				ret = 1;
6234fa9e4066Sahrens 			}
6235f3861e1aSahl 			break;
6236f3861e1aSahl 		}
6237fa9e4066Sahrens 
6238fa9e4066Sahrens 		zfs_close(zhp);
6239fa9e4066Sahrens 	}
6240fa9e4066Sahrens 
6241fa9e4066Sahrens 	return (ret);
6242fa9e4066Sahrens }
6243fa9e4066Sahrens 
6244fa9e4066Sahrens /*
6245fa9e4066Sahrens  * zfs unmount -a
6246fa9e4066Sahrens  * zfs unmount filesystem
6247fa9e4066Sahrens  *
6248fa9e4066Sahrens  * Unmount all filesystems, or a specific ZFS filesystem.
6249fa9e4066Sahrens  */
6250fa9e4066Sahrens static int
6251fa9e4066Sahrens zfs_do_unmount(int argc, char **argv)
6252fa9e4066Sahrens {
6253fa9e4066Sahrens 	return (unshare_unmount(OP_MOUNT, argc, argv));
6254fa9e4066Sahrens }
6255fa9e4066Sahrens 
6256fa9e4066Sahrens /*
6257fa9e4066Sahrens  * zfs unshare -a
6258fa9e4066Sahrens  * zfs unshare filesystem
6259fa9e4066Sahrens  *
6260fa9e4066Sahrens  * Unshare all filesystems, or a specific ZFS filesystem.
6261fa9e4066Sahrens  */
6262fa9e4066Sahrens static int
6263fa9e4066Sahrens zfs_do_unshare(int argc, char **argv)
6264fa9e4066Sahrens {
6265fa9e4066Sahrens 	return (unshare_unmount(OP_SHARE, argc, argv));
6266fa9e4066Sahrens }
6267fa9e4066Sahrens 
6268fa9e4066Sahrens /*
6269fa9e4066Sahrens  * Called when invoked as /etc/fs/zfs/mount.  Do the mount if the mountpoint is
6270fa9e4066Sahrens  * 'legacy'.  Otherwise, complain that use should be using 'zfs mount'.
6271fa9e4066Sahrens  */
6272fa9e4066Sahrens static int
6273fa9e4066Sahrens manual_mount(int argc, char **argv)
6274fa9e4066Sahrens {
6275fa9e4066Sahrens 	zfs_handle_t *zhp;
6276fa9e4066Sahrens 	char mountpoint[ZFS_MAXPROPLEN];
6277fa9e4066Sahrens 	char mntopts[MNT_LINE_MAX] = { '\0' };
627805c998d6SRichard Lowe 	int ret = 0;
6279fa9e4066Sahrens 	int c;
6280fa9e4066Sahrens 	int flags = 0;
6281fa9e4066Sahrens 	char *dataset, *path;
6282fa9e4066Sahrens 
6283fa9e4066Sahrens 	/* check options */
6284ea8dc4b6Seschrock 	while ((c = getopt(argc, argv, ":mo:O")) != -1) {
6285fa9e4066Sahrens 		switch (c) {
6286fa9e4066Sahrens 		case 'o':
6287fa9e4066Sahrens 			(void) strlcpy(mntopts, optarg, sizeof (mntopts));
6288fa9e4066Sahrens 			break;
6289fa9e4066Sahrens 		case 'O':
6290fa9e4066Sahrens 			flags |= MS_OVERLAY;
6291fa9e4066Sahrens 			break;
6292ea8dc4b6Seschrock 		case 'm':
6293ea8dc4b6Seschrock 			flags |= MS_NOMNTTAB;
6294ea8dc4b6Seschrock 			break;
6295fa9e4066Sahrens 		case ':':
6296fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing argument for "
6297fa9e4066Sahrens 			    "'%c' option\n"), optopt);
629899653d4eSeschrock 			usage(B_FALSE);
6299fa9e4066Sahrens 			break;
6300fa9e4066Sahrens 		case '?':
6301fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
6302fa9e4066Sahrens 			    optopt);
6303fa9e4066Sahrens 			(void) fprintf(stderr, gettext("usage: mount [-o opts] "
6304fa9e4066Sahrens 			    "<path>\n"));
6305fa9e4066Sahrens 			return (2);
6306fa9e4066Sahrens 		}
6307fa9e4066Sahrens 	}
6308fa9e4066Sahrens 
6309fa9e4066Sahrens 	argc -= optind;
6310fa9e4066Sahrens 	argv += optind;
6311fa9e4066Sahrens 
6312fa9e4066Sahrens 	/* check that we only have two arguments */
6313fa9e4066Sahrens 	if (argc != 2) {
6314fa9e4066Sahrens 		if (argc == 0)
6315fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing dataset "
6316fa9e4066Sahrens 			    "argument\n"));
6317fa9e4066Sahrens 		else if (argc == 1)
6318fa9e4066Sahrens 			(void) fprintf(stderr,
6319fa9e4066Sahrens 			    gettext("missing mountpoint argument\n"));
6320fa9e4066Sahrens 		else
6321fa9e4066Sahrens 			(void) fprintf(stderr, gettext("too many arguments\n"));
6322fa9e4066Sahrens 		(void) fprintf(stderr, "usage: mount <dataset> <mountpoint>\n");
6323fa9e4066Sahrens 		return (2);
6324fa9e4066Sahrens 	}
6325fa9e4066Sahrens 
6326fa9e4066Sahrens 	dataset = argv[0];
6327fa9e4066Sahrens 	path = argv[1];
6328fa9e4066Sahrens 
6329fa9e4066Sahrens 	/* try to open the dataset */
633099653d4eSeschrock 	if ((zhp = zfs_open(g_zfs, dataset, ZFS_TYPE_FILESYSTEM)) == NULL)
6331fa9e4066Sahrens 		return (1);
6332fa9e4066Sahrens 
6333fa9e4066Sahrens 	(void) zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint,
633499653d4eSeschrock 	    sizeof (mountpoint), NULL, NULL, 0, B_FALSE);
6335fa9e4066Sahrens 
6336fa9e4066Sahrens 	/* check for legacy mountpoint and complain appropriately */
6337fa9e4066Sahrens 	ret = 0;
6338fa9e4066Sahrens 	if (strcmp(mountpoint, ZFS_MOUNTPOINT_LEGACY) == 0) {
6339fa9e4066Sahrens 		if (mount(dataset, path, MS_OPTIONSTR | flags, MNTTYPE_ZFS,
6340fa9e4066Sahrens 		    NULL, 0, mntopts, sizeof (mntopts)) != 0) {
6341fa9e4066Sahrens 			(void) fprintf(stderr, gettext("mount failed: %s\n"),
6342fa9e4066Sahrens 			    strerror(errno));
6343fa9e4066Sahrens 			ret = 1;
6344fa9e4066Sahrens 		}
6345fa9e4066Sahrens 	} else {
6346fa9e4066Sahrens 		(void) fprintf(stderr, gettext("filesystem '%s' cannot be "
6347fa9e4066Sahrens 		    "mounted using 'mount -F zfs'\n"), dataset);
6348fa9e4066Sahrens 		(void) fprintf(stderr, gettext("Use 'zfs set mountpoint=%s' "
6349fa9e4066Sahrens 		    "instead.\n"), path);
6350fa9e4066Sahrens 		(void) fprintf(stderr, gettext("If you must use 'mount -F zfs' "
6351fa9e4066Sahrens 		    "or /etc/vfstab, use 'zfs set mountpoint=legacy'.\n"));
6352fa9e4066Sahrens 		(void) fprintf(stderr, gettext("See zfs(1M) for more "
6353fa9e4066Sahrens 		    "information.\n"));
6354fa9e4066Sahrens 		ret = 1;
6355fa9e4066Sahrens 	}
6356fa9e4066Sahrens 
6357fa9e4066Sahrens 	return (ret);
6358fa9e4066Sahrens }
6359fa9e4066Sahrens 
6360fa9e4066Sahrens /*
6361fa9e4066Sahrens  * Called when invoked as /etc/fs/zfs/umount.  Unlike a manual mount, we allow
6362fa9e4066Sahrens  * unmounts of non-legacy filesystems, as this is the dominant administrative
6363fa9e4066Sahrens  * interface.
6364fa9e4066Sahrens  */
6365fa9e4066Sahrens static int
6366fa9e4066Sahrens manual_unmount(int argc, char **argv)
6367fa9e4066Sahrens {
6368fa9e4066Sahrens 	int flags = 0;
6369fa9e4066Sahrens 	int c;
6370fa9e4066Sahrens 
6371fa9e4066Sahrens 	/* check options */
6372fa9e4066Sahrens 	while ((c = getopt(argc, argv, "f")) != -1) {
6373fa9e4066Sahrens 		switch (c) {
6374fa9e4066Sahrens 		case 'f':
6375fa9e4066Sahrens 			flags = MS_FORCE;
6376fa9e4066Sahrens 			break;
6377fa9e4066Sahrens 		case '?':
6378fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
6379fa9e4066Sahrens 			    optopt);
6380fa9e4066Sahrens 			(void) fprintf(stderr, gettext("usage: unmount [-f] "
6381fa9e4066Sahrens 			    "<path>\n"));
6382fa9e4066Sahrens 			return (2);
6383fa9e4066Sahrens 		}
6384fa9e4066Sahrens 	}
6385fa9e4066Sahrens 
6386fa9e4066Sahrens 	argc -= optind;
6387fa9e4066Sahrens 	argv += optind;
6388fa9e4066Sahrens 
6389fa9e4066Sahrens 	/* check arguments */
6390fa9e4066Sahrens 	if (argc != 1) {
6391fa9e4066Sahrens 		if (argc == 0)
6392fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing path "
6393fa9e4066Sahrens 			    "argument\n"));
6394fa9e4066Sahrens 		else
6395fa9e4066Sahrens 			(void) fprintf(stderr, gettext("too many arguments\n"));
6396fa9e4066Sahrens 		(void) fprintf(stderr, gettext("usage: unmount [-f] <path>\n"));
6397fa9e4066Sahrens 		return (2);
6398fa9e4066Sahrens 	}
6399fa9e4066Sahrens 
640099653d4eSeschrock 	return (unshare_unmount_path(OP_MOUNT, argv[0], flags, B_TRUE));
6401fa9e4066Sahrens }
6402fa9e4066Sahrens 
6403fa9e4066Sahrens static int
6404ecd6cf80Smarks find_command_idx(char *command, int *idx)
6405ecd6cf80Smarks {
6406ecd6cf80Smarks 	int i;
6407ecd6cf80Smarks 
6408ecd6cf80Smarks 	for (i = 0; i < NCOMMAND; i++) {
6409ecd6cf80Smarks 		if (command_table[i].name == NULL)
6410ecd6cf80Smarks 			continue;
6411ecd6cf80Smarks 
6412ecd6cf80Smarks 		if (strcmp(command, command_table[i].name) == 0) {
6413ecd6cf80Smarks 			*idx = i;
6414ecd6cf80Smarks 			return (0);
6415ecd6cf80Smarks 		}
6416ecd6cf80Smarks 	}
6417ecd6cf80Smarks 	return (1);
6418ecd6cf80Smarks }
6419ecd6cf80Smarks 
642099d5e173STim Haley static int
642199d5e173STim Haley zfs_do_diff(int argc, char **argv)
642299d5e173STim Haley {
642399d5e173STim Haley 	zfs_handle_t *zhp;
642499d5e173STim Haley 	int flags = 0;
642599d5e173STim Haley 	char *tosnap = NULL;
642699d5e173STim Haley 	char *fromsnap = NULL;
642799d5e173STim Haley 	char *atp, *copy;
642805c998d6SRichard Lowe 	int err = 0;
642999d5e173STim Haley 	int c;
643099d5e173STim Haley 
643199d5e173STim Haley 	while ((c = getopt(argc, argv, "FHt")) != -1) {
643299d5e173STim Haley 		switch (c) {
643399d5e173STim Haley 		case 'F':
643499d5e173STim Haley 			flags |= ZFS_DIFF_CLASSIFY;
643599d5e173STim Haley 			break;
643699d5e173STim Haley 		case 'H':
643799d5e173STim Haley 			flags |= ZFS_DIFF_PARSEABLE;
643899d5e173STim Haley 			break;
643999d5e173STim Haley 		case 't':
644099d5e173STim Haley 			flags |= ZFS_DIFF_TIMESTAMP;
644199d5e173STim Haley 			break;
644299d5e173STim Haley 		default:
644399d5e173STim Haley 			(void) fprintf(stderr,
644499d5e173STim Haley 			    gettext("invalid option '%c'\n"), optopt);
644599d5e173STim Haley 			usage(B_FALSE);
644699d5e173STim Haley 		}
644799d5e173STim Haley 	}
644899d5e173STim Haley 
644999d5e173STim Haley 	argc -= optind;
645099d5e173STim Haley 	argv += optind;
645199d5e173STim Haley 
645299d5e173STim Haley 	if (argc < 1) {
645399d5e173STim Haley 		(void) fprintf(stderr,
645499d5e173STim Haley 		gettext("must provide at least one snapshot name\n"));
645599d5e173STim Haley 		usage(B_FALSE);
645699d5e173STim Haley 	}
645799d5e173STim Haley 
645899d5e173STim Haley 	if (argc > 2) {
645999d5e173STim Haley 		(void) fprintf(stderr, gettext("too many arguments\n"));
646099d5e173STim Haley 		usage(B_FALSE);
646199d5e173STim Haley 	}
646299d5e173STim Haley 
646399d5e173STim Haley 	fromsnap = argv[0];
646499d5e173STim Haley 	tosnap = (argc == 2) ? argv[1] : NULL;
646599d5e173STim Haley 
646699d5e173STim Haley 	copy = NULL;
646799d5e173STim Haley 	if (*fromsnap != '@')
646899d5e173STim Haley 		copy = strdup(fromsnap);
646999d5e173STim Haley 	else if (tosnap)
647099d5e173STim Haley 		copy = strdup(tosnap);
647199d5e173STim Haley 	if (copy == NULL)
647299d5e173STim Haley 		usage(B_FALSE);
647399d5e173STim Haley 
647499d5e173STim Haley 	if (atp = strchr(copy, '@'))
647599d5e173STim Haley 		*atp = '\0';
647699d5e173STim Haley 
647799d5e173STim Haley 	if ((zhp = zfs_open(g_zfs, copy, ZFS_TYPE_FILESYSTEM)) == NULL)
647899d5e173STim Haley 		return (1);
647999d5e173STim Haley 
648099d5e173STim Haley 	free(copy);
648199d5e173STim Haley 
648299d5e173STim Haley 	/*
648399d5e173STim Haley 	 * Ignore SIGPIPE so that the library can give us
648499d5e173STim Haley 	 * information on any failure
648599d5e173STim Haley 	 */
648699d5e173STim Haley 	(void) sigignore(SIGPIPE);
648799d5e173STim Haley 
648899d5e173STim Haley 	err = zfs_show_diffs(zhp, STDOUT_FILENO, fromsnap, tosnap, flags);
648999d5e173STim Haley 
649099d5e173STim Haley 	zfs_close(zhp);
649199d5e173STim Haley 
649299d5e173STim Haley 	return (err != 0);
649399d5e173STim Haley }
649499d5e173STim Haley 
6495fa9e4066Sahrens int
6496fa9e4066Sahrens main(int argc, char **argv)
6497fa9e4066Sahrens {
649805c998d6SRichard Lowe 	int ret = 0;
6499fa9e4066Sahrens 	int i;
6500fa9e4066Sahrens 	char *progname;
6501fa9e4066Sahrens 	char *cmdname;
6502fa9e4066Sahrens 
6503fa9e4066Sahrens 	(void) setlocale(LC_ALL, "");
6504fa9e4066Sahrens 	(void) textdomain(TEXT_DOMAIN);
6505fa9e4066Sahrens 
6506fa9e4066Sahrens 	opterr = 0;
6507fa9e4066Sahrens 
650899653d4eSeschrock 	if ((g_zfs = libzfs_init()) == NULL) {
650999653d4eSeschrock 		(void) fprintf(stderr, gettext("internal error: failed to "
651099653d4eSeschrock 		    "initialize ZFS library\n"));
651199653d4eSeschrock 		return (1);
651299653d4eSeschrock 	}
651399653d4eSeschrock 
65144445fffbSMatthew Ahrens 	zfs_save_arguments(argc, argv, history_str, sizeof (history_str));
6515ecd6cf80Smarks 
651699653d4eSeschrock 	libzfs_print_on_error(g_zfs, B_TRUE);
651799653d4eSeschrock 
6518fa9e4066Sahrens 	if ((mnttab_file = fopen(MNTTAB, "r")) == NULL) {
6519fa9e4066Sahrens 		(void) fprintf(stderr, gettext("internal error: unable to "
6520fa9e4066Sahrens 		    "open %s\n"), MNTTAB);
6521fa9e4066Sahrens 		return (1);
6522fa9e4066Sahrens 	}
6523fa9e4066Sahrens 
6524fa9e4066Sahrens 	/*
6525fa9e4066Sahrens 	 * This command also doubles as the /etc/fs mount and unmount program.
6526fa9e4066Sahrens 	 * Determine if we should take this behavior based on argv[0].
6527fa9e4066Sahrens 	 */
6528fa9e4066Sahrens 	progname = basename(argv[0]);
6529fa9e4066Sahrens 	if (strcmp(progname, "mount") == 0) {
6530fa9e4066Sahrens 		ret = manual_mount(argc, argv);
6531fa9e4066Sahrens 	} else if (strcmp(progname, "umount") == 0) {
6532fa9e4066Sahrens 		ret = manual_unmount(argc, argv);
6533fa9e4066Sahrens 	} else {
6534fa9e4066Sahrens 		/*
6535fa9e4066Sahrens 		 * Make sure the user has specified some command.
6536fa9e4066Sahrens 		 */
6537fa9e4066Sahrens 		if (argc < 2) {
6538fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing command\n"));
653999653d4eSeschrock 			usage(B_FALSE);
6540fa9e4066Sahrens 		}
6541fa9e4066Sahrens 
6542fa9e4066Sahrens 		cmdname = argv[1];
6543fa9e4066Sahrens 
6544fa9e4066Sahrens 		/*
6545fa9e4066Sahrens 		 * The 'umount' command is an alias for 'unmount'
6546fa9e4066Sahrens 		 */
6547fa9e4066Sahrens 		if (strcmp(cmdname, "umount") == 0)
6548fa9e4066Sahrens 			cmdname = "unmount";
6549fa9e4066Sahrens 
6550fa9e4066Sahrens 		/*
6551f2a3c691Sahrens 		 * The 'recv' command is an alias for 'receive'
6552f2a3c691Sahrens 		 */
6553f2a3c691Sahrens 		if (strcmp(cmdname, "recv") == 0)
6554f2a3c691Sahrens 			cmdname = "receive";
6555f2a3c691Sahrens 
6556f2a3c691Sahrens 		/*
6557fa9e4066Sahrens 		 * Special case '-?'
6558fa9e4066Sahrens 		 */
6559fa9e4066Sahrens 		if (strcmp(cmdname, "-?") == 0)
656099653d4eSeschrock 			usage(B_TRUE);
6561fa9e4066Sahrens 
6562fa9e4066Sahrens 		/*
6563fa9e4066Sahrens 		 * Run the appropriate command.
6564fa9e4066Sahrens 		 */
6565b2634b9cSEric Taylor 		libzfs_mnttab_cache(g_zfs, B_TRUE);
6566ecd6cf80Smarks 		if (find_command_idx(cmdname, &i) == 0) {
6567fa9e4066Sahrens 			current_command = &command_table[i];
6568fa9e4066Sahrens 			ret = command_table[i].func(argc - 1, argv + 1);
656991ebeef5Sahrens 		} else if (strchr(cmdname, '=') != NULL) {
657091ebeef5Sahrens 			verify(find_command_idx("set", &i) == 0);
6571ecd6cf80Smarks 			current_command = &command_table[i];
6572ecd6cf80Smarks 			ret = command_table[i].func(argc, argv);
6573ecd6cf80Smarks 		} else {
6574fa9e4066Sahrens 			(void) fprintf(stderr, gettext("unrecognized "
6575fa9e4066Sahrens 			    "command '%s'\n"), cmdname);
657699653d4eSeschrock 			usage(B_FALSE);
6577fa9e4066Sahrens 		}
6578b2634b9cSEric Taylor 		libzfs_mnttab_cache(g_zfs, B_FALSE);
6579fa9e4066Sahrens 	}
6580fa9e4066Sahrens 
6581fa9e4066Sahrens 	(void) fclose(mnttab_file);
6582fa9e4066Sahrens 
65834445fffbSMatthew Ahrens 	if (ret == 0 && log_history)
65844445fffbSMatthew Ahrens 		(void) zpool_log_history(g_zfs, history_str);
65854445fffbSMatthew Ahrens 
658699653d4eSeschrock 	libzfs_fini(g_zfs);
658799653d4eSeschrock 
6588fa9e4066Sahrens 	/*
6589fa9e4066Sahrens 	 * The 'ZFS_ABORT' environment variable causes us to dump core on exit
6590fa9e4066Sahrens 	 * for the purposes of running ::findleaks.
6591fa9e4066Sahrens 	 */
6592fa9e4066Sahrens 	if (getenv("ZFS_ABORT") != NULL) {
6593fa9e4066Sahrens 		(void) printf("dumping core by request\n");
6594fa9e4066Sahrens 		abort();
6595fa9e4066Sahrens 	}
6596fa9e4066Sahrens 
6597fa9e4066Sahrens 	return (ret);
6598fa9e4066Sahrens }
6599