xref: /freebsd/sys/contrib/openzfs/cmd/zfs/zfs_main.c (revision ce4dcb97ca433b2a2f03fbae957dae0ff16f6f51)
1eda14cbcSMatt Macy /*
2eda14cbcSMatt Macy  * CDDL HEADER START
3eda14cbcSMatt Macy  *
4eda14cbcSMatt Macy  * The contents of this file are subject to the terms of the
5eda14cbcSMatt Macy  * Common Development and Distribution License (the "License").
6eda14cbcSMatt Macy  * You may not use this file except in compliance with the License.
7eda14cbcSMatt Macy  *
8eda14cbcSMatt Macy  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9271171e0SMartin Matuska  * or https://opensource.org/licenses/CDDL-1.0.
10eda14cbcSMatt Macy  * See the License for the specific language governing permissions
11eda14cbcSMatt Macy  * and limitations under the License.
12eda14cbcSMatt Macy  *
13eda14cbcSMatt Macy  * When distributing Covered Code, include this CDDL HEADER in each
14eda14cbcSMatt Macy  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15eda14cbcSMatt Macy  * If applicable, add the following below this CDDL HEADER, with the
16eda14cbcSMatt Macy  * fields enclosed by brackets "[]" replaced with your own identifying
17eda14cbcSMatt Macy  * information: Portions Copyright [yyyy] [name of copyright owner]
18eda14cbcSMatt Macy  *
19eda14cbcSMatt Macy  * CDDL HEADER END
20eda14cbcSMatt Macy  */
21eda14cbcSMatt Macy 
22eda14cbcSMatt Macy /*
23eda14cbcSMatt Macy  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
24eda14cbcSMatt Macy  * Copyright (c) 2011, 2020 by Delphix. All rights reserved.
25eda14cbcSMatt Macy  * Copyright 2012 Milan Jurik. All rights reserved.
26eda14cbcSMatt Macy  * Copyright (c) 2012, Joyent, Inc. All rights reserved.
27eda14cbcSMatt Macy  * Copyright (c) 2013 Steven Hartland.  All rights reserved.
28eda14cbcSMatt Macy  * Copyright 2016 Igor Kozhukhov <ikozhukhov@gmail.com>.
29eda14cbcSMatt Macy  * Copyright 2016 Nexenta Systems, Inc.
30eda14cbcSMatt Macy  * Copyright (c) 2019 Datto Inc.
31eda14cbcSMatt Macy  * Copyright (c) 2019, loli10K <ezomori.nozomu@gmail.com>
32eda14cbcSMatt Macy  * Copyright 2019 Joyent, Inc.
33eda14cbcSMatt Macy  * Copyright (c) 2019, 2020 by Christian Schwarz. All rights reserved.
34eda14cbcSMatt Macy  */
35eda14cbcSMatt Macy 
36eda14cbcSMatt Macy #include <assert.h>
37eda14cbcSMatt Macy #include <ctype.h>
38eda14cbcSMatt Macy #include <sys/debug.h>
39eda14cbcSMatt Macy #include <errno.h>
40eda14cbcSMatt Macy #include <getopt.h>
41eda14cbcSMatt Macy #include <libgen.h>
42eda14cbcSMatt Macy #include <libintl.h>
43eda14cbcSMatt Macy #include <libuutil.h>
44eda14cbcSMatt Macy #include <libnvpair.h>
45eda14cbcSMatt Macy #include <locale.h>
46eda14cbcSMatt Macy #include <stddef.h>
47eda14cbcSMatt Macy #include <stdio.h>
48eda14cbcSMatt Macy #include <stdlib.h>
49da5137abSMartin Matuska #include <string.h>
50eda14cbcSMatt Macy #include <unistd.h>
51eda14cbcSMatt Macy #include <fcntl.h>
52eda14cbcSMatt Macy #include <zone.h>
53eda14cbcSMatt Macy #include <grp.h>
54eda14cbcSMatt Macy #include <pwd.h>
5516038816SMartin Matuska #include <umem.h>
5616038816SMartin Matuska #include <pthread.h>
57eda14cbcSMatt Macy #include <signal.h>
58eda14cbcSMatt Macy #include <sys/list.h>
59eda14cbcSMatt Macy #include <sys/mkdev.h>
60eda14cbcSMatt Macy #include <sys/mntent.h>
61eda14cbcSMatt Macy #include <sys/mnttab.h>
62eda14cbcSMatt Macy #include <sys/mount.h>
63eda14cbcSMatt Macy #include <sys/stat.h>
64eda14cbcSMatt Macy #include <sys/fs/zfs.h>
65eda14cbcSMatt Macy #include <sys/systeminfo.h>
66eda14cbcSMatt Macy #include <sys/types.h>
67eda14cbcSMatt Macy #include <time.h>
68eda14cbcSMatt Macy #include <sys/zfs_project.h>
69eda14cbcSMatt Macy 
70eda14cbcSMatt Macy #include <libzfs.h>
71eda14cbcSMatt Macy #include <libzfs_core.h>
72eda14cbcSMatt Macy #include <zfs_prop.h>
73eda14cbcSMatt Macy #include <zfs_deleg.h>
74eda14cbcSMatt Macy #include <libzutil.h>
75eda14cbcSMatt Macy #ifdef HAVE_IDMAP
76eda14cbcSMatt Macy #include <aclutils.h>
77eda14cbcSMatt Macy #include <directory.h>
78eda14cbcSMatt Macy #endif /* HAVE_IDMAP */
79eda14cbcSMatt Macy 
80eda14cbcSMatt Macy #include "zfs_iter.h"
81eda14cbcSMatt Macy #include "zfs_util.h"
82eda14cbcSMatt Macy #include "zfs_comutil.h"
83eda14cbcSMatt Macy #include "zfs_projectutil.h"
84eda14cbcSMatt Macy 
85eda14cbcSMatt Macy libzfs_handle_t *g_zfs;
86eda14cbcSMatt Macy 
87eda14cbcSMatt Macy static char history_str[HIS_MAX_RECORD_LEN];
88eda14cbcSMatt Macy static boolean_t log_history = B_TRUE;
89eda14cbcSMatt Macy 
90eda14cbcSMatt Macy static int zfs_do_clone(int argc, char **argv);
91eda14cbcSMatt Macy static int zfs_do_create(int argc, char **argv);
92eda14cbcSMatt Macy static int zfs_do_destroy(int argc, char **argv);
93eda14cbcSMatt Macy static int zfs_do_get(int argc, char **argv);
94eda14cbcSMatt Macy static int zfs_do_inherit(int argc, char **argv);
95eda14cbcSMatt Macy static int zfs_do_list(int argc, char **argv);
96eda14cbcSMatt Macy static int zfs_do_mount(int argc, char **argv);
97eda14cbcSMatt Macy static int zfs_do_rename(int argc, char **argv);
98eda14cbcSMatt Macy static int zfs_do_rollback(int argc, char **argv);
99eda14cbcSMatt Macy static int zfs_do_set(int argc, char **argv);
100eda14cbcSMatt Macy static int zfs_do_upgrade(int argc, char **argv);
101eda14cbcSMatt Macy static int zfs_do_snapshot(int argc, char **argv);
102eda14cbcSMatt Macy static int zfs_do_unmount(int argc, char **argv);
103eda14cbcSMatt Macy static int zfs_do_share(int argc, char **argv);
104eda14cbcSMatt Macy static int zfs_do_unshare(int argc, char **argv);
105eda14cbcSMatt Macy static int zfs_do_send(int argc, char **argv);
106eda14cbcSMatt Macy static int zfs_do_receive(int argc, char **argv);
107eda14cbcSMatt Macy static int zfs_do_promote(int argc, char **argv);
108eda14cbcSMatt Macy static int zfs_do_userspace(int argc, char **argv);
109eda14cbcSMatt Macy static int zfs_do_allow(int argc, char **argv);
110eda14cbcSMatt Macy static int zfs_do_unallow(int argc, char **argv);
111eda14cbcSMatt Macy static int zfs_do_hold(int argc, char **argv);
112eda14cbcSMatt Macy static int zfs_do_holds(int argc, char **argv);
113eda14cbcSMatt Macy static int zfs_do_release(int argc, char **argv);
114eda14cbcSMatt Macy static int zfs_do_diff(int argc, char **argv);
115eda14cbcSMatt Macy static int zfs_do_bookmark(int argc, char **argv);
116eda14cbcSMatt Macy static int zfs_do_channel_program(int argc, char **argv);
117eda14cbcSMatt Macy static int zfs_do_load_key(int argc, char **argv);
118eda14cbcSMatt Macy static int zfs_do_unload_key(int argc, char **argv);
119eda14cbcSMatt Macy static int zfs_do_change_key(int argc, char **argv);
120eda14cbcSMatt Macy static int zfs_do_project(int argc, char **argv);
121eda14cbcSMatt Macy static int zfs_do_version(int argc, char **argv);
122eda14cbcSMatt Macy static int zfs_do_redact(int argc, char **argv);
123eda14cbcSMatt Macy static int zfs_do_wait(int argc, char **argv);
124eda14cbcSMatt Macy 
125eda14cbcSMatt Macy #ifdef __FreeBSD__
126eda14cbcSMatt Macy static int zfs_do_jail(int argc, char **argv);
127eda14cbcSMatt Macy static int zfs_do_unjail(int argc, char **argv);
128eda14cbcSMatt Macy #endif
129eda14cbcSMatt Macy 
1301f1e2261SMartin Matuska #ifdef __linux__
1311f1e2261SMartin Matuska static int zfs_do_zone(int argc, char **argv);
1321f1e2261SMartin Matuska static int zfs_do_unzone(int argc, char **argv);
1331f1e2261SMartin Matuska #endif
1341f1e2261SMartin Matuska 
135cbfe9975SMartin Matuska static int zfs_do_help(int argc, char **argv);
136cbfe9975SMartin Matuska 
137*ce4dcb97SMartin Matuska enum zfs_options {
138*ce4dcb97SMartin Matuska 	ZFS_OPTION_JSON_NUMS_AS_INT = 1024
139*ce4dcb97SMartin Matuska };
140*ce4dcb97SMartin Matuska 
141eda14cbcSMatt Macy /*
142eda14cbcSMatt Macy  * Enable a reasonable set of defaults for libumem debugging on DEBUG builds.
143eda14cbcSMatt Macy  */
144eda14cbcSMatt Macy 
145eda14cbcSMatt Macy #ifdef DEBUG
146eda14cbcSMatt Macy const char *
147eda14cbcSMatt Macy _umem_debug_init(void)
148eda14cbcSMatt Macy {
149eda14cbcSMatt Macy 	return ("default,verbose"); /* $UMEM_DEBUG setting */
150eda14cbcSMatt Macy }
151eda14cbcSMatt Macy 
152eda14cbcSMatt Macy const char *
153eda14cbcSMatt Macy _umem_logging_init(void)
154eda14cbcSMatt Macy {
155eda14cbcSMatt Macy 	return ("fail,contents"); /* $UMEM_LOGGING setting */
156eda14cbcSMatt Macy }
157eda14cbcSMatt Macy #endif
158eda14cbcSMatt Macy 
159eda14cbcSMatt Macy typedef enum {
160eda14cbcSMatt Macy 	HELP_CLONE,
161eda14cbcSMatt Macy 	HELP_CREATE,
162eda14cbcSMatt Macy 	HELP_DESTROY,
163eda14cbcSMatt Macy 	HELP_GET,
164eda14cbcSMatt Macy 	HELP_INHERIT,
165eda14cbcSMatt Macy 	HELP_UPGRADE,
166eda14cbcSMatt Macy 	HELP_LIST,
167eda14cbcSMatt Macy 	HELP_MOUNT,
168eda14cbcSMatt Macy 	HELP_PROMOTE,
169eda14cbcSMatt Macy 	HELP_RECEIVE,
170eda14cbcSMatt Macy 	HELP_RENAME,
171eda14cbcSMatt Macy 	HELP_ROLLBACK,
172eda14cbcSMatt Macy 	HELP_SEND,
173eda14cbcSMatt Macy 	HELP_SET,
174eda14cbcSMatt Macy 	HELP_SHARE,
175eda14cbcSMatt Macy 	HELP_SNAPSHOT,
176eda14cbcSMatt Macy 	HELP_UNMOUNT,
177eda14cbcSMatt Macy 	HELP_UNSHARE,
178eda14cbcSMatt Macy 	HELP_ALLOW,
179eda14cbcSMatt Macy 	HELP_UNALLOW,
180eda14cbcSMatt Macy 	HELP_USERSPACE,
181eda14cbcSMatt Macy 	HELP_GROUPSPACE,
182eda14cbcSMatt Macy 	HELP_PROJECTSPACE,
183eda14cbcSMatt Macy 	HELP_PROJECT,
184eda14cbcSMatt Macy 	HELP_HOLD,
185eda14cbcSMatt Macy 	HELP_HOLDS,
186eda14cbcSMatt Macy 	HELP_RELEASE,
187eda14cbcSMatt Macy 	HELP_DIFF,
188eda14cbcSMatt Macy 	HELP_BOOKMARK,
189eda14cbcSMatt Macy 	HELP_CHANNEL_PROGRAM,
190eda14cbcSMatt Macy 	HELP_LOAD_KEY,
191eda14cbcSMatt Macy 	HELP_UNLOAD_KEY,
192eda14cbcSMatt Macy 	HELP_CHANGE_KEY,
193eda14cbcSMatt Macy 	HELP_VERSION,
194eda14cbcSMatt Macy 	HELP_REDACT,
195eda14cbcSMatt Macy 	HELP_JAIL,
196eda14cbcSMatt Macy 	HELP_UNJAIL,
197eda14cbcSMatt Macy 	HELP_WAIT,
1981f1e2261SMartin Matuska 	HELP_ZONE,
1991f1e2261SMartin Matuska 	HELP_UNZONE,
200eda14cbcSMatt Macy } zfs_help_t;
201eda14cbcSMatt Macy 
202eda14cbcSMatt Macy typedef struct zfs_command {
203eda14cbcSMatt Macy 	const char	*name;
204eda14cbcSMatt Macy 	int		(*func)(int argc, char **argv);
205eda14cbcSMatt Macy 	zfs_help_t	usage;
206eda14cbcSMatt Macy } zfs_command_t;
207eda14cbcSMatt Macy 
208eda14cbcSMatt Macy /*
209eda14cbcSMatt Macy  * Master command table.  Each ZFS command has a name, associated function, and
210eda14cbcSMatt Macy  * usage message.  The usage messages need to be internationalized, so we have
211eda14cbcSMatt Macy  * to have a function to return the usage message based on a command index.
212eda14cbcSMatt Macy  *
213eda14cbcSMatt Macy  * These commands are organized according to how they are displayed in the usage
214eda14cbcSMatt Macy  * message.  An empty command (one with a NULL name) indicates an empty line in
215eda14cbcSMatt Macy  * the generic usage message.
216eda14cbcSMatt Macy  */
217eda14cbcSMatt Macy static zfs_command_t command_table[] = {
218eda14cbcSMatt Macy 	{ "version",	zfs_do_version, 	HELP_VERSION		},
219eda14cbcSMatt Macy 	{ NULL },
220eda14cbcSMatt Macy 	{ "create",	zfs_do_create,		HELP_CREATE		},
221eda14cbcSMatt Macy 	{ "destroy",	zfs_do_destroy,		HELP_DESTROY		},
222eda14cbcSMatt Macy 	{ NULL },
223eda14cbcSMatt Macy 	{ "snapshot",	zfs_do_snapshot,	HELP_SNAPSHOT		},
224eda14cbcSMatt Macy 	{ "rollback",	zfs_do_rollback,	HELP_ROLLBACK		},
225eda14cbcSMatt Macy 	{ "clone",	zfs_do_clone,		HELP_CLONE		},
226eda14cbcSMatt Macy 	{ "promote",	zfs_do_promote,		HELP_PROMOTE		},
227eda14cbcSMatt Macy 	{ "rename",	zfs_do_rename,		HELP_RENAME		},
228eda14cbcSMatt Macy 	{ "bookmark",	zfs_do_bookmark,	HELP_BOOKMARK		},
229eda14cbcSMatt Macy 	{ "program",    zfs_do_channel_program, HELP_CHANNEL_PROGRAM    },
230eda14cbcSMatt Macy 	{ NULL },
231eda14cbcSMatt Macy 	{ "list",	zfs_do_list,		HELP_LIST		},
232eda14cbcSMatt Macy 	{ NULL },
233eda14cbcSMatt Macy 	{ "set",	zfs_do_set,		HELP_SET		},
234eda14cbcSMatt Macy 	{ "get",	zfs_do_get,		HELP_GET		},
235eda14cbcSMatt Macy 	{ "inherit",	zfs_do_inherit,		HELP_INHERIT		},
236eda14cbcSMatt Macy 	{ "upgrade",	zfs_do_upgrade,		HELP_UPGRADE		},
237eda14cbcSMatt Macy 	{ NULL },
238eda14cbcSMatt Macy 	{ "userspace",	zfs_do_userspace,	HELP_USERSPACE		},
239eda14cbcSMatt Macy 	{ "groupspace",	zfs_do_userspace,	HELP_GROUPSPACE		},
240eda14cbcSMatt Macy 	{ "projectspace", zfs_do_userspace,	HELP_PROJECTSPACE	},
241eda14cbcSMatt Macy 	{ NULL },
242eda14cbcSMatt Macy 	{ "project",	zfs_do_project,		HELP_PROJECT		},
243eda14cbcSMatt Macy 	{ NULL },
244eda14cbcSMatt Macy 	{ "mount",	zfs_do_mount,		HELP_MOUNT		},
245eda14cbcSMatt Macy 	{ "unmount",	zfs_do_unmount,		HELP_UNMOUNT		},
246eda14cbcSMatt Macy 	{ "share",	zfs_do_share,		HELP_SHARE		},
247eda14cbcSMatt Macy 	{ "unshare",	zfs_do_unshare,		HELP_UNSHARE		},
248eda14cbcSMatt Macy 	{ NULL },
249eda14cbcSMatt Macy 	{ "send",	zfs_do_send,		HELP_SEND		},
250eda14cbcSMatt Macy 	{ "receive",	zfs_do_receive,		HELP_RECEIVE		},
251eda14cbcSMatt Macy 	{ NULL },
252eda14cbcSMatt Macy 	{ "allow",	zfs_do_allow,		HELP_ALLOW		},
253eda14cbcSMatt Macy 	{ NULL },
254eda14cbcSMatt Macy 	{ "unallow",	zfs_do_unallow,		HELP_UNALLOW		},
255eda14cbcSMatt Macy 	{ NULL },
256eda14cbcSMatt Macy 	{ "hold",	zfs_do_hold,		HELP_HOLD		},
257eda14cbcSMatt Macy 	{ "holds",	zfs_do_holds,		HELP_HOLDS		},
258eda14cbcSMatt Macy 	{ "release",	zfs_do_release,		HELP_RELEASE		},
259eda14cbcSMatt Macy 	{ "diff",	zfs_do_diff,		HELP_DIFF		},
260eda14cbcSMatt Macy 	{ "load-key",	zfs_do_load_key,	HELP_LOAD_KEY		},
261eda14cbcSMatt Macy 	{ "unload-key",	zfs_do_unload_key,	HELP_UNLOAD_KEY		},
262eda14cbcSMatt Macy 	{ "change-key",	zfs_do_change_key,	HELP_CHANGE_KEY		},
263eda14cbcSMatt Macy 	{ "redact",	zfs_do_redact,		HELP_REDACT		},
264eda14cbcSMatt Macy 	{ "wait",	zfs_do_wait,		HELP_WAIT		},
265eda14cbcSMatt Macy 
266eda14cbcSMatt Macy #ifdef __FreeBSD__
267eda14cbcSMatt Macy 	{ "jail",	zfs_do_jail,		HELP_JAIL		},
268eda14cbcSMatt Macy 	{ "unjail",	zfs_do_unjail,		HELP_UNJAIL		},
269eda14cbcSMatt Macy #endif
2701f1e2261SMartin Matuska 
2711f1e2261SMartin Matuska #ifdef __linux__
2721f1e2261SMartin Matuska 	{ "zone",	zfs_do_zone,		HELP_ZONE		},
2731f1e2261SMartin Matuska 	{ "unzone",	zfs_do_unzone,		HELP_UNZONE		},
2741f1e2261SMartin Matuska #endif
275eda14cbcSMatt Macy };
276eda14cbcSMatt Macy 
277eda14cbcSMatt Macy #define	NCOMMAND	(sizeof (command_table) / sizeof (command_table[0]))
278eda14cbcSMatt Macy 
279*ce4dcb97SMartin Matuska #define	MAX_CMD_LEN	256
280*ce4dcb97SMartin Matuska 
281eda14cbcSMatt Macy zfs_command_t *current_command;
282eda14cbcSMatt Macy 
283eda14cbcSMatt Macy static const char *
284eda14cbcSMatt Macy get_usage(zfs_help_t idx)
285eda14cbcSMatt Macy {
286eda14cbcSMatt Macy 	switch (idx) {
287eda14cbcSMatt Macy 	case HELP_CLONE:
288eda14cbcSMatt Macy 		return (gettext("\tclone [-p] [-o property=value] ... "
289eda14cbcSMatt Macy 		    "<snapshot> <filesystem|volume>\n"));
290eda14cbcSMatt Macy 	case HELP_CREATE:
2917877fdebSMatt Macy 		return (gettext("\tcreate [-Pnpuv] [-o property=value] ... "
292eda14cbcSMatt Macy 		    "<filesystem>\n"
293eda14cbcSMatt Macy 		    "\tcreate [-Pnpsv] [-b blocksize] [-o property=value] ... "
294eda14cbcSMatt Macy 		    "-V <size> <volume>\n"));
295eda14cbcSMatt Macy 	case HELP_DESTROY:
296eda14cbcSMatt Macy 		return (gettext("\tdestroy [-fnpRrv] <filesystem|volume>\n"
297eda14cbcSMatt Macy 		    "\tdestroy [-dnpRrv] "
298eda14cbcSMatt Macy 		    "<filesystem|volume>@<snap>[%<snap>][,...]\n"
299eda14cbcSMatt Macy 		    "\tdestroy <filesystem|volume>#<bookmark>\n"));
300eda14cbcSMatt Macy 	case HELP_GET:
301*ce4dcb97SMartin Matuska 		return (gettext("\tget [-rHp] [-j [--json-int]] [-d max] "
302eda14cbcSMatt Macy 		    "[-o \"all\" | field[,...]]\n"
303eda14cbcSMatt Macy 		    "\t    [-t type[,...]] [-s source[,...]]\n"
304eda14cbcSMatt Macy 		    "\t    <\"all\" | property[,...]> "
305eda14cbcSMatt Macy 		    "[filesystem|volume|snapshot|bookmark] ...\n"));
306eda14cbcSMatt Macy 	case HELP_INHERIT:
307eda14cbcSMatt Macy 		return (gettext("\tinherit [-rS] <property> "
308eda14cbcSMatt Macy 		    "<filesystem|volume|snapshot> ...\n"));
309eda14cbcSMatt Macy 	case HELP_UPGRADE:
310eda14cbcSMatt Macy 		return (gettext("\tupgrade [-v]\n"
311eda14cbcSMatt Macy 		    "\tupgrade [-r] [-V version] <-a | filesystem ...>\n"));
312eda14cbcSMatt Macy 	case HELP_LIST:
313*ce4dcb97SMartin Matuska 		return (gettext("\tlist [-Hp] [-j [--json-int]] [-r|-d max] "
314*ce4dcb97SMartin Matuska 		    "[-o property[,...]] [-s property]...\n\t    "
315*ce4dcb97SMartin Matuska 		    "[-S property]... [-t type[,...]] "
316eda14cbcSMatt Macy 		    "[filesystem|volume|snapshot] ...\n"));
317eda14cbcSMatt Macy 	case HELP_MOUNT:
318*ce4dcb97SMartin Matuska 		return (gettext("\tmount [-j]\n"
3191719886fSMartin Matuska 		    "\tmount [-flvO] [-o opts] <-a|-R filesystem|"
3201719886fSMartin Matuska 		    "filesystem>\n"));
321eda14cbcSMatt Macy 	case HELP_PROMOTE:
322eda14cbcSMatt Macy 		return (gettext("\tpromote <clone-filesystem>\n"));
323eda14cbcSMatt Macy 	case HELP_RECEIVE:
324eda14cbcSMatt Macy 		return (gettext("\treceive [-vMnsFhu] "
325eda14cbcSMatt Macy 		    "[-o <property>=<value>] ... [-x <property>] ...\n"
326eda14cbcSMatt Macy 		    "\t    <filesystem|volume|snapshot>\n"
327eda14cbcSMatt Macy 		    "\treceive [-vMnsFhu] [-o <property>=<value>] ... "
328eda14cbcSMatt Macy 		    "[-x <property>] ... \n"
329eda14cbcSMatt Macy 		    "\t    [-d | -e] <filesystem>\n"
330eda14cbcSMatt Macy 		    "\treceive -A <filesystem|volume>\n"));
331eda14cbcSMatt Macy 	case HELP_RENAME:
332eda14cbcSMatt Macy 		return (gettext("\trename [-f] <filesystem|volume|snapshot> "
333eda14cbcSMatt Macy 		    "<filesystem|volume|snapshot>\n"
334eac7052fSMatt Macy 		    "\trename -p [-f] <filesystem|volume> <filesystem|volume>\n"
335eac7052fSMatt Macy 		    "\trename -u [-f] <filesystem> <filesystem>\n"
336eda14cbcSMatt Macy 		    "\trename -r <snapshot> <snapshot>\n"));
337eda14cbcSMatt Macy 	case HELP_ROLLBACK:
338eda14cbcSMatt Macy 		return (gettext("\trollback [-rRf] <snapshot>\n"));
339eda14cbcSMatt Macy 	case HELP_SEND:
34015f0b8c3SMartin Matuska 		return (gettext("\tsend [-DLPbcehnpsVvw] "
341716fd348SMartin Matuska 		    "[-i|-I snapshot]\n"
342716fd348SMartin Matuska 		    "\t     [-R [-X dataset[,dataset]...]]     <snapshot>\n"
34315f0b8c3SMartin Matuska 		    "\tsend [-DnVvPLecw] [-i snapshot|bookmark] "
344eda14cbcSMatt Macy 		    "<filesystem|volume|snapshot>\n"
34515f0b8c3SMartin Matuska 		    "\tsend [-DnPpVvLec] [-i bookmark|snapshot] "
346eda14cbcSMatt Macy 		    "--redact <bookmark> <snapshot>\n"
34715f0b8c3SMartin Matuska 		    "\tsend [-nVvPe] -t <receive_resume_token>\n"
34815f0b8c3SMartin Matuska 		    "\tsend [-PnVv] --saved filesystem\n"));
349eda14cbcSMatt Macy 	case HELP_SET:
350f7f4bd06SMartin Matuska 		return (gettext("\tset [-u] <property=value> ... "
351eda14cbcSMatt Macy 		    "<filesystem|volume|snapshot> ...\n"));
352eda14cbcSMatt Macy 	case HELP_SHARE:
353eda14cbcSMatt Macy 		return (gettext("\tshare [-l] <-a [nfs|smb] | filesystem>\n"));
354eda14cbcSMatt Macy 	case HELP_SNAPSHOT:
355eda14cbcSMatt Macy 		return (gettext("\tsnapshot [-r] [-o property=value] ... "
356eda14cbcSMatt Macy 		    "<filesystem|volume>@<snap> ...\n"));
357eda14cbcSMatt Macy 	case HELP_UNMOUNT:
358eda14cbcSMatt Macy 		return (gettext("\tunmount [-fu] "
359eda14cbcSMatt Macy 		    "<-a | filesystem|mountpoint>\n"));
360eda14cbcSMatt Macy 	case HELP_UNSHARE:
361eda14cbcSMatt Macy 		return (gettext("\tunshare "
362eda14cbcSMatt Macy 		    "<-a [nfs|smb] | filesystem|mountpoint>\n"));
363eda14cbcSMatt Macy 	case HELP_ALLOW:
364eda14cbcSMatt Macy 		return (gettext("\tallow <filesystem|volume>\n"
365eda14cbcSMatt Macy 		    "\tallow [-ldug] "
366eda14cbcSMatt Macy 		    "<\"everyone\"|user|group>[,...] <perm|@setname>[,...]\n"
367eda14cbcSMatt Macy 		    "\t    <filesystem|volume>\n"
368eda14cbcSMatt Macy 		    "\tallow [-ld] -e <perm|@setname>[,...] "
369eda14cbcSMatt Macy 		    "<filesystem|volume>\n"
370eda14cbcSMatt Macy 		    "\tallow -c <perm|@setname>[,...] <filesystem|volume>\n"
371eda14cbcSMatt Macy 		    "\tallow -s @setname <perm|@setname>[,...] "
372eda14cbcSMatt Macy 		    "<filesystem|volume>\n"));
373eda14cbcSMatt Macy 	case HELP_UNALLOW:
374eda14cbcSMatt Macy 		return (gettext("\tunallow [-rldug] "
375eda14cbcSMatt Macy 		    "<\"everyone\"|user|group>[,...]\n"
376eda14cbcSMatt Macy 		    "\t    [<perm|@setname>[,...]] <filesystem|volume>\n"
377eda14cbcSMatt Macy 		    "\tunallow [-rld] -e [<perm|@setname>[,...]] "
378eda14cbcSMatt Macy 		    "<filesystem|volume>\n"
379eda14cbcSMatt Macy 		    "\tunallow [-r] -c [<perm|@setname>[,...]] "
380eda14cbcSMatt Macy 		    "<filesystem|volume>\n"
381eda14cbcSMatt Macy 		    "\tunallow [-r] -s @setname [<perm|@setname>[,...]] "
382eda14cbcSMatt Macy 		    "<filesystem|volume>\n"));
383eda14cbcSMatt Macy 	case HELP_USERSPACE:
384eda14cbcSMatt Macy 		return (gettext("\tuserspace [-Hinp] [-o field[,...]] "
385eda14cbcSMatt Macy 		    "[-s field] ...\n"
386eda14cbcSMatt Macy 		    "\t    [-S field] ... [-t type[,...]] "
387c40487d4SMatt Macy 		    "<filesystem|snapshot|path>\n"));
388eda14cbcSMatt Macy 	case HELP_GROUPSPACE:
389eda14cbcSMatt Macy 		return (gettext("\tgroupspace [-Hinp] [-o field[,...]] "
390eda14cbcSMatt Macy 		    "[-s field] ...\n"
391eda14cbcSMatt Macy 		    "\t    [-S field] ... [-t type[,...]] "
392c40487d4SMatt Macy 		    "<filesystem|snapshot|path>\n"));
393eda14cbcSMatt Macy 	case HELP_PROJECTSPACE:
394eda14cbcSMatt Macy 		return (gettext("\tprojectspace [-Hp] [-o field[,...]] "
395eda14cbcSMatt Macy 		    "[-s field] ... \n"
396c40487d4SMatt Macy 		    "\t    [-S field] ... <filesystem|snapshot|path>\n"));
397eda14cbcSMatt Macy 	case HELP_PROJECT:
398eda14cbcSMatt Macy 		return (gettext("\tproject [-d|-r] <directory|file ...>\n"
399eda14cbcSMatt Macy 		    "\tproject -c [-0] [-d|-r] [-p id] <directory|file ...>\n"
400eda14cbcSMatt Macy 		    "\tproject -C [-k] [-r] <directory ...>\n"
401eda14cbcSMatt Macy 		    "\tproject [-p id] [-r] [-s] <directory ...>\n"));
402eda14cbcSMatt Macy 	case HELP_HOLD:
403eda14cbcSMatt Macy 		return (gettext("\thold [-r] <tag> <snapshot> ...\n"));
404eda14cbcSMatt Macy 	case HELP_HOLDS:
405dbd5678dSMartin Matuska 		return (gettext("\tholds [-rHp] <snapshot> ...\n"));
406eda14cbcSMatt Macy 	case HELP_RELEASE:
407eda14cbcSMatt Macy 		return (gettext("\trelease [-r] <tag> <snapshot> ...\n"));
408eda14cbcSMatt Macy 	case HELP_DIFF:
409bb2d13b6SMartin Matuska 		return (gettext("\tdiff [-FHth] <snapshot> "
410eda14cbcSMatt Macy 		    "[snapshot|filesystem]\n"));
411eda14cbcSMatt Macy 	case HELP_BOOKMARK:
412eda14cbcSMatt Macy 		return (gettext("\tbookmark <snapshot|bookmark> "
413eda14cbcSMatt Macy 		    "<newbookmark>\n"));
414eda14cbcSMatt Macy 	case HELP_CHANNEL_PROGRAM:
415eda14cbcSMatt Macy 		return (gettext("\tprogram [-jn] [-t <instruction limit>] "
416eda14cbcSMatt Macy 		    "[-m <memory limit (b)>]\n"
417eda14cbcSMatt Macy 		    "\t    <pool> <program file> [lua args...]\n"));
418eda14cbcSMatt Macy 	case HELP_LOAD_KEY:
419eda14cbcSMatt Macy 		return (gettext("\tload-key [-rn] [-L <keylocation>] "
420eda14cbcSMatt Macy 		    "<-a | filesystem|volume>\n"));
421eda14cbcSMatt Macy 	case HELP_UNLOAD_KEY:
422eda14cbcSMatt Macy 		return (gettext("\tunload-key [-r] "
423eda14cbcSMatt Macy 		    "<-a | filesystem|volume>\n"));
424eda14cbcSMatt Macy 	case HELP_CHANGE_KEY:
425eda14cbcSMatt Macy 		return (gettext("\tchange-key [-l] [-o keyformat=<value>]\n"
426eac7052fSMatt Macy 		    "\t    [-o keylocation=<value>] [-o pbkdf2iters=<value>]\n"
427eda14cbcSMatt Macy 		    "\t    <filesystem|volume>\n"
428eda14cbcSMatt Macy 		    "\tchange-key -i [-l] <filesystem|volume>\n"));
429eda14cbcSMatt Macy 	case HELP_VERSION:
430*ce4dcb97SMartin Matuska 		return (gettext("\tversion [-j]\n"));
431eda14cbcSMatt Macy 	case HELP_REDACT:
432eda14cbcSMatt Macy 		return (gettext("\tredact <snapshot> <bookmark> "
433eda14cbcSMatt Macy 		    "<redaction_snapshot> ...\n"));
434eda14cbcSMatt Macy 	case HELP_JAIL:
435eda14cbcSMatt Macy 		return (gettext("\tjail <jailid|jailname> <filesystem>\n"));
436eda14cbcSMatt Macy 	case HELP_UNJAIL:
437eda14cbcSMatt Macy 		return (gettext("\tunjail <jailid|jailname> <filesystem>\n"));
438eda14cbcSMatt Macy 	case HELP_WAIT:
439eda14cbcSMatt Macy 		return (gettext("\twait [-t <activity>] <filesystem>\n"));
4401f1e2261SMartin Matuska 	case HELP_ZONE:
4411f1e2261SMartin Matuska 		return (gettext("\tzone <nsfile> <filesystem>\n"));
4421f1e2261SMartin Matuska 	case HELP_UNZONE:
4431f1e2261SMartin Matuska 		return (gettext("\tunzone <nsfile> <filesystem>\n"));
4441f88aa09SMartin Matuska 	default:
4451f88aa09SMartin Matuska 		__builtin_unreachable();
446eda14cbcSMatt Macy 	}
447eda14cbcSMatt Macy }
448eda14cbcSMatt Macy 
449eda14cbcSMatt Macy void
450eda14cbcSMatt Macy nomem(void)
451eda14cbcSMatt Macy {
452eda14cbcSMatt Macy 	(void) fprintf(stderr, gettext("internal error: out of memory\n"));
453eda14cbcSMatt Macy 	exit(1);
454eda14cbcSMatt Macy }
455eda14cbcSMatt Macy 
456eda14cbcSMatt Macy /*
457eda14cbcSMatt Macy  * Utility function to guarantee malloc() success.
458eda14cbcSMatt Macy  */
459eda14cbcSMatt Macy 
460eda14cbcSMatt Macy void *
461eda14cbcSMatt Macy safe_malloc(size_t size)
462eda14cbcSMatt Macy {
463eda14cbcSMatt Macy 	void *data;
464eda14cbcSMatt Macy 
465eda14cbcSMatt Macy 	if ((data = calloc(1, size)) == NULL)
466eda14cbcSMatt Macy 		nomem();
467eda14cbcSMatt Macy 
468eda14cbcSMatt Macy 	return (data);
469eda14cbcSMatt Macy }
470eda14cbcSMatt Macy 
471eda14cbcSMatt Macy static void *
472eda14cbcSMatt Macy safe_realloc(void *data, size_t size)
473eda14cbcSMatt Macy {
474eda14cbcSMatt Macy 	void *newp;
475eda14cbcSMatt Macy 	if ((newp = realloc(data, size)) == NULL) {
476eda14cbcSMatt Macy 		free(data);
477eda14cbcSMatt Macy 		nomem();
478eda14cbcSMatt Macy 	}
479eda14cbcSMatt Macy 
480eda14cbcSMatt Macy 	return (newp);
481eda14cbcSMatt Macy }
482eda14cbcSMatt Macy 
483eda14cbcSMatt Macy static char *
484a0b956f5SMartin Matuska safe_strdup(const char *str)
485eda14cbcSMatt Macy {
486eda14cbcSMatt Macy 	char *dupstr = strdup(str);
487eda14cbcSMatt Macy 
488eda14cbcSMatt Macy 	if (dupstr == NULL)
489eda14cbcSMatt Macy 		nomem();
490eda14cbcSMatt Macy 
491eda14cbcSMatt Macy 	return (dupstr);
492eda14cbcSMatt Macy }
493eda14cbcSMatt Macy 
494eda14cbcSMatt Macy /*
495eda14cbcSMatt Macy  * Callback routine that will print out information for each of
496eda14cbcSMatt Macy  * the properties.
497eda14cbcSMatt Macy  */
498eda14cbcSMatt Macy static int
499eda14cbcSMatt Macy usage_prop_cb(int prop, void *cb)
500eda14cbcSMatt Macy {
501eda14cbcSMatt Macy 	FILE *fp = cb;
502eda14cbcSMatt Macy 
503eda14cbcSMatt Macy 	(void) fprintf(fp, "\t%-15s ", zfs_prop_to_name(prop));
504eda14cbcSMatt Macy 
505eda14cbcSMatt Macy 	if (zfs_prop_readonly(prop))
506eda14cbcSMatt Macy 		(void) fprintf(fp, " NO    ");
507eda14cbcSMatt Macy 	else
508eda14cbcSMatt Macy 		(void) fprintf(fp, "YES    ");
509eda14cbcSMatt Macy 
510eda14cbcSMatt Macy 	if (zfs_prop_inheritable(prop))
511eda14cbcSMatt Macy 		(void) fprintf(fp, "  YES   ");
512eda14cbcSMatt Macy 	else
513eda14cbcSMatt Macy 		(void) fprintf(fp, "   NO   ");
514eda14cbcSMatt Macy 
515716fd348SMartin Matuska 	(void) fprintf(fp, "%s\n", zfs_prop_values(prop) ?: "-");
516eda14cbcSMatt Macy 
517eda14cbcSMatt Macy 	return (ZPROP_CONT);
518eda14cbcSMatt Macy }
519eda14cbcSMatt Macy 
520eda14cbcSMatt Macy /*
521eda14cbcSMatt Macy  * Display usage message.  If we're inside a command, display only the usage for
522eda14cbcSMatt Macy  * that command.  Otherwise, iterate over the entire command table and display
523eda14cbcSMatt Macy  * a complete usage message.
524eda14cbcSMatt Macy  */
525da5137abSMartin Matuska static __attribute__((noreturn)) void
526eda14cbcSMatt Macy usage(boolean_t requested)
527eda14cbcSMatt Macy {
528eda14cbcSMatt Macy 	int i;
529eda14cbcSMatt Macy 	boolean_t show_properties = B_FALSE;
530eda14cbcSMatt Macy 	FILE *fp = requested ? stdout : stderr;
531eda14cbcSMatt Macy 
532eda14cbcSMatt Macy 	if (current_command == NULL) {
533eda14cbcSMatt Macy 
534eda14cbcSMatt Macy 		(void) fprintf(fp, gettext("usage: zfs command args ...\n"));
535eda14cbcSMatt Macy 		(void) fprintf(fp,
536eda14cbcSMatt Macy 		    gettext("where 'command' is one of the following:\n\n"));
537eda14cbcSMatt Macy 
538eda14cbcSMatt Macy 		for (i = 0; i < NCOMMAND; i++) {
539eda14cbcSMatt Macy 			if (command_table[i].name == NULL)
540eda14cbcSMatt Macy 				(void) fprintf(fp, "\n");
541eda14cbcSMatt Macy 			else
542eda14cbcSMatt Macy 				(void) fprintf(fp, "%s",
543eda14cbcSMatt Macy 				    get_usage(command_table[i].usage));
544eda14cbcSMatt Macy 		}
545eda14cbcSMatt Macy 
546eda14cbcSMatt Macy 		(void) fprintf(fp, gettext("\nEach dataset is of the form: "
547eda14cbcSMatt Macy 		    "pool/[dataset/]*dataset[@name]\n"));
548eda14cbcSMatt Macy 	} else {
549eda14cbcSMatt Macy 		(void) fprintf(fp, gettext("usage:\n"));
550eda14cbcSMatt Macy 		(void) fprintf(fp, "%s", get_usage(current_command->usage));
551eda14cbcSMatt Macy 	}
552eda14cbcSMatt Macy 
553eda14cbcSMatt Macy 	if (current_command != NULL &&
554eda14cbcSMatt Macy 	    (strcmp(current_command->name, "set") == 0 ||
555eda14cbcSMatt Macy 	    strcmp(current_command->name, "get") == 0 ||
556eda14cbcSMatt Macy 	    strcmp(current_command->name, "inherit") == 0 ||
557eda14cbcSMatt Macy 	    strcmp(current_command->name, "list") == 0))
558eda14cbcSMatt Macy 		show_properties = B_TRUE;
559eda14cbcSMatt Macy 
560eda14cbcSMatt Macy 	if (show_properties) {
561bb2d13b6SMartin Matuska 		(void) fprintf(fp, "%s",
562eda14cbcSMatt Macy 		    gettext("\nThe following properties are supported:\n"));
563eda14cbcSMatt Macy 
564eda14cbcSMatt Macy 		(void) fprintf(fp, "\n\t%-14s %s  %s   %s\n\n",
565eda14cbcSMatt Macy 		    "PROPERTY", "EDIT", "INHERIT", "VALUES");
566eda14cbcSMatt Macy 
567eda14cbcSMatt Macy 		/* Iterate over all properties */
568eda14cbcSMatt Macy 		(void) zprop_iter(usage_prop_cb, fp, B_FALSE, B_TRUE,
569eda14cbcSMatt Macy 		    ZFS_TYPE_DATASET);
570eda14cbcSMatt Macy 
571eda14cbcSMatt Macy 		(void) fprintf(fp, "\t%-15s ", "userused@...");
572eda14cbcSMatt Macy 		(void) fprintf(fp, " NO       NO   <size>\n");
573eda14cbcSMatt Macy 		(void) fprintf(fp, "\t%-15s ", "groupused@...");
574eda14cbcSMatt Macy 		(void) fprintf(fp, " NO       NO   <size>\n");
575eda14cbcSMatt Macy 		(void) fprintf(fp, "\t%-15s ", "projectused@...");
576eda14cbcSMatt Macy 		(void) fprintf(fp, " NO       NO   <size>\n");
577eda14cbcSMatt Macy 		(void) fprintf(fp, "\t%-15s ", "userobjused@...");
578eda14cbcSMatt Macy 		(void) fprintf(fp, " NO       NO   <size>\n");
579eda14cbcSMatt Macy 		(void) fprintf(fp, "\t%-15s ", "groupobjused@...");
580eda14cbcSMatt Macy 		(void) fprintf(fp, " NO       NO   <size>\n");
581eda14cbcSMatt Macy 		(void) fprintf(fp, "\t%-15s ", "projectobjused@...");
582eda14cbcSMatt Macy 		(void) fprintf(fp, " NO       NO   <size>\n");
583eda14cbcSMatt Macy 		(void) fprintf(fp, "\t%-15s ", "userquota@...");
584eda14cbcSMatt Macy 		(void) fprintf(fp, "YES       NO   <size> | none\n");
585eda14cbcSMatt Macy 		(void) fprintf(fp, "\t%-15s ", "groupquota@...");
586eda14cbcSMatt Macy 		(void) fprintf(fp, "YES       NO   <size> | none\n");
587eda14cbcSMatt Macy 		(void) fprintf(fp, "\t%-15s ", "projectquota@...");
588eda14cbcSMatt Macy 		(void) fprintf(fp, "YES       NO   <size> | none\n");
589eda14cbcSMatt Macy 		(void) fprintf(fp, "\t%-15s ", "userobjquota@...");
590eda14cbcSMatt Macy 		(void) fprintf(fp, "YES       NO   <size> | none\n");
591eda14cbcSMatt Macy 		(void) fprintf(fp, "\t%-15s ", "groupobjquota@...");
592eda14cbcSMatt Macy 		(void) fprintf(fp, "YES       NO   <size> | none\n");
593eda14cbcSMatt Macy 		(void) fprintf(fp, "\t%-15s ", "projectobjquota@...");
594eda14cbcSMatt Macy 		(void) fprintf(fp, "YES       NO   <size> | none\n");
595eda14cbcSMatt Macy 		(void) fprintf(fp, "\t%-15s ", "written@<snap>");
596eda14cbcSMatt Macy 		(void) fprintf(fp, " NO       NO   <size>\n");
597eda14cbcSMatt Macy 		(void) fprintf(fp, "\t%-15s ", "written#<bookmark>");
598eda14cbcSMatt Macy 		(void) fprintf(fp, " NO       NO   <size>\n");
599eda14cbcSMatt Macy 
600eda14cbcSMatt Macy 		(void) fprintf(fp, gettext("\nSizes are specified in bytes "
601eda14cbcSMatt Macy 		    "with standard units such as K, M, G, etc.\n"));
602c03c5b1cSMartin Matuska 		(void) fprintf(fp, "%s", gettext("\nUser-defined properties "
603c03c5b1cSMartin Matuska 		    "can be specified by using a name containing a colon "
604c03c5b1cSMartin Matuska 		    "(:).\n"));
605eda14cbcSMatt Macy 		(void) fprintf(fp, gettext("\nThe {user|group|project}"
606eda14cbcSMatt Macy 		    "[obj]{used|quota}@ properties must be appended with\n"
607eda14cbcSMatt Macy 		    "a user|group|project specifier of one of these forms:\n"
608eda14cbcSMatt Macy 		    "    POSIX name      (eg: \"matt\")\n"
609eda14cbcSMatt Macy 		    "    POSIX id        (eg: \"126829\")\n"
610eda14cbcSMatt Macy 		    "    SMB name@domain (eg: \"matt@sun\")\n"
611eda14cbcSMatt Macy 		    "    SMB SID         (eg: \"S-1-234-567-89\")\n"));
612eda14cbcSMatt Macy 	} else {
613eda14cbcSMatt Macy 		(void) fprintf(fp,
614eda14cbcSMatt Macy 		    gettext("\nFor the property list, run: %s\n"),
615eda14cbcSMatt Macy 		    "zfs set|get");
616eda14cbcSMatt Macy 		(void) fprintf(fp,
617eda14cbcSMatt Macy 		    gettext("\nFor the delegated permission list, run: %s\n"),
618eda14cbcSMatt Macy 		    "zfs allow|unallow");
619cbfe9975SMartin Matuska 		(void) fprintf(fp,
620cbfe9975SMartin Matuska 		    gettext("\nFor further help on a command or topic, "
621cbfe9975SMartin Matuska 		    "run: %s\n"), "zfs help [<topic>]");
622eda14cbcSMatt Macy 	}
623eda14cbcSMatt Macy 
624eda14cbcSMatt Macy 	/*
625eda14cbcSMatt Macy 	 * See comments at end of main().
626eda14cbcSMatt Macy 	 */
627eda14cbcSMatt Macy 	if (getenv("ZFS_ABORT") != NULL) {
628eda14cbcSMatt Macy 		(void) printf("dumping core by request\n");
629eda14cbcSMatt Macy 		abort();
630eda14cbcSMatt Macy 	}
631eda14cbcSMatt Macy 
632eda14cbcSMatt Macy 	exit(requested ? 0 : 2);
633eda14cbcSMatt Macy }
634eda14cbcSMatt Macy 
635eda14cbcSMatt Macy /*
636eda14cbcSMatt Macy  * Take a property=value argument string and add it to the given nvlist.
637eda14cbcSMatt Macy  * Modifies the argument inplace.
638eda14cbcSMatt Macy  */
639eda14cbcSMatt Macy static boolean_t
640eda14cbcSMatt Macy parseprop(nvlist_t *props, char *propname)
641eda14cbcSMatt Macy {
642eda14cbcSMatt Macy 	char *propval;
643eda14cbcSMatt Macy 
644eda14cbcSMatt Macy 	if ((propval = strchr(propname, '=')) == NULL) {
645eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("missing "
646eda14cbcSMatt Macy 		    "'=' for property=value argument\n"));
647eda14cbcSMatt Macy 		return (B_FALSE);
648eda14cbcSMatt Macy 	}
649eda14cbcSMatt Macy 	*propval = '\0';
650eda14cbcSMatt Macy 	propval++;
651eda14cbcSMatt Macy 	if (nvlist_exists(props, propname)) {
652eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("property '%s' "
653eda14cbcSMatt Macy 		    "specified multiple times\n"), propname);
654eda14cbcSMatt Macy 		return (B_FALSE);
655eda14cbcSMatt Macy 	}
656eda14cbcSMatt Macy 	if (nvlist_add_string(props, propname, propval) != 0)
657eda14cbcSMatt Macy 		nomem();
658eda14cbcSMatt Macy 	return (B_TRUE);
659eda14cbcSMatt Macy }
660eda14cbcSMatt Macy 
661eda14cbcSMatt Macy /*
662eda14cbcSMatt Macy  * Take a property name argument and add it to the given nvlist.
663eda14cbcSMatt Macy  * Modifies the argument inplace.
664eda14cbcSMatt Macy  */
665eda14cbcSMatt Macy static boolean_t
666eda14cbcSMatt Macy parsepropname(nvlist_t *props, char *propname)
667eda14cbcSMatt Macy {
668eda14cbcSMatt Macy 	if (strchr(propname, '=') != NULL) {
669eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("invalid character "
670eda14cbcSMatt Macy 		    "'=' in property argument\n"));
671eda14cbcSMatt Macy 		return (B_FALSE);
672eda14cbcSMatt Macy 	}
673eda14cbcSMatt Macy 	if (nvlist_exists(props, propname)) {
674eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("property '%s' "
675eda14cbcSMatt Macy 		    "specified multiple times\n"), propname);
676eda14cbcSMatt Macy 		return (B_FALSE);
677eda14cbcSMatt Macy 	}
678eda14cbcSMatt Macy 	if (nvlist_add_boolean(props, propname) != 0)
679eda14cbcSMatt Macy 		nomem();
680eda14cbcSMatt Macy 	return (B_TRUE);
681eda14cbcSMatt Macy }
682eda14cbcSMatt Macy 
683eda14cbcSMatt Macy static int
684eda14cbcSMatt Macy parse_depth(char *opt, int *flags)
685eda14cbcSMatt Macy {
686eda14cbcSMatt Macy 	char *tmp;
687eda14cbcSMatt Macy 	int depth;
688eda14cbcSMatt Macy 
689eda14cbcSMatt Macy 	depth = (int)strtol(opt, &tmp, 0);
690eda14cbcSMatt Macy 	if (*tmp) {
691eda14cbcSMatt Macy 		(void) fprintf(stderr,
692eda14cbcSMatt Macy 		    gettext("%s is not an integer\n"), optarg);
693eda14cbcSMatt Macy 		usage(B_FALSE);
694eda14cbcSMatt Macy 	}
695eda14cbcSMatt Macy 	if (depth < 0) {
696eda14cbcSMatt Macy 		(void) fprintf(stderr,
697eda14cbcSMatt Macy 		    gettext("Depth can not be negative.\n"));
698eda14cbcSMatt Macy 		usage(B_FALSE);
699eda14cbcSMatt Macy 	}
700eda14cbcSMatt Macy 	*flags |= (ZFS_ITER_DEPTH_LIMIT|ZFS_ITER_RECURSE);
701eda14cbcSMatt Macy 	return (depth);
702eda14cbcSMatt Macy }
703eda14cbcSMatt Macy 
704eda14cbcSMatt Macy #define	PROGRESS_DELAY 2		/* seconds */
705eda14cbcSMatt Macy 
706a0b956f5SMartin Matuska static const char *pt_reverse =
707a0b956f5SMartin Matuska 	"\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";
708eda14cbcSMatt Macy static time_t pt_begin;
709eda14cbcSMatt Macy static char *pt_header = NULL;
710eda14cbcSMatt Macy static boolean_t pt_shown;
711eda14cbcSMatt Macy 
712eda14cbcSMatt Macy static void
713eda14cbcSMatt Macy start_progress_timer(void)
714eda14cbcSMatt Macy {
715eda14cbcSMatt Macy 	pt_begin = time(NULL) + PROGRESS_DELAY;
716eda14cbcSMatt Macy 	pt_shown = B_FALSE;
717eda14cbcSMatt Macy }
718eda14cbcSMatt Macy 
719eda14cbcSMatt Macy static void
720a0b956f5SMartin Matuska set_progress_header(const char *header)
721eda14cbcSMatt Macy {
722eda14cbcSMatt Macy 	assert(pt_header == NULL);
723eda14cbcSMatt Macy 	pt_header = safe_strdup(header);
724eda14cbcSMatt Macy 	if (pt_shown) {
725eda14cbcSMatt Macy 		(void) printf("%s: ", header);
726eda14cbcSMatt Macy 		(void) fflush(stdout);
727eda14cbcSMatt Macy 	}
728eda14cbcSMatt Macy }
729eda14cbcSMatt Macy 
730eda14cbcSMatt Macy static void
731a0b956f5SMartin Matuska update_progress(const char *update)
732eda14cbcSMatt Macy {
733eda14cbcSMatt Macy 	if (!pt_shown && time(NULL) > pt_begin) {
734eda14cbcSMatt Macy 		int len = strlen(update);
735eda14cbcSMatt Macy 
736eda14cbcSMatt Macy 		(void) printf("%s: %s%*.*s", pt_header, update, len, len,
737eda14cbcSMatt Macy 		    pt_reverse);
738eda14cbcSMatt Macy 		(void) fflush(stdout);
739eda14cbcSMatt Macy 		pt_shown = B_TRUE;
740eda14cbcSMatt Macy 	} else if (pt_shown) {
741eda14cbcSMatt Macy 		int len = strlen(update);
742eda14cbcSMatt Macy 
743eda14cbcSMatt Macy 		(void) printf("%s%*.*s", update, len, len, pt_reverse);
744eda14cbcSMatt Macy 		(void) fflush(stdout);
745eda14cbcSMatt Macy 	}
746eda14cbcSMatt Macy }
747eda14cbcSMatt Macy 
748eda14cbcSMatt Macy static void
749a0b956f5SMartin Matuska finish_progress(const char *done)
750eda14cbcSMatt Macy {
751eda14cbcSMatt Macy 	if (pt_shown) {
752a0b956f5SMartin Matuska 		(void) puts(done);
753eda14cbcSMatt Macy 		(void) fflush(stdout);
754eda14cbcSMatt Macy 	}
755eda14cbcSMatt Macy 	free(pt_header);
756eda14cbcSMatt Macy 	pt_header = NULL;
757eda14cbcSMatt Macy }
758eda14cbcSMatt Macy 
759eda14cbcSMatt Macy static int
760eda14cbcSMatt Macy zfs_mount_and_share(libzfs_handle_t *hdl, const char *dataset, zfs_type_t type)
761eda14cbcSMatt Macy {
762eda14cbcSMatt Macy 	zfs_handle_t *zhp = NULL;
763eda14cbcSMatt Macy 	int ret = 0;
764eda14cbcSMatt Macy 
765eda14cbcSMatt Macy 	zhp = zfs_open(hdl, dataset, type);
766eda14cbcSMatt Macy 	if (zhp == NULL)
767eda14cbcSMatt Macy 		return (1);
768eda14cbcSMatt Macy 
769eda14cbcSMatt Macy 	/*
770eda14cbcSMatt Macy 	 * Volumes may neither be mounted or shared.  Potentially in the
771eda14cbcSMatt Macy 	 * future filesystems detected on these volumes could be mounted.
772eda14cbcSMatt Macy 	 */
773eda14cbcSMatt Macy 	if (zfs_get_type(zhp) == ZFS_TYPE_VOLUME) {
774eda14cbcSMatt Macy 		zfs_close(zhp);
775eda14cbcSMatt Macy 		return (0);
776eda14cbcSMatt Macy 	}
777eda14cbcSMatt Macy 
778eda14cbcSMatt Macy 	/*
779eda14cbcSMatt Macy 	 * Mount and/or share the new filesystem as appropriate.  We provide a
780eda14cbcSMatt Macy 	 * verbose error message to let the user know that their filesystem was
781eda14cbcSMatt Macy 	 * in fact created, even if we failed to mount or share it.
782eda14cbcSMatt Macy 	 *
783eda14cbcSMatt Macy 	 * If the user doesn't want the dataset automatically mounted, then
784eda14cbcSMatt Macy 	 * skip the mount/share step
785eda14cbcSMatt Macy 	 */
786eda14cbcSMatt Macy 	if (zfs_prop_valid_for_type(ZFS_PROP_CANMOUNT, type, B_FALSE) &&
787eda14cbcSMatt Macy 	    zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT) == ZFS_CANMOUNT_ON) {
788eda14cbcSMatt Macy 		if (zfs_mount_delegation_check()) {
789eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("filesystem "
790eda14cbcSMatt Macy 			    "successfully created, but it may only be "
791eda14cbcSMatt Macy 			    "mounted by root\n"));
792eda14cbcSMatt Macy 			ret = 1;
793eda14cbcSMatt Macy 		} else if (zfs_mount(zhp, NULL, 0) != 0) {
794eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("filesystem "
795eda14cbcSMatt Macy 			    "successfully created, but not mounted\n"));
796eda14cbcSMatt Macy 			ret = 1;
797716fd348SMartin Matuska 		} else if (zfs_share(zhp, NULL) != 0) {
798eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("filesystem "
799eda14cbcSMatt Macy 			    "successfully created, but not shared\n"));
800eda14cbcSMatt Macy 			ret = 1;
801eda14cbcSMatt Macy 		}
802716fd348SMartin Matuska 		zfs_commit_shares(NULL);
803eda14cbcSMatt Macy 	}
804eda14cbcSMatt Macy 
805eda14cbcSMatt Macy 	zfs_close(zhp);
806eda14cbcSMatt Macy 
807eda14cbcSMatt Macy 	return (ret);
808eda14cbcSMatt Macy }
809eda14cbcSMatt Macy 
810eda14cbcSMatt Macy /*
811eda14cbcSMatt Macy  * zfs clone [-p] [-o prop=value] ... <snap> <fs | vol>
812eda14cbcSMatt Macy  *
813eda14cbcSMatt Macy  * Given an existing dataset, create a writable copy whose initial contents
814eda14cbcSMatt Macy  * are the same as the source.  The newly created dataset maintains a
815eda14cbcSMatt Macy  * dependency on the original; the original cannot be destroyed so long as
816eda14cbcSMatt Macy  * the clone exists.
817eda14cbcSMatt Macy  *
818eda14cbcSMatt Macy  * The '-p' flag creates all the non-existing ancestors of the target first.
819eda14cbcSMatt Macy  */
820eda14cbcSMatt Macy static int
821eda14cbcSMatt Macy zfs_do_clone(int argc, char **argv)
822eda14cbcSMatt Macy {
823eda14cbcSMatt Macy 	zfs_handle_t *zhp = NULL;
824eda14cbcSMatt Macy 	boolean_t parents = B_FALSE;
825eda14cbcSMatt Macy 	nvlist_t *props;
826eda14cbcSMatt Macy 	int ret = 0;
827eda14cbcSMatt Macy 	int c;
828eda14cbcSMatt Macy 
829eda14cbcSMatt Macy 	if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0)
830eda14cbcSMatt Macy 		nomem();
831eda14cbcSMatt Macy 
832eda14cbcSMatt Macy 	/* check options */
833eda14cbcSMatt Macy 	while ((c = getopt(argc, argv, "o:p")) != -1) {
834eda14cbcSMatt Macy 		switch (c) {
835eda14cbcSMatt Macy 		case 'o':
836eda14cbcSMatt Macy 			if (!parseprop(props, optarg)) {
837eda14cbcSMatt Macy 				nvlist_free(props);
838eda14cbcSMatt Macy 				return (1);
839eda14cbcSMatt Macy 			}
840eda14cbcSMatt Macy 			break;
841eda14cbcSMatt Macy 		case 'p':
842eda14cbcSMatt Macy 			parents = B_TRUE;
843eda14cbcSMatt Macy 			break;
844eda14cbcSMatt Macy 		case '?':
845eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
846eda14cbcSMatt Macy 			    optopt);
847eda14cbcSMatt Macy 			goto usage;
848eda14cbcSMatt Macy 		}
849eda14cbcSMatt Macy 	}
850eda14cbcSMatt Macy 
851eda14cbcSMatt Macy 	argc -= optind;
852eda14cbcSMatt Macy 	argv += optind;
853eda14cbcSMatt Macy 
854eda14cbcSMatt Macy 	/* check number of arguments */
855eda14cbcSMatt Macy 	if (argc < 1) {
856eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("missing source dataset "
857eda14cbcSMatt Macy 		    "argument\n"));
858eda14cbcSMatt Macy 		goto usage;
859eda14cbcSMatt Macy 	}
860eda14cbcSMatt Macy 	if (argc < 2) {
861eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("missing target dataset "
862eda14cbcSMatt Macy 		    "argument\n"));
863eda14cbcSMatt Macy 		goto usage;
864eda14cbcSMatt Macy 	}
865eda14cbcSMatt Macy 	if (argc > 2) {
866eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("too many arguments\n"));
867eda14cbcSMatt Macy 		goto usage;
868eda14cbcSMatt Macy 	}
869eda14cbcSMatt Macy 
870eda14cbcSMatt Macy 	/* open the source dataset */
871eda14cbcSMatt Macy 	if ((zhp = zfs_open(g_zfs, argv[0], ZFS_TYPE_SNAPSHOT)) == NULL) {
872eda14cbcSMatt Macy 		nvlist_free(props);
873eda14cbcSMatt Macy 		return (1);
874eda14cbcSMatt Macy 	}
875eda14cbcSMatt Macy 
876eda14cbcSMatt Macy 	if (parents && zfs_name_valid(argv[1], ZFS_TYPE_FILESYSTEM |
877eda14cbcSMatt Macy 	    ZFS_TYPE_VOLUME)) {
878eda14cbcSMatt Macy 		/*
879eda14cbcSMatt Macy 		 * Now create the ancestors of the target dataset.  If the
880eda14cbcSMatt Macy 		 * target already exists and '-p' option was used we should not
881eda14cbcSMatt Macy 		 * complain.
882eda14cbcSMatt Macy 		 */
883eda14cbcSMatt Macy 		if (zfs_dataset_exists(g_zfs, argv[1], ZFS_TYPE_FILESYSTEM |
884eda14cbcSMatt Macy 		    ZFS_TYPE_VOLUME)) {
885eda14cbcSMatt Macy 			zfs_close(zhp);
886eda14cbcSMatt Macy 			nvlist_free(props);
887eda14cbcSMatt Macy 			return (0);
888eda14cbcSMatt Macy 		}
889eda14cbcSMatt Macy 		if (zfs_create_ancestors(g_zfs, argv[1]) != 0) {
890eda14cbcSMatt Macy 			zfs_close(zhp);
891eda14cbcSMatt Macy 			nvlist_free(props);
892eda14cbcSMatt Macy 			return (1);
893eda14cbcSMatt Macy 		}
894eda14cbcSMatt Macy 	}
895eda14cbcSMatt Macy 
896eda14cbcSMatt Macy 	/* pass to libzfs */
897eda14cbcSMatt Macy 	ret = zfs_clone(zhp, argv[1], props);
898eda14cbcSMatt Macy 
899eda14cbcSMatt Macy 	/* create the mountpoint if necessary */
900eda14cbcSMatt Macy 	if (ret == 0) {
901eda14cbcSMatt Macy 		if (log_history) {
902eda14cbcSMatt Macy 			(void) zpool_log_history(g_zfs, history_str);
903eda14cbcSMatt Macy 			log_history = B_FALSE;
904eda14cbcSMatt Macy 		}
905eda14cbcSMatt Macy 
906eda14cbcSMatt Macy 		ret = zfs_mount_and_share(g_zfs, argv[1], ZFS_TYPE_DATASET);
907eda14cbcSMatt Macy 	}
908eda14cbcSMatt Macy 
909eda14cbcSMatt Macy 	zfs_close(zhp);
910eda14cbcSMatt Macy 	nvlist_free(props);
911eda14cbcSMatt Macy 
912eda14cbcSMatt Macy 	return (!!ret);
913eda14cbcSMatt Macy 
914eda14cbcSMatt Macy usage:
915eda14cbcSMatt Macy 	ASSERT3P(zhp, ==, NULL);
916eda14cbcSMatt Macy 	nvlist_free(props);
917eda14cbcSMatt Macy 	usage(B_FALSE);
918eda14cbcSMatt Macy 	return (-1);
919eda14cbcSMatt Macy }
920eda14cbcSMatt Macy 
921eda14cbcSMatt Macy /*
9227877fdebSMatt Macy  * Return a default volblocksize for the pool which always uses more than
9237877fdebSMatt Macy  * half of the data sectors.  This primarily applies to dRAID which always
9247877fdebSMatt Macy  * writes full stripe widths.
9257877fdebSMatt Macy  */
9267877fdebSMatt Macy static uint64_t
9277877fdebSMatt Macy default_volblocksize(zpool_handle_t *zhp, nvlist_t *props)
9287877fdebSMatt Macy {
9297877fdebSMatt Macy 	uint64_t volblocksize, asize = SPA_MINBLOCKSIZE;
9307877fdebSMatt Macy 	nvlist_t *tree, **vdevs;
9317877fdebSMatt Macy 	uint_t nvdevs;
9327877fdebSMatt Macy 
9337877fdebSMatt Macy 	nvlist_t *config = zpool_get_config(zhp, NULL);
9347877fdebSMatt Macy 
9357877fdebSMatt Macy 	if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &tree) != 0 ||
9367877fdebSMatt Macy 	    nvlist_lookup_nvlist_array(tree, ZPOOL_CONFIG_CHILDREN,
9377877fdebSMatt Macy 	    &vdevs, &nvdevs) != 0) {
9387877fdebSMatt Macy 		return (ZVOL_DEFAULT_BLOCKSIZE);
9397877fdebSMatt Macy 	}
9407877fdebSMatt Macy 
9417877fdebSMatt Macy 	for (int i = 0; i < nvdevs; i++) {
9427877fdebSMatt Macy 		nvlist_t *nv = vdevs[i];
9437877fdebSMatt Macy 		uint64_t ashift, ndata, nparity;
9447877fdebSMatt Macy 
9457877fdebSMatt Macy 		if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_ASHIFT, &ashift) != 0)
9467877fdebSMatt Macy 			continue;
9477877fdebSMatt Macy 
9487877fdebSMatt Macy 		if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_DRAID_NDATA,
9497877fdebSMatt Macy 		    &ndata) == 0) {
9507877fdebSMatt Macy 			/* dRAID minimum allocation width */
9517877fdebSMatt Macy 			asize = MAX(asize, ndata * (1ULL << ashift));
9527877fdebSMatt Macy 		} else if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NPARITY,
9537877fdebSMatt Macy 		    &nparity) == 0) {
9547877fdebSMatt Macy 			/* raidz minimum allocation width */
9557877fdebSMatt Macy 			if (nparity == 1)
9567877fdebSMatt Macy 				asize = MAX(asize, 2 * (1ULL << ashift));
9577877fdebSMatt Macy 			else
9587877fdebSMatt Macy 				asize = MAX(asize, 4 * (1ULL << ashift));
9597877fdebSMatt Macy 		} else {
9607877fdebSMatt Macy 			/* mirror or (non-redundant) leaf vdev */
9617877fdebSMatt Macy 			asize = MAX(asize, 1ULL << ashift);
9627877fdebSMatt Macy 		}
9637877fdebSMatt Macy 	}
9647877fdebSMatt Macy 
9657877fdebSMatt Macy 	/*
9667877fdebSMatt Macy 	 * Calculate the target volblocksize such that more than half
9677877fdebSMatt Macy 	 * of the asize is used. The following table is for 4k sectors.
9687877fdebSMatt Macy 	 *
9697877fdebSMatt Macy 	 * n   asize   blksz  used  |   n   asize   blksz  used
9707877fdebSMatt Macy 	 * -------------------------+---------------------------------
9717877fdebSMatt Macy 	 * 1   4,096   8,192  100%  |   9  36,864  32,768   88%
9727877fdebSMatt Macy 	 * 2   8,192   8,192  100%  |  10  40,960  32,768   80%
9737877fdebSMatt Macy 	 * 3  12,288   8,192   66%  |  11  45,056  32,768   72%
9747877fdebSMatt Macy 	 * 4  16,384  16,384  100%  |  12  49,152  32,768   66%
9757877fdebSMatt Macy 	 * 5  20,480  16,384   80%  |  13  53,248  32,768   61%
9767877fdebSMatt Macy 	 * 6  24,576  16,384   66%  |  14  57,344  32,768   57%
9777877fdebSMatt Macy 	 * 7  28,672  16,384   57%  |  15  61,440  32,768   53%
9787877fdebSMatt Macy 	 * 8  32,768  32,768  100%  |  16  65,536  65,636  100%
9797877fdebSMatt Macy 	 *
9807877fdebSMatt Macy 	 * This is primarily a concern for dRAID which always allocates
9817877fdebSMatt Macy 	 * a full stripe width.  For dRAID the default stripe width is
9827877fdebSMatt Macy 	 * n=8 in which case the volblocksize is set to 32k. Ignoring
9837877fdebSMatt Macy 	 * compression there are no unused sectors.  This same reasoning
9847877fdebSMatt Macy 	 * applies to raidz[2,3] so target 4 sectors to minimize waste.
9857877fdebSMatt Macy 	 */
9867877fdebSMatt Macy 	uint64_t tgt_volblocksize = ZVOL_DEFAULT_BLOCKSIZE;
9877877fdebSMatt Macy 	while (tgt_volblocksize * 2 <= asize)
9887877fdebSMatt Macy 		tgt_volblocksize *= 2;
9897877fdebSMatt Macy 
9907877fdebSMatt Macy 	const char *prop = zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE);
9917877fdebSMatt Macy 	if (nvlist_lookup_uint64(props, prop, &volblocksize) == 0) {
9927877fdebSMatt Macy 
9937877fdebSMatt Macy 		/* Issue a warning when a non-optimal size is requested. */
9947877fdebSMatt Macy 		if (volblocksize < ZVOL_DEFAULT_BLOCKSIZE) {
9957877fdebSMatt Macy 			(void) fprintf(stderr, gettext("Warning: "
9967877fdebSMatt Macy 			    "volblocksize (%llu) is less than the default "
9977877fdebSMatt Macy 			    "minimum block size (%llu).\nTo reduce wasted "
9987877fdebSMatt Macy 			    "space a volblocksize of %llu is recommended.\n"),
9997877fdebSMatt Macy 			    (u_longlong_t)volblocksize,
10007877fdebSMatt Macy 			    (u_longlong_t)ZVOL_DEFAULT_BLOCKSIZE,
10017877fdebSMatt Macy 			    (u_longlong_t)tgt_volblocksize);
10027877fdebSMatt Macy 		} else if (volblocksize < tgt_volblocksize) {
10037877fdebSMatt Macy 			(void) fprintf(stderr, gettext("Warning: "
10047877fdebSMatt Macy 			    "volblocksize (%llu) is much less than the "
10057877fdebSMatt Macy 			    "minimum allocation\nunit (%llu), which wastes "
10067877fdebSMatt Macy 			    "at least %llu%% of space. To reduce wasted "
10077877fdebSMatt Macy 			    "space,\nuse a larger volblocksize (%llu is "
10087877fdebSMatt Macy 			    "recommended), fewer dRAID data disks\n"
10097877fdebSMatt Macy 			    "per group, or smaller sector size (ashift).\n"),
10107877fdebSMatt Macy 			    (u_longlong_t)volblocksize, (u_longlong_t)asize,
10117877fdebSMatt Macy 			    (u_longlong_t)((100 * (asize - volblocksize)) /
10127877fdebSMatt Macy 			    asize), (u_longlong_t)tgt_volblocksize);
10137877fdebSMatt Macy 		}
10147877fdebSMatt Macy 	} else {
10157877fdebSMatt Macy 		volblocksize = tgt_volblocksize;
10167877fdebSMatt Macy 		fnvlist_add_uint64(props, prop, volblocksize);
10177877fdebSMatt Macy 	}
10187877fdebSMatt Macy 
10197877fdebSMatt Macy 	return (volblocksize);
10207877fdebSMatt Macy }
10217877fdebSMatt Macy 
10227877fdebSMatt Macy /*
1023eda14cbcSMatt Macy  * zfs create [-Pnpv] [-o prop=value] ... fs
1024eda14cbcSMatt Macy  * zfs create [-Pnpsv] [-b blocksize] [-o prop=value] ... -V vol size
1025eda14cbcSMatt Macy  *
1026eda14cbcSMatt Macy  * Create a new dataset.  This command can be used to create filesystems
1027eda14cbcSMatt Macy  * and volumes.  Snapshot creation is handled by 'zfs snapshot'.
1028eda14cbcSMatt Macy  * For volumes, the user must specify a size to be used.
1029eda14cbcSMatt Macy  *
1030eda14cbcSMatt Macy  * The '-s' flag applies only to volumes, and indicates that we should not try
1031eda14cbcSMatt Macy  * to set the reservation for this volume.  By default we set a reservation
1032eda14cbcSMatt Macy  * equal to the size for any volume.  For pools with SPA_VERSION >=
1033eda14cbcSMatt Macy  * SPA_VERSION_REFRESERVATION, we set a refreservation instead.
1034eda14cbcSMatt Macy  *
1035eda14cbcSMatt Macy  * The '-p' flag creates all the non-existing ancestors of the target first.
1036eda14cbcSMatt Macy  *
1037eda14cbcSMatt Macy  * The '-n' flag is no-op (dry run) mode.  This will perform a user-space sanity
1038eda14cbcSMatt Macy  * check of arguments and properties, but does not check for permissions,
1039eda14cbcSMatt Macy  * available space, etc.
1040eda14cbcSMatt Macy  *
10417877fdebSMatt Macy  * The '-u' flag prevents the newly created file system from being mounted.
10427877fdebSMatt Macy  *
1043eda14cbcSMatt Macy  * The '-v' flag is for verbose output.
1044eda14cbcSMatt Macy  *
1045eda14cbcSMatt Macy  * The '-P' flag is used for parseable output.  It implies '-v'.
1046eda14cbcSMatt Macy  */
1047eda14cbcSMatt Macy static int
1048eda14cbcSMatt Macy zfs_do_create(int argc, char **argv)
1049eda14cbcSMatt Macy {
1050eda14cbcSMatt Macy 	zfs_type_t type = ZFS_TYPE_FILESYSTEM;
1051eda14cbcSMatt Macy 	zpool_handle_t *zpool_handle = NULL;
1052eda14cbcSMatt Macy 	nvlist_t *real_props = NULL;
1053eda14cbcSMatt Macy 	uint64_t volsize = 0;
1054eda14cbcSMatt Macy 	int c;
1055eda14cbcSMatt Macy 	boolean_t noreserve = B_FALSE;
1056eda14cbcSMatt Macy 	boolean_t bflag = B_FALSE;
1057eda14cbcSMatt Macy 	boolean_t parents = B_FALSE;
1058eda14cbcSMatt Macy 	boolean_t dryrun = B_FALSE;
10597877fdebSMatt Macy 	boolean_t nomount = B_FALSE;
1060eda14cbcSMatt Macy 	boolean_t verbose = B_FALSE;
1061eda14cbcSMatt Macy 	boolean_t parseable = B_FALSE;
1062eda14cbcSMatt Macy 	int ret = 1;
1063eda14cbcSMatt Macy 	nvlist_t *props;
1064eda14cbcSMatt Macy 	uint64_t intval;
10652a58b312SMartin Matuska 	const char *strval;
1066eda14cbcSMatt Macy 
1067eda14cbcSMatt Macy 	if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0)
1068eda14cbcSMatt Macy 		nomem();
1069eda14cbcSMatt Macy 
1070eda14cbcSMatt Macy 	/* check options */
10717877fdebSMatt Macy 	while ((c = getopt(argc, argv, ":PV:b:nso:puv")) != -1) {
1072eda14cbcSMatt Macy 		switch (c) {
1073eda14cbcSMatt Macy 		case 'V':
1074eda14cbcSMatt Macy 			type = ZFS_TYPE_VOLUME;
1075eda14cbcSMatt Macy 			if (zfs_nicestrtonum(g_zfs, optarg, &intval) != 0) {
1076eda14cbcSMatt Macy 				(void) fprintf(stderr, gettext("bad volume "
1077eda14cbcSMatt Macy 				    "size '%s': %s\n"), optarg,
1078eda14cbcSMatt Macy 				    libzfs_error_description(g_zfs));
1079eda14cbcSMatt Macy 				goto error;
1080eda14cbcSMatt Macy 			}
1081eda14cbcSMatt Macy 
1082eda14cbcSMatt Macy 			if (nvlist_add_uint64(props,
1083eda14cbcSMatt Macy 			    zfs_prop_to_name(ZFS_PROP_VOLSIZE), intval) != 0)
1084eda14cbcSMatt Macy 				nomem();
1085eda14cbcSMatt Macy 			volsize = intval;
1086eda14cbcSMatt Macy 			break;
1087eda14cbcSMatt Macy 		case 'P':
1088eda14cbcSMatt Macy 			verbose = B_TRUE;
1089eda14cbcSMatt Macy 			parseable = B_TRUE;
1090eda14cbcSMatt Macy 			break;
1091eda14cbcSMatt Macy 		case 'p':
1092eda14cbcSMatt Macy 			parents = B_TRUE;
1093eda14cbcSMatt Macy 			break;
1094eda14cbcSMatt Macy 		case 'b':
1095eda14cbcSMatt Macy 			bflag = B_TRUE;
1096eda14cbcSMatt Macy 			if (zfs_nicestrtonum(g_zfs, optarg, &intval) != 0) {
1097eda14cbcSMatt Macy 				(void) fprintf(stderr, gettext("bad volume "
1098eda14cbcSMatt Macy 				    "block size '%s': %s\n"), optarg,
1099eda14cbcSMatt Macy 				    libzfs_error_description(g_zfs));
1100eda14cbcSMatt Macy 				goto error;
1101eda14cbcSMatt Macy 			}
1102eda14cbcSMatt Macy 
1103eda14cbcSMatt Macy 			if (nvlist_add_uint64(props,
1104eda14cbcSMatt Macy 			    zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE),
1105eda14cbcSMatt Macy 			    intval) != 0)
1106eda14cbcSMatt Macy 				nomem();
1107eda14cbcSMatt Macy 			break;
1108eda14cbcSMatt Macy 		case 'n':
1109eda14cbcSMatt Macy 			dryrun = B_TRUE;
1110eda14cbcSMatt Macy 			break;
1111eda14cbcSMatt Macy 		case 'o':
1112eda14cbcSMatt Macy 			if (!parseprop(props, optarg))
1113eda14cbcSMatt Macy 				goto error;
1114eda14cbcSMatt Macy 			break;
1115eda14cbcSMatt Macy 		case 's':
1116eda14cbcSMatt Macy 			noreserve = B_TRUE;
1117eda14cbcSMatt Macy 			break;
11187877fdebSMatt Macy 		case 'u':
11197877fdebSMatt Macy 			nomount = B_TRUE;
11207877fdebSMatt Macy 			break;
1121eda14cbcSMatt Macy 		case 'v':
1122eda14cbcSMatt Macy 			verbose = B_TRUE;
1123eda14cbcSMatt Macy 			break;
1124eda14cbcSMatt Macy 		case ':':
1125eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("missing size "
1126eda14cbcSMatt Macy 			    "argument\n"));
1127eda14cbcSMatt Macy 			goto badusage;
1128eda14cbcSMatt Macy 		case '?':
1129eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
1130eda14cbcSMatt Macy 			    optopt);
1131eda14cbcSMatt Macy 			goto badusage;
1132eda14cbcSMatt Macy 		}
1133eda14cbcSMatt Macy 	}
1134eda14cbcSMatt Macy 
1135eda14cbcSMatt Macy 	if ((bflag || noreserve) && type != ZFS_TYPE_VOLUME) {
1136eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("'-s' and '-b' can only be "
1137eda14cbcSMatt Macy 		    "used when creating a volume\n"));
1138eda14cbcSMatt Macy 		goto badusage;
1139eda14cbcSMatt Macy 	}
11407877fdebSMatt Macy 	if (nomount && type != ZFS_TYPE_FILESYSTEM) {
11417877fdebSMatt Macy 		(void) fprintf(stderr, gettext("'-u' can only be "
11427877fdebSMatt Macy 		    "used when creating a filesystem\n"));
11437877fdebSMatt Macy 		goto badusage;
11447877fdebSMatt Macy 	}
1145eda14cbcSMatt Macy 
1146eda14cbcSMatt Macy 	argc -= optind;
1147eda14cbcSMatt Macy 	argv += optind;
1148eda14cbcSMatt Macy 
1149eda14cbcSMatt Macy 	/* check number of arguments */
1150eda14cbcSMatt Macy 	if (argc == 0) {
1151eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("missing %s argument\n"),
1152eda14cbcSMatt Macy 		    zfs_type_to_name(type));
1153eda14cbcSMatt Macy 		goto badusage;
1154eda14cbcSMatt Macy 	}
1155eda14cbcSMatt Macy 	if (argc > 1) {
1156eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("too many arguments\n"));
1157eda14cbcSMatt Macy 		goto badusage;
1158eda14cbcSMatt Macy 	}
1159eda14cbcSMatt Macy 
11607877fdebSMatt Macy 	if (dryrun || type == ZFS_TYPE_VOLUME) {
1161eda14cbcSMatt Macy 		char msg[ZFS_MAX_DATASET_NAME_LEN * 2];
1162eda14cbcSMatt Macy 		char *p;
1163eda14cbcSMatt Macy 
1164eda14cbcSMatt Macy 		if ((p = strchr(argv[0], '/')) != NULL)
1165eda14cbcSMatt Macy 			*p = '\0';
1166eda14cbcSMatt Macy 		zpool_handle = zpool_open(g_zfs, argv[0]);
1167eda14cbcSMatt Macy 		if (p != NULL)
1168eda14cbcSMatt Macy 			*p = '/';
1169eda14cbcSMatt Macy 		if (zpool_handle == NULL)
1170eda14cbcSMatt Macy 			goto error;
1171eda14cbcSMatt Macy 
1172eda14cbcSMatt Macy 		(void) snprintf(msg, sizeof (msg),
1173eda14cbcSMatt Macy 		    dryrun ? gettext("cannot verify '%s'") :
1174eda14cbcSMatt Macy 		    gettext("cannot create '%s'"), argv[0]);
1175eda14cbcSMatt Macy 		if (props && (real_props = zfs_valid_proplist(g_zfs, type,
1176eda14cbcSMatt Macy 		    props, 0, NULL, zpool_handle, B_TRUE, msg)) == NULL) {
1177eda14cbcSMatt Macy 			zpool_close(zpool_handle);
1178eda14cbcSMatt Macy 			goto error;
1179eda14cbcSMatt Macy 		}
1180eda14cbcSMatt Macy 	}
1181eda14cbcSMatt Macy 
1182eda14cbcSMatt Macy 	if (type == ZFS_TYPE_VOLUME) {
11837877fdebSMatt Macy 		const char *prop = zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE);
11847877fdebSMatt Macy 		uint64_t volblocksize = default_volblocksize(zpool_handle,
11857877fdebSMatt Macy 		    real_props);
1186eda14cbcSMatt Macy 
11877877fdebSMatt Macy 		if (volblocksize != ZVOL_DEFAULT_BLOCKSIZE &&
11887877fdebSMatt Macy 		    nvlist_lookup_string(props, prop, &strval) != 0) {
11892a58b312SMartin Matuska 			char *tmp;
11902a58b312SMartin Matuska 			if (asprintf(&tmp, "%llu",
11917877fdebSMatt Macy 			    (u_longlong_t)volblocksize) == -1)
11927877fdebSMatt Macy 				nomem();
11932a58b312SMartin Matuska 			nvlist_add_string(props, prop, tmp);
11942a58b312SMartin Matuska 			free(tmp);
11957877fdebSMatt Macy 		}
1196eda14cbcSMatt Macy 
11977877fdebSMatt Macy 		/*
11987877fdebSMatt Macy 		 * If volsize is not a multiple of volblocksize, round it
11997877fdebSMatt Macy 		 * up to the nearest multiple of the volblocksize.
12007877fdebSMatt Macy 		 */
1201eda14cbcSMatt Macy 		if (volsize % volblocksize) {
1202eda14cbcSMatt Macy 			volsize = P2ROUNDUP_TYPED(volsize, volblocksize,
1203eda14cbcSMatt Macy 			    uint64_t);
1204eda14cbcSMatt Macy 
1205eda14cbcSMatt Macy 			if (nvlist_add_uint64(props,
1206eda14cbcSMatt Macy 			    zfs_prop_to_name(ZFS_PROP_VOLSIZE), volsize) != 0) {
1207eda14cbcSMatt Macy 				nvlist_free(props);
1208eda14cbcSMatt Macy 				nomem();
1209eda14cbcSMatt Macy 			}
1210eda14cbcSMatt Macy 		}
1211eda14cbcSMatt Macy 	}
1212eda14cbcSMatt Macy 
1213eda14cbcSMatt Macy 	if (type == ZFS_TYPE_VOLUME && !noreserve) {
1214eda14cbcSMatt Macy 		uint64_t spa_version;
1215eda14cbcSMatt Macy 		zfs_prop_t resv_prop;
1216eda14cbcSMatt Macy 
1217eda14cbcSMatt Macy 		spa_version = zpool_get_prop_int(zpool_handle,
1218eda14cbcSMatt Macy 		    ZPOOL_PROP_VERSION, NULL);
1219eda14cbcSMatt Macy 		if (spa_version >= SPA_VERSION_REFRESERVATION)
1220eda14cbcSMatt Macy 			resv_prop = ZFS_PROP_REFRESERVATION;
1221eda14cbcSMatt Macy 		else
1222eda14cbcSMatt Macy 			resv_prop = ZFS_PROP_RESERVATION;
1223eda14cbcSMatt Macy 
1224eda14cbcSMatt Macy 		volsize = zvol_volsize_to_reservation(zpool_handle, volsize,
1225eda14cbcSMatt Macy 		    real_props);
1226eda14cbcSMatt Macy 
1227eda14cbcSMatt Macy 		if (nvlist_lookup_string(props, zfs_prop_to_name(resv_prop),
1228eda14cbcSMatt Macy 		    &strval) != 0) {
1229eda14cbcSMatt Macy 			if (nvlist_add_uint64(props,
1230eda14cbcSMatt Macy 			    zfs_prop_to_name(resv_prop), volsize) != 0) {
1231eda14cbcSMatt Macy 				nvlist_free(props);
1232eda14cbcSMatt Macy 				nomem();
1233eda14cbcSMatt Macy 			}
1234eda14cbcSMatt Macy 		}
1235eda14cbcSMatt Macy 	}
1236eda14cbcSMatt Macy 	if (zpool_handle != NULL) {
1237eda14cbcSMatt Macy 		zpool_close(zpool_handle);
1238eda14cbcSMatt Macy 		nvlist_free(real_props);
1239eda14cbcSMatt Macy 	}
1240eda14cbcSMatt Macy 
1241eda14cbcSMatt Macy 	if (parents && zfs_name_valid(argv[0], type)) {
1242eda14cbcSMatt Macy 		/*
1243eda14cbcSMatt Macy 		 * Now create the ancestors of target dataset.  If the target
1244eda14cbcSMatt Macy 		 * already exists and '-p' option was used we should not
1245eda14cbcSMatt Macy 		 * complain.
1246eda14cbcSMatt Macy 		 */
1247eda14cbcSMatt Macy 		if (zfs_dataset_exists(g_zfs, argv[0], type)) {
1248eda14cbcSMatt Macy 			ret = 0;
1249eda14cbcSMatt Macy 			goto error;
1250eda14cbcSMatt Macy 		}
1251eda14cbcSMatt Macy 		if (verbose) {
1252eda14cbcSMatt Macy 			(void) printf(parseable ? "create_ancestors\t%s\n" :
1253eda14cbcSMatt Macy 			    dryrun ?  "would create ancestors of %s\n" :
1254eda14cbcSMatt Macy 			    "create ancestors of %s\n", argv[0]);
1255eda14cbcSMatt Macy 		}
1256eda14cbcSMatt Macy 		if (!dryrun) {
1257eda14cbcSMatt Macy 			if (zfs_create_ancestors(g_zfs, argv[0]) != 0) {
1258eda14cbcSMatt Macy 				goto error;
1259eda14cbcSMatt Macy 			}
1260eda14cbcSMatt Macy 		}
1261eda14cbcSMatt Macy 	}
1262eda14cbcSMatt Macy 
1263eda14cbcSMatt Macy 	if (verbose) {
1264eda14cbcSMatt Macy 		nvpair_t *nvp = NULL;
1265eda14cbcSMatt Macy 		(void) printf(parseable ? "create\t%s\n" :
1266eda14cbcSMatt Macy 		    dryrun ? "would create %s\n" : "create %s\n", argv[0]);
1267eda14cbcSMatt Macy 		while ((nvp = nvlist_next_nvpair(props, nvp)) != NULL) {
1268eda14cbcSMatt Macy 			uint64_t uval;
12692a58b312SMartin Matuska 			const char *sval;
1270eda14cbcSMatt Macy 
1271eda14cbcSMatt Macy 			switch (nvpair_type(nvp)) {
1272eda14cbcSMatt Macy 			case DATA_TYPE_UINT64:
1273eda14cbcSMatt Macy 				VERIFY0(nvpair_value_uint64(nvp, &uval));
1274eda14cbcSMatt Macy 				(void) printf(parseable ?
1275eda14cbcSMatt Macy 				    "property\t%s\t%llu\n" : "\t%s=%llu\n",
1276eda14cbcSMatt Macy 				    nvpair_name(nvp), (u_longlong_t)uval);
1277eda14cbcSMatt Macy 				break;
1278eda14cbcSMatt Macy 			case DATA_TYPE_STRING:
1279eda14cbcSMatt Macy 				VERIFY0(nvpair_value_string(nvp, &sval));
1280eda14cbcSMatt Macy 				(void) printf(parseable ?
1281eda14cbcSMatt Macy 				    "property\t%s\t%s\n" : "\t%s=%s\n",
1282eda14cbcSMatt Macy 				    nvpair_name(nvp), sval);
1283eda14cbcSMatt Macy 				break;
1284eda14cbcSMatt Macy 			default:
1285eda14cbcSMatt Macy 				(void) fprintf(stderr, "property '%s' "
1286eda14cbcSMatt Macy 				    "has illegal type %d\n",
1287eda14cbcSMatt Macy 				    nvpair_name(nvp), nvpair_type(nvp));
1288eda14cbcSMatt Macy 				abort();
1289eda14cbcSMatt Macy 			}
1290eda14cbcSMatt Macy 		}
1291eda14cbcSMatt Macy 	}
1292eda14cbcSMatt Macy 	if (dryrun) {
1293eda14cbcSMatt Macy 		ret = 0;
1294eda14cbcSMatt Macy 		goto error;
1295eda14cbcSMatt Macy 	}
1296eda14cbcSMatt Macy 
1297eda14cbcSMatt Macy 	/* pass to libzfs */
1298eda14cbcSMatt Macy 	if (zfs_create(g_zfs, argv[0], type, props) != 0)
1299eda14cbcSMatt Macy 		goto error;
1300eda14cbcSMatt Macy 
1301eda14cbcSMatt Macy 	if (log_history) {
1302eda14cbcSMatt Macy 		(void) zpool_log_history(g_zfs, history_str);
1303eda14cbcSMatt Macy 		log_history = B_FALSE;
1304eda14cbcSMatt Macy 	}
1305eda14cbcSMatt Macy 
13067877fdebSMatt Macy 	if (nomount) {
13077877fdebSMatt Macy 		ret = 0;
13087877fdebSMatt Macy 		goto error;
13097877fdebSMatt Macy 	}
13107877fdebSMatt Macy 
1311eda14cbcSMatt Macy 	ret = zfs_mount_and_share(g_zfs, argv[0], ZFS_TYPE_DATASET);
1312eda14cbcSMatt Macy error:
1313eda14cbcSMatt Macy 	nvlist_free(props);
1314eda14cbcSMatt Macy 	return (ret);
1315eda14cbcSMatt Macy badusage:
1316eda14cbcSMatt Macy 	nvlist_free(props);
1317eda14cbcSMatt Macy 	usage(B_FALSE);
1318eda14cbcSMatt Macy 	return (2);
1319eda14cbcSMatt Macy }
1320eda14cbcSMatt Macy 
1321eda14cbcSMatt Macy /*
1322eda14cbcSMatt Macy  * zfs destroy [-rRf] <fs, vol>
1323eda14cbcSMatt Macy  * zfs destroy [-rRd] <snap>
1324eda14cbcSMatt Macy  *
1325eda14cbcSMatt Macy  *	-r	Recursively destroy all children
1326eda14cbcSMatt Macy  *	-R	Recursively destroy all dependents, including clones
1327eda14cbcSMatt Macy  *	-f	Force unmounting of any dependents
1328eda14cbcSMatt Macy  *	-d	If we can't destroy now, mark for deferred destruction
1329eda14cbcSMatt Macy  *
1330eda14cbcSMatt Macy  * Destroys the given dataset.  By default, it will unmount any filesystems,
1331eda14cbcSMatt Macy  * and refuse to destroy a dataset that has any dependents.  A dependent can
1332eda14cbcSMatt Macy  * either be a child, or a clone of a child.
1333eda14cbcSMatt Macy  */
1334eda14cbcSMatt Macy typedef struct destroy_cbdata {
1335eda14cbcSMatt Macy 	boolean_t	cb_first;
1336eda14cbcSMatt Macy 	boolean_t	cb_force;
1337eda14cbcSMatt Macy 	boolean_t	cb_recurse;
1338eda14cbcSMatt Macy 	boolean_t	cb_error;
1339eda14cbcSMatt Macy 	boolean_t	cb_doclones;
1340eda14cbcSMatt Macy 	zfs_handle_t	*cb_target;
1341eda14cbcSMatt Macy 	boolean_t	cb_defer_destroy;
1342eda14cbcSMatt Macy 	boolean_t	cb_verbose;
1343eda14cbcSMatt Macy 	boolean_t	cb_parsable;
1344eda14cbcSMatt Macy 	boolean_t	cb_dryrun;
1345eda14cbcSMatt Macy 	nvlist_t	*cb_nvl;
1346eda14cbcSMatt Macy 	nvlist_t	*cb_batchedsnaps;
1347eda14cbcSMatt Macy 
1348eda14cbcSMatt Macy 	/* first snap in contiguous run */
1349eda14cbcSMatt Macy 	char		*cb_firstsnap;
1350eda14cbcSMatt Macy 	/* previous snap in contiguous run */
1351eda14cbcSMatt Macy 	char		*cb_prevsnap;
1352eda14cbcSMatt Macy 	int64_t		cb_snapused;
1353eda14cbcSMatt Macy 	char		*cb_snapspec;
1354eda14cbcSMatt Macy 	char		*cb_bookmark;
1355eda14cbcSMatt Macy 	uint64_t	cb_snap_count;
1356eda14cbcSMatt Macy } destroy_cbdata_t;
1357eda14cbcSMatt Macy 
1358eda14cbcSMatt Macy /*
1359eda14cbcSMatt Macy  * Check for any dependents based on the '-r' or '-R' flags.
1360eda14cbcSMatt Macy  */
1361eda14cbcSMatt Macy static int
1362eda14cbcSMatt Macy destroy_check_dependent(zfs_handle_t *zhp, void *data)
1363eda14cbcSMatt Macy {
1364eda14cbcSMatt Macy 	destroy_cbdata_t *cbp = data;
1365eda14cbcSMatt Macy 	const char *tname = zfs_get_name(cbp->cb_target);
1366eda14cbcSMatt Macy 	const char *name = zfs_get_name(zhp);
1367eda14cbcSMatt Macy 
1368eda14cbcSMatt Macy 	if (strncmp(tname, name, strlen(tname)) == 0 &&
1369eda14cbcSMatt Macy 	    (name[strlen(tname)] == '/' || name[strlen(tname)] == '@')) {
1370eda14cbcSMatt Macy 		/*
1371eda14cbcSMatt Macy 		 * This is a direct descendant, not a clone somewhere else in
1372eda14cbcSMatt Macy 		 * the hierarchy.
1373eda14cbcSMatt Macy 		 */
1374eda14cbcSMatt Macy 		if (cbp->cb_recurse)
1375eda14cbcSMatt Macy 			goto out;
1376eda14cbcSMatt Macy 
1377eda14cbcSMatt Macy 		if (cbp->cb_first) {
1378eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("cannot destroy '%s': "
1379eda14cbcSMatt Macy 			    "%s has children\n"),
1380eda14cbcSMatt Macy 			    zfs_get_name(cbp->cb_target),
1381eda14cbcSMatt Macy 			    zfs_type_to_name(zfs_get_type(cbp->cb_target)));
1382eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("use '-r' to destroy "
1383eda14cbcSMatt Macy 			    "the following datasets:\n"));
1384eda14cbcSMatt Macy 			cbp->cb_first = B_FALSE;
1385eda14cbcSMatt Macy 			cbp->cb_error = B_TRUE;
1386eda14cbcSMatt Macy 		}
1387eda14cbcSMatt Macy 
1388eda14cbcSMatt Macy 		(void) fprintf(stderr, "%s\n", zfs_get_name(zhp));
1389eda14cbcSMatt Macy 	} else {
1390eda14cbcSMatt Macy 		/*
1391eda14cbcSMatt Macy 		 * This is a clone.  We only want to report this if the '-r'
1392eda14cbcSMatt Macy 		 * wasn't specified, or the target is a snapshot.
1393eda14cbcSMatt Macy 		 */
1394eda14cbcSMatt Macy 		if (!cbp->cb_recurse &&
1395eda14cbcSMatt Macy 		    zfs_get_type(cbp->cb_target) != ZFS_TYPE_SNAPSHOT)
1396eda14cbcSMatt Macy 			goto out;
1397eda14cbcSMatt Macy 
1398eda14cbcSMatt Macy 		if (cbp->cb_first) {
1399eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("cannot destroy '%s': "
1400eda14cbcSMatt Macy 			    "%s has dependent clones\n"),
1401eda14cbcSMatt Macy 			    zfs_get_name(cbp->cb_target),
1402eda14cbcSMatt Macy 			    zfs_type_to_name(zfs_get_type(cbp->cb_target)));
1403eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("use '-R' to destroy "
1404eda14cbcSMatt Macy 			    "the following datasets:\n"));
1405eda14cbcSMatt Macy 			cbp->cb_first = B_FALSE;
1406eda14cbcSMatt Macy 			cbp->cb_error = B_TRUE;
1407eda14cbcSMatt Macy 			cbp->cb_dryrun = B_TRUE;
1408eda14cbcSMatt Macy 		}
1409eda14cbcSMatt Macy 
1410eda14cbcSMatt Macy 		(void) fprintf(stderr, "%s\n", zfs_get_name(zhp));
1411eda14cbcSMatt Macy 	}
1412eda14cbcSMatt Macy 
1413eda14cbcSMatt Macy out:
1414eda14cbcSMatt Macy 	zfs_close(zhp);
1415eda14cbcSMatt Macy 	return (0);
1416eda14cbcSMatt Macy }
1417eda14cbcSMatt Macy 
1418eda14cbcSMatt Macy static int
1419eda14cbcSMatt Macy destroy_batched(destroy_cbdata_t *cb)
1420eda14cbcSMatt Macy {
1421eda14cbcSMatt Macy 	int error = zfs_destroy_snaps_nvl(g_zfs,
1422eda14cbcSMatt Macy 	    cb->cb_batchedsnaps, B_FALSE);
1423eda14cbcSMatt Macy 	fnvlist_free(cb->cb_batchedsnaps);
1424eda14cbcSMatt Macy 	cb->cb_batchedsnaps = fnvlist_alloc();
1425eda14cbcSMatt Macy 	return (error);
1426eda14cbcSMatt Macy }
1427eda14cbcSMatt Macy 
1428eda14cbcSMatt Macy static int
1429eda14cbcSMatt Macy destroy_callback(zfs_handle_t *zhp, void *data)
1430eda14cbcSMatt Macy {
1431eda14cbcSMatt Macy 	destroy_cbdata_t *cb = data;
1432eda14cbcSMatt Macy 	const char *name = zfs_get_name(zhp);
1433eda14cbcSMatt Macy 	int error;
1434eda14cbcSMatt Macy 
1435eda14cbcSMatt Macy 	if (cb->cb_verbose) {
1436eda14cbcSMatt Macy 		if (cb->cb_parsable) {
1437eda14cbcSMatt Macy 			(void) printf("destroy\t%s\n", name);
1438eda14cbcSMatt Macy 		} else if (cb->cb_dryrun) {
1439eda14cbcSMatt Macy 			(void) printf(gettext("would destroy %s\n"),
1440eda14cbcSMatt Macy 			    name);
1441eda14cbcSMatt Macy 		} else {
1442eda14cbcSMatt Macy 			(void) printf(gettext("will destroy %s\n"),
1443eda14cbcSMatt Macy 			    name);
1444eda14cbcSMatt Macy 		}
1445eda14cbcSMatt Macy 	}
1446eda14cbcSMatt Macy 
1447eda14cbcSMatt Macy 	/*
1448eda14cbcSMatt Macy 	 * Ignore pools (which we've already flagged as an error before getting
1449eda14cbcSMatt Macy 	 * here).
1450eda14cbcSMatt Macy 	 */
1451eda14cbcSMatt Macy 	if (strchr(zfs_get_name(zhp), '/') == NULL &&
1452eda14cbcSMatt Macy 	    zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM) {
1453eda14cbcSMatt Macy 		zfs_close(zhp);
1454eda14cbcSMatt Macy 		return (0);
1455eda14cbcSMatt Macy 	}
1456eda14cbcSMatt Macy 	if (cb->cb_dryrun) {
1457eda14cbcSMatt Macy 		zfs_close(zhp);
1458eda14cbcSMatt Macy 		return (0);
1459eda14cbcSMatt Macy 	}
1460eda14cbcSMatt Macy 
1461eda14cbcSMatt Macy 	/*
1462eda14cbcSMatt Macy 	 * We batch up all contiguous snapshots (even of different
1463eda14cbcSMatt Macy 	 * filesystems) and destroy them with one ioctl.  We can't
1464eda14cbcSMatt Macy 	 * simply do all snap deletions and then all fs deletions,
1465eda14cbcSMatt Macy 	 * because we must delete a clone before its origin.
1466eda14cbcSMatt Macy 	 */
1467eda14cbcSMatt Macy 	if (zfs_get_type(zhp) == ZFS_TYPE_SNAPSHOT) {
1468eda14cbcSMatt Macy 		cb->cb_snap_count++;
1469eda14cbcSMatt Macy 		fnvlist_add_boolean(cb->cb_batchedsnaps, name);
1470dbd5678dSMartin Matuska 		if (cb->cb_snap_count % 10 == 0 && cb->cb_defer_destroy) {
1471eda14cbcSMatt Macy 			error = destroy_batched(cb);
1472dbd5678dSMartin Matuska 			if (error != 0) {
1473dbd5678dSMartin Matuska 				zfs_close(zhp);
1474dbd5678dSMartin Matuska 				return (-1);
1475dbd5678dSMartin Matuska 			}
1476dbd5678dSMartin Matuska 		}
1477eda14cbcSMatt Macy 	} else {
1478eda14cbcSMatt Macy 		error = destroy_batched(cb);
1479eda14cbcSMatt Macy 		if (error != 0 ||
1480eda14cbcSMatt Macy 		    zfs_unmount(zhp, NULL, cb->cb_force ? MS_FORCE : 0) != 0 ||
1481eda14cbcSMatt Macy 		    zfs_destroy(zhp, cb->cb_defer_destroy) != 0) {
1482eda14cbcSMatt Macy 			zfs_close(zhp);
1483eda14cbcSMatt Macy 			/*
1484eda14cbcSMatt Macy 			 * When performing a recursive destroy we ignore errors
1485eda14cbcSMatt Macy 			 * so that the recursive destroy could continue
1486eda14cbcSMatt Macy 			 * destroying past problem datasets
1487eda14cbcSMatt Macy 			 */
1488eda14cbcSMatt Macy 			if (cb->cb_recurse) {
1489eda14cbcSMatt Macy 				cb->cb_error = B_TRUE;
1490eda14cbcSMatt Macy 				return (0);
1491eda14cbcSMatt Macy 			}
1492eda14cbcSMatt Macy 			return (-1);
1493eda14cbcSMatt Macy 		}
1494eda14cbcSMatt Macy 	}
1495eda14cbcSMatt Macy 
1496eda14cbcSMatt Macy 	zfs_close(zhp);
1497eda14cbcSMatt Macy 	return (0);
1498eda14cbcSMatt Macy }
1499eda14cbcSMatt Macy 
1500eda14cbcSMatt Macy static int
1501eda14cbcSMatt Macy destroy_print_cb(zfs_handle_t *zhp, void *arg)
1502eda14cbcSMatt Macy {
1503eda14cbcSMatt Macy 	destroy_cbdata_t *cb = arg;
1504eda14cbcSMatt Macy 	const char *name = zfs_get_name(zhp);
1505eda14cbcSMatt Macy 	int err = 0;
1506eda14cbcSMatt Macy 
1507eda14cbcSMatt Macy 	if (nvlist_exists(cb->cb_nvl, name)) {
1508eda14cbcSMatt Macy 		if (cb->cb_firstsnap == NULL)
1509eda14cbcSMatt Macy 			cb->cb_firstsnap = strdup(name);
1510eda14cbcSMatt Macy 		if (cb->cb_prevsnap != NULL)
1511eda14cbcSMatt Macy 			free(cb->cb_prevsnap);
1512eda14cbcSMatt Macy 		/* this snap continues the current range */
1513eda14cbcSMatt Macy 		cb->cb_prevsnap = strdup(name);
1514eda14cbcSMatt Macy 		if (cb->cb_firstsnap == NULL || cb->cb_prevsnap == NULL)
1515eda14cbcSMatt Macy 			nomem();
1516eda14cbcSMatt Macy 		if (cb->cb_verbose) {
1517eda14cbcSMatt Macy 			if (cb->cb_parsable) {
1518eda14cbcSMatt Macy 				(void) printf("destroy\t%s\n", name);
1519eda14cbcSMatt Macy 			} else if (cb->cb_dryrun) {
1520eda14cbcSMatt Macy 				(void) printf(gettext("would destroy %s\n"),
1521eda14cbcSMatt Macy 				    name);
1522eda14cbcSMatt Macy 			} else {
1523eda14cbcSMatt Macy 				(void) printf(gettext("will destroy %s\n"),
1524eda14cbcSMatt Macy 				    name);
1525eda14cbcSMatt Macy 			}
1526eda14cbcSMatt Macy 		}
1527eda14cbcSMatt Macy 	} else if (cb->cb_firstsnap != NULL) {
1528eda14cbcSMatt Macy 		/* end of this range */
1529eda14cbcSMatt Macy 		uint64_t used = 0;
1530eda14cbcSMatt Macy 		err = lzc_snaprange_space(cb->cb_firstsnap,
1531eda14cbcSMatt Macy 		    cb->cb_prevsnap, &used);
1532eda14cbcSMatt Macy 		cb->cb_snapused += used;
1533eda14cbcSMatt Macy 		free(cb->cb_firstsnap);
1534eda14cbcSMatt Macy 		cb->cb_firstsnap = NULL;
1535eda14cbcSMatt Macy 		free(cb->cb_prevsnap);
1536eda14cbcSMatt Macy 		cb->cb_prevsnap = NULL;
1537eda14cbcSMatt Macy 	}
1538eda14cbcSMatt Macy 	zfs_close(zhp);
1539eda14cbcSMatt Macy 	return (err);
1540eda14cbcSMatt Macy }
1541eda14cbcSMatt Macy 
1542eda14cbcSMatt Macy static int
1543eda14cbcSMatt Macy destroy_print_snapshots(zfs_handle_t *fs_zhp, destroy_cbdata_t *cb)
1544eda14cbcSMatt Macy {
1545eda14cbcSMatt Macy 	int err;
1546eda14cbcSMatt Macy 	assert(cb->cb_firstsnap == NULL);
1547eda14cbcSMatt Macy 	assert(cb->cb_prevsnap == NULL);
1548d411c1d6SMartin Matuska 	err = zfs_iter_snapshots_sorted_v2(fs_zhp, 0, destroy_print_cb, cb, 0,
1549d411c1d6SMartin Matuska 	    0);
1550eda14cbcSMatt Macy 	if (cb->cb_firstsnap != NULL) {
1551eda14cbcSMatt Macy 		uint64_t used = 0;
1552eda14cbcSMatt Macy 		if (err == 0) {
1553eda14cbcSMatt Macy 			err = lzc_snaprange_space(cb->cb_firstsnap,
1554eda14cbcSMatt Macy 			    cb->cb_prevsnap, &used);
1555eda14cbcSMatt Macy 		}
1556eda14cbcSMatt Macy 		cb->cb_snapused += used;
1557eda14cbcSMatt Macy 		free(cb->cb_firstsnap);
1558eda14cbcSMatt Macy 		cb->cb_firstsnap = NULL;
1559eda14cbcSMatt Macy 		free(cb->cb_prevsnap);
1560eda14cbcSMatt Macy 		cb->cb_prevsnap = NULL;
1561eda14cbcSMatt Macy 	}
1562eda14cbcSMatt Macy 	return (err);
1563eda14cbcSMatt Macy }
1564eda14cbcSMatt Macy 
1565eda14cbcSMatt Macy static int
1566eda14cbcSMatt Macy snapshot_to_nvl_cb(zfs_handle_t *zhp, void *arg)
1567eda14cbcSMatt Macy {
1568eda14cbcSMatt Macy 	destroy_cbdata_t *cb = arg;
1569eda14cbcSMatt Macy 	int err = 0;
1570eda14cbcSMatt Macy 
1571eda14cbcSMatt Macy 	/* Check for clones. */
1572eda14cbcSMatt Macy 	if (!cb->cb_doclones && !cb->cb_defer_destroy) {
1573eda14cbcSMatt Macy 		cb->cb_target = zhp;
1574eda14cbcSMatt Macy 		cb->cb_first = B_TRUE;
1575d411c1d6SMartin Matuska 		err = zfs_iter_dependents_v2(zhp, 0, B_TRUE,
1576eda14cbcSMatt Macy 		    destroy_check_dependent, cb);
1577eda14cbcSMatt Macy 	}
1578eda14cbcSMatt Macy 
1579eda14cbcSMatt Macy 	if (err == 0) {
1580eda14cbcSMatt Macy 		if (nvlist_add_boolean(cb->cb_nvl, zfs_get_name(zhp)))
1581eda14cbcSMatt Macy 			nomem();
1582eda14cbcSMatt Macy 	}
1583eda14cbcSMatt Macy 	zfs_close(zhp);
1584eda14cbcSMatt Macy 	return (err);
1585eda14cbcSMatt Macy }
1586eda14cbcSMatt Macy 
1587eda14cbcSMatt Macy static int
1588eda14cbcSMatt Macy gather_snapshots(zfs_handle_t *zhp, void *arg)
1589eda14cbcSMatt Macy {
1590eda14cbcSMatt Macy 	destroy_cbdata_t *cb = arg;
1591eda14cbcSMatt Macy 	int err = 0;
1592eda14cbcSMatt Macy 
1593d411c1d6SMartin Matuska 	err = zfs_iter_snapspec_v2(zhp, 0, cb->cb_snapspec,
159415f0b8c3SMartin Matuska 	    snapshot_to_nvl_cb, cb);
1595eda14cbcSMatt Macy 	if (err == ENOENT)
1596eda14cbcSMatt Macy 		err = 0;
1597eda14cbcSMatt Macy 	if (err != 0)
1598eda14cbcSMatt Macy 		goto out;
1599eda14cbcSMatt Macy 
1600eda14cbcSMatt Macy 	if (cb->cb_verbose) {
1601eda14cbcSMatt Macy 		err = destroy_print_snapshots(zhp, cb);
1602eda14cbcSMatt Macy 		if (err != 0)
1603eda14cbcSMatt Macy 			goto out;
1604eda14cbcSMatt Macy 	}
1605eda14cbcSMatt Macy 
1606eda14cbcSMatt Macy 	if (cb->cb_recurse)
1607d411c1d6SMartin Matuska 		err = zfs_iter_filesystems_v2(zhp, 0, gather_snapshots, cb);
1608eda14cbcSMatt Macy 
1609eda14cbcSMatt Macy out:
1610eda14cbcSMatt Macy 	zfs_close(zhp);
1611eda14cbcSMatt Macy 	return (err);
1612eda14cbcSMatt Macy }
1613eda14cbcSMatt Macy 
1614eda14cbcSMatt Macy static int
1615eda14cbcSMatt Macy destroy_clones(destroy_cbdata_t *cb)
1616eda14cbcSMatt Macy {
1617eda14cbcSMatt Macy 	nvpair_t *pair;
1618eda14cbcSMatt Macy 	for (pair = nvlist_next_nvpair(cb->cb_nvl, NULL);
1619eda14cbcSMatt Macy 	    pair != NULL;
1620eda14cbcSMatt Macy 	    pair = nvlist_next_nvpair(cb->cb_nvl, pair)) {
1621eda14cbcSMatt Macy 		zfs_handle_t *zhp = zfs_open(g_zfs, nvpair_name(pair),
1622eda14cbcSMatt Macy 		    ZFS_TYPE_SNAPSHOT);
1623eda14cbcSMatt Macy 		if (zhp != NULL) {
1624eda14cbcSMatt Macy 			boolean_t defer = cb->cb_defer_destroy;
1625eda14cbcSMatt Macy 			int err;
1626eda14cbcSMatt Macy 
1627eda14cbcSMatt Macy 			/*
1628eda14cbcSMatt Macy 			 * We can't defer destroy non-snapshots, so set it to
1629eda14cbcSMatt Macy 			 * false while destroying the clones.
1630eda14cbcSMatt Macy 			 */
1631eda14cbcSMatt Macy 			cb->cb_defer_destroy = B_FALSE;
1632d411c1d6SMartin Matuska 			err = zfs_iter_dependents_v2(zhp, 0, B_FALSE,
1633eda14cbcSMatt Macy 			    destroy_callback, cb);
1634eda14cbcSMatt Macy 			cb->cb_defer_destroy = defer;
1635eda14cbcSMatt Macy 			zfs_close(zhp);
1636eda14cbcSMatt Macy 			if (err != 0)
1637eda14cbcSMatt Macy 				return (err);
1638eda14cbcSMatt Macy 		}
1639eda14cbcSMatt Macy 	}
1640eda14cbcSMatt Macy 	return (0);
1641eda14cbcSMatt Macy }
1642eda14cbcSMatt Macy 
1643eda14cbcSMatt Macy static int
1644eda14cbcSMatt Macy zfs_do_destroy(int argc, char **argv)
1645eda14cbcSMatt Macy {
1646eda14cbcSMatt Macy 	destroy_cbdata_t cb = { 0 };
1647eda14cbcSMatt Macy 	int rv = 0;
1648eda14cbcSMatt Macy 	int err = 0;
1649eda14cbcSMatt Macy 	int c;
1650eda14cbcSMatt Macy 	zfs_handle_t *zhp = NULL;
1651eda14cbcSMatt Macy 	char *at, *pound;
1652eda14cbcSMatt Macy 	zfs_type_t type = ZFS_TYPE_DATASET;
1653eda14cbcSMatt Macy 
1654eda14cbcSMatt Macy 	/* check options */
1655eda14cbcSMatt Macy 	while ((c = getopt(argc, argv, "vpndfrR")) != -1) {
1656eda14cbcSMatt Macy 		switch (c) {
1657eda14cbcSMatt Macy 		case 'v':
1658eda14cbcSMatt Macy 			cb.cb_verbose = B_TRUE;
1659eda14cbcSMatt Macy 			break;
1660eda14cbcSMatt Macy 		case 'p':
1661eda14cbcSMatt Macy 			cb.cb_verbose = B_TRUE;
1662eda14cbcSMatt Macy 			cb.cb_parsable = B_TRUE;
1663eda14cbcSMatt Macy 			break;
1664eda14cbcSMatt Macy 		case 'n':
1665eda14cbcSMatt Macy 			cb.cb_dryrun = B_TRUE;
1666eda14cbcSMatt Macy 			break;
1667eda14cbcSMatt Macy 		case 'd':
1668eda14cbcSMatt Macy 			cb.cb_defer_destroy = B_TRUE;
1669eda14cbcSMatt Macy 			type = ZFS_TYPE_SNAPSHOT;
1670eda14cbcSMatt Macy 			break;
1671eda14cbcSMatt Macy 		case 'f':
1672eda14cbcSMatt Macy 			cb.cb_force = B_TRUE;
1673eda14cbcSMatt Macy 			break;
1674eda14cbcSMatt Macy 		case 'r':
1675eda14cbcSMatt Macy 			cb.cb_recurse = B_TRUE;
1676eda14cbcSMatt Macy 			break;
1677eda14cbcSMatt Macy 		case 'R':
1678eda14cbcSMatt Macy 			cb.cb_recurse = B_TRUE;
1679eda14cbcSMatt Macy 			cb.cb_doclones = B_TRUE;
1680eda14cbcSMatt Macy 			break;
1681eda14cbcSMatt Macy 		case '?':
1682eda14cbcSMatt Macy 		default:
1683eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
1684eda14cbcSMatt Macy 			    optopt);
1685eda14cbcSMatt Macy 			usage(B_FALSE);
1686eda14cbcSMatt Macy 		}
1687eda14cbcSMatt Macy 	}
1688eda14cbcSMatt Macy 
1689eda14cbcSMatt Macy 	argc -= optind;
1690eda14cbcSMatt Macy 	argv += optind;
1691eda14cbcSMatt Macy 
1692eda14cbcSMatt Macy 	/* check number of arguments */
1693eda14cbcSMatt Macy 	if (argc == 0) {
1694eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("missing dataset argument\n"));
1695eda14cbcSMatt Macy 		usage(B_FALSE);
1696eda14cbcSMatt Macy 	}
1697eda14cbcSMatt Macy 	if (argc > 1) {
1698eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("too many arguments\n"));
1699eda14cbcSMatt Macy 		usage(B_FALSE);
1700eda14cbcSMatt Macy 	}
1701eda14cbcSMatt Macy 
1702eda14cbcSMatt Macy 	at = strchr(argv[0], '@');
1703eda14cbcSMatt Macy 	pound = strchr(argv[0], '#');
1704eda14cbcSMatt Macy 	if (at != NULL) {
1705eda14cbcSMatt Macy 
1706eda14cbcSMatt Macy 		/* Build the list of snaps to destroy in cb_nvl. */
1707eda14cbcSMatt Macy 		cb.cb_nvl = fnvlist_alloc();
1708eda14cbcSMatt Macy 
1709eda14cbcSMatt Macy 		*at = '\0';
1710eda14cbcSMatt Macy 		zhp = zfs_open(g_zfs, argv[0],
1711eda14cbcSMatt Macy 		    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
1712eda14cbcSMatt Macy 		if (zhp == NULL) {
1713eda14cbcSMatt Macy 			nvlist_free(cb.cb_nvl);
1714eda14cbcSMatt Macy 			return (1);
1715eda14cbcSMatt Macy 		}
1716eda14cbcSMatt Macy 
1717eda14cbcSMatt Macy 		cb.cb_snapspec = at + 1;
1718eda14cbcSMatt Macy 		if (gather_snapshots(zfs_handle_dup(zhp), &cb) != 0 ||
1719eda14cbcSMatt Macy 		    cb.cb_error) {
1720eda14cbcSMatt Macy 			rv = 1;
1721eda14cbcSMatt Macy 			goto out;
1722eda14cbcSMatt Macy 		}
1723eda14cbcSMatt Macy 
1724eda14cbcSMatt Macy 		if (nvlist_empty(cb.cb_nvl)) {
1725eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("could not find any "
1726eda14cbcSMatt Macy 			    "snapshots to destroy; check snapshot names.\n"));
1727eda14cbcSMatt Macy 			rv = 1;
1728eda14cbcSMatt Macy 			goto out;
1729eda14cbcSMatt Macy 		}
1730eda14cbcSMatt Macy 
1731eda14cbcSMatt Macy 		if (cb.cb_verbose) {
1732eda14cbcSMatt Macy 			char buf[16];
1733eda14cbcSMatt Macy 			zfs_nicebytes(cb.cb_snapused, buf, sizeof (buf));
1734eda14cbcSMatt Macy 			if (cb.cb_parsable) {
1735eda14cbcSMatt Macy 				(void) printf("reclaim\t%llu\n",
1736eda14cbcSMatt Macy 				    (u_longlong_t)cb.cb_snapused);
1737eda14cbcSMatt Macy 			} else if (cb.cb_dryrun) {
1738eda14cbcSMatt Macy 				(void) printf(gettext("would reclaim %s\n"),
1739eda14cbcSMatt Macy 				    buf);
1740eda14cbcSMatt Macy 			} else {
1741eda14cbcSMatt Macy 				(void) printf(gettext("will reclaim %s\n"),
1742eda14cbcSMatt Macy 				    buf);
1743eda14cbcSMatt Macy 			}
1744eda14cbcSMatt Macy 		}
1745eda14cbcSMatt Macy 
1746eda14cbcSMatt Macy 		if (!cb.cb_dryrun) {
1747eda14cbcSMatt Macy 			if (cb.cb_doclones) {
1748eda14cbcSMatt Macy 				cb.cb_batchedsnaps = fnvlist_alloc();
1749eda14cbcSMatt Macy 				err = destroy_clones(&cb);
1750eda14cbcSMatt Macy 				if (err == 0) {
1751eda14cbcSMatt Macy 					err = zfs_destroy_snaps_nvl(g_zfs,
1752eda14cbcSMatt Macy 					    cb.cb_batchedsnaps, B_FALSE);
1753eda14cbcSMatt Macy 				}
1754eda14cbcSMatt Macy 				if (err != 0) {
1755eda14cbcSMatt Macy 					rv = 1;
1756eda14cbcSMatt Macy 					goto out;
1757eda14cbcSMatt Macy 				}
1758eda14cbcSMatt Macy 			}
1759eda14cbcSMatt Macy 			if (err == 0) {
1760eda14cbcSMatt Macy 				err = zfs_destroy_snaps_nvl(g_zfs, cb.cb_nvl,
1761eda14cbcSMatt Macy 				    cb.cb_defer_destroy);
1762eda14cbcSMatt Macy 			}
1763eda14cbcSMatt Macy 		}
1764eda14cbcSMatt Macy 
1765eda14cbcSMatt Macy 		if (err != 0)
1766eda14cbcSMatt Macy 			rv = 1;
1767eda14cbcSMatt Macy 	} else if (pound != NULL) {
1768eda14cbcSMatt Macy 		int err;
1769eda14cbcSMatt Macy 		nvlist_t *nvl;
1770eda14cbcSMatt Macy 
1771eda14cbcSMatt Macy 		if (cb.cb_dryrun) {
1772eda14cbcSMatt Macy 			(void) fprintf(stderr,
1773eda14cbcSMatt Macy 			    "dryrun is not supported with bookmark\n");
1774eda14cbcSMatt Macy 			return (-1);
1775eda14cbcSMatt Macy 		}
1776eda14cbcSMatt Macy 
1777eda14cbcSMatt Macy 		if (cb.cb_defer_destroy) {
1778eda14cbcSMatt Macy 			(void) fprintf(stderr,
1779eda14cbcSMatt Macy 			    "defer destroy is not supported with bookmark\n");
1780eda14cbcSMatt Macy 			return (-1);
1781eda14cbcSMatt Macy 		}
1782eda14cbcSMatt Macy 
1783eda14cbcSMatt Macy 		if (cb.cb_recurse) {
1784eda14cbcSMatt Macy 			(void) fprintf(stderr,
1785eda14cbcSMatt Macy 			    "recursive is not supported with bookmark\n");
1786eda14cbcSMatt Macy 			return (-1);
1787eda14cbcSMatt Macy 		}
1788eda14cbcSMatt Macy 
1789eda14cbcSMatt Macy 		/*
1790eda14cbcSMatt Macy 		 * Unfortunately, zfs_bookmark() doesn't honor the
1791eda14cbcSMatt Macy 		 * casesensitivity setting.  However, we can't simply
1792eda14cbcSMatt Macy 		 * remove this check, because lzc_destroy_bookmarks()
1793eda14cbcSMatt Macy 		 * ignores non-existent bookmarks, so this is necessary
1794eda14cbcSMatt Macy 		 * to get a proper error message.
1795eda14cbcSMatt Macy 		 */
1796eda14cbcSMatt Macy 		if (!zfs_bookmark_exists(argv[0])) {
1797eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("bookmark '%s' "
1798eda14cbcSMatt Macy 			    "does not exist.\n"), argv[0]);
1799eda14cbcSMatt Macy 			return (1);
1800eda14cbcSMatt Macy 		}
1801eda14cbcSMatt Macy 
1802eda14cbcSMatt Macy 		nvl = fnvlist_alloc();
1803eda14cbcSMatt Macy 		fnvlist_add_boolean(nvl, argv[0]);
1804eda14cbcSMatt Macy 
1805eda14cbcSMatt Macy 		err = lzc_destroy_bookmarks(nvl, NULL);
1806eda14cbcSMatt Macy 		if (err != 0) {
1807eda14cbcSMatt Macy 			(void) zfs_standard_error(g_zfs, err,
1808eda14cbcSMatt Macy 			    "cannot destroy bookmark");
1809eda14cbcSMatt Macy 		}
1810eda14cbcSMatt Macy 
1811eda14cbcSMatt Macy 		nvlist_free(nvl);
1812eda14cbcSMatt Macy 
1813eda14cbcSMatt Macy 		return (err);
1814eda14cbcSMatt Macy 	} else {
1815eda14cbcSMatt Macy 		/* Open the given dataset */
1816eda14cbcSMatt Macy 		if ((zhp = zfs_open(g_zfs, argv[0], type)) == NULL)
1817eda14cbcSMatt Macy 			return (1);
1818eda14cbcSMatt Macy 
1819eda14cbcSMatt Macy 		cb.cb_target = zhp;
1820eda14cbcSMatt Macy 
1821eda14cbcSMatt Macy 		/*
1822eda14cbcSMatt Macy 		 * Perform an explicit check for pools before going any further.
1823eda14cbcSMatt Macy 		 */
1824eda14cbcSMatt Macy 		if (!cb.cb_recurse && strchr(zfs_get_name(zhp), '/') == NULL &&
1825eda14cbcSMatt Macy 		    zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM) {
1826eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("cannot destroy '%s': "
1827eda14cbcSMatt Macy 			    "operation does not apply to pools\n"),
1828eda14cbcSMatt Macy 			    zfs_get_name(zhp));
1829eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("use 'zfs destroy -r "
1830eda14cbcSMatt Macy 			    "%s' to destroy all datasets in the pool\n"),
1831eda14cbcSMatt Macy 			    zfs_get_name(zhp));
1832eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("use 'zpool destroy %s' "
1833eda14cbcSMatt Macy 			    "to destroy the pool itself\n"), zfs_get_name(zhp));
1834eda14cbcSMatt Macy 			rv = 1;
1835eda14cbcSMatt Macy 			goto out;
1836eda14cbcSMatt Macy 		}
1837eda14cbcSMatt Macy 
1838eda14cbcSMatt Macy 		/*
1839eda14cbcSMatt Macy 		 * Check for any dependents and/or clones.
1840eda14cbcSMatt Macy 		 */
1841eda14cbcSMatt Macy 		cb.cb_first = B_TRUE;
1842d411c1d6SMartin Matuska 		if (!cb.cb_doclones && zfs_iter_dependents_v2(zhp, 0, B_TRUE,
1843d411c1d6SMartin Matuska 		    destroy_check_dependent, &cb) != 0) {
1844eda14cbcSMatt Macy 			rv = 1;
1845eda14cbcSMatt Macy 			goto out;
1846eda14cbcSMatt Macy 		}
1847eda14cbcSMatt Macy 
1848eda14cbcSMatt Macy 		if (cb.cb_error) {
1849eda14cbcSMatt Macy 			rv = 1;
1850eda14cbcSMatt Macy 			goto out;
1851eda14cbcSMatt Macy 		}
1852eda14cbcSMatt Macy 		cb.cb_batchedsnaps = fnvlist_alloc();
1853d411c1d6SMartin Matuska 		if (zfs_iter_dependents_v2(zhp, 0, B_FALSE, destroy_callback,
1854eda14cbcSMatt Macy 		    &cb) != 0) {
1855eda14cbcSMatt Macy 			rv = 1;
1856eda14cbcSMatt Macy 			goto out;
1857eda14cbcSMatt Macy 		}
1858eda14cbcSMatt Macy 
1859eda14cbcSMatt Macy 		/*
1860eda14cbcSMatt Macy 		 * Do the real thing.  The callback will close the
1861eda14cbcSMatt Macy 		 * handle regardless of whether it succeeds or not.
1862eda14cbcSMatt Macy 		 */
1863eda14cbcSMatt Macy 		err = destroy_callback(zhp, &cb);
1864eda14cbcSMatt Macy 		zhp = NULL;
1865eda14cbcSMatt Macy 		if (err == 0) {
1866eda14cbcSMatt Macy 			err = zfs_destroy_snaps_nvl(g_zfs,
1867eda14cbcSMatt Macy 			    cb.cb_batchedsnaps, cb.cb_defer_destroy);
1868eda14cbcSMatt Macy 		}
1869eda14cbcSMatt Macy 		if (err != 0 || cb.cb_error == B_TRUE)
1870eda14cbcSMatt Macy 			rv = 1;
1871eda14cbcSMatt Macy 	}
1872eda14cbcSMatt Macy 
1873eda14cbcSMatt Macy out:
1874eda14cbcSMatt Macy 	fnvlist_free(cb.cb_batchedsnaps);
1875eda14cbcSMatt Macy 	fnvlist_free(cb.cb_nvl);
1876eda14cbcSMatt Macy 	if (zhp != NULL)
1877eda14cbcSMatt Macy 		zfs_close(zhp);
1878eda14cbcSMatt Macy 	return (rv);
1879eda14cbcSMatt Macy }
1880eda14cbcSMatt Macy 
1881eda14cbcSMatt Macy static boolean_t
1882eda14cbcSMatt Macy is_recvd_column(zprop_get_cbdata_t *cbp)
1883eda14cbcSMatt Macy {
1884eda14cbcSMatt Macy 	int i;
1885eda14cbcSMatt Macy 	zfs_get_column_t col;
1886eda14cbcSMatt Macy 
1887eda14cbcSMatt Macy 	for (i = 0; i < ZFS_GET_NCOLS &&
1888eda14cbcSMatt Macy 	    (col = cbp->cb_columns[i]) != GET_COL_NONE; i++)
1889eda14cbcSMatt Macy 		if (col == GET_COL_RECVD)
1890eda14cbcSMatt Macy 			return (B_TRUE);
1891eda14cbcSMatt Macy 	return (B_FALSE);
1892eda14cbcSMatt Macy }
1893eda14cbcSMatt Macy 
1894eda14cbcSMatt Macy /*
1895*ce4dcb97SMartin Matuska  * Generates an nvlist with output version for every command based on params.
1896*ce4dcb97SMartin Matuska  * Purpose of this is to add a version of JSON output, considering the schema
1897*ce4dcb97SMartin Matuska  * format might be updated for each command in future.
1898*ce4dcb97SMartin Matuska  *
1899*ce4dcb97SMartin Matuska  * Schema:
1900*ce4dcb97SMartin Matuska  *
1901*ce4dcb97SMartin Matuska  * "output_version": {
1902*ce4dcb97SMartin Matuska  *    "command": string,
1903*ce4dcb97SMartin Matuska  *    "vers_major": integer,
1904*ce4dcb97SMartin Matuska  *    "vers_minor": integer,
1905*ce4dcb97SMartin Matuska  *  }
1906*ce4dcb97SMartin Matuska  */
1907*ce4dcb97SMartin Matuska static nvlist_t *
1908*ce4dcb97SMartin Matuska zfs_json_schema(int maj_v, int min_v)
1909*ce4dcb97SMartin Matuska {
1910*ce4dcb97SMartin Matuska 	nvlist_t *sch = NULL;
1911*ce4dcb97SMartin Matuska 	nvlist_t *ov = NULL;
1912*ce4dcb97SMartin Matuska 	char cmd[MAX_CMD_LEN];
1913*ce4dcb97SMartin Matuska 	snprintf(cmd, MAX_CMD_LEN, "zfs %s", current_command->name);
1914*ce4dcb97SMartin Matuska 
1915*ce4dcb97SMartin Matuska 	sch = fnvlist_alloc();
1916*ce4dcb97SMartin Matuska 	ov = fnvlist_alloc();
1917*ce4dcb97SMartin Matuska 	fnvlist_add_string(ov, "command", cmd);
1918*ce4dcb97SMartin Matuska 	fnvlist_add_uint32(ov, "vers_major", maj_v);
1919*ce4dcb97SMartin Matuska 	fnvlist_add_uint32(ov, "vers_minor", min_v);
1920*ce4dcb97SMartin Matuska 	fnvlist_add_nvlist(sch, "output_version", ov);
1921*ce4dcb97SMartin Matuska 	fnvlist_free(ov);
1922*ce4dcb97SMartin Matuska 	return (sch);
1923*ce4dcb97SMartin Matuska }
1924*ce4dcb97SMartin Matuska 
1925*ce4dcb97SMartin Matuska static void
1926*ce4dcb97SMartin Matuska fill_dataset_info(nvlist_t *list, zfs_handle_t *zhp, boolean_t as_int)
1927*ce4dcb97SMartin Matuska {
1928*ce4dcb97SMartin Matuska 	char createtxg[ZFS_MAXPROPLEN];
1929*ce4dcb97SMartin Matuska 	zfs_type_t type = zfs_get_type(zhp);
1930*ce4dcb97SMartin Matuska 	nvlist_add_string(list, "name", zfs_get_name(zhp));
1931*ce4dcb97SMartin Matuska 
1932*ce4dcb97SMartin Matuska 	switch (type) {
1933*ce4dcb97SMartin Matuska 	case ZFS_TYPE_FILESYSTEM:
1934*ce4dcb97SMartin Matuska 		fnvlist_add_string(list, "type", "FILESYSTEM");
1935*ce4dcb97SMartin Matuska 		break;
1936*ce4dcb97SMartin Matuska 	case ZFS_TYPE_VOLUME:
1937*ce4dcb97SMartin Matuska 		fnvlist_add_string(list, "type", "VOLUME");
1938*ce4dcb97SMartin Matuska 		break;
1939*ce4dcb97SMartin Matuska 	case ZFS_TYPE_SNAPSHOT:
1940*ce4dcb97SMartin Matuska 		fnvlist_add_string(list, "type", "SNAPSHOT");
1941*ce4dcb97SMartin Matuska 		break;
1942*ce4dcb97SMartin Matuska 	case ZFS_TYPE_POOL:
1943*ce4dcb97SMartin Matuska 		fnvlist_add_string(list, "type", "POOL");
1944*ce4dcb97SMartin Matuska 		break;
1945*ce4dcb97SMartin Matuska 	case ZFS_TYPE_BOOKMARK:
1946*ce4dcb97SMartin Matuska 		fnvlist_add_string(list, "type", "BOOKMARK");
1947*ce4dcb97SMartin Matuska 		break;
1948*ce4dcb97SMartin Matuska 	default:
1949*ce4dcb97SMartin Matuska 		fnvlist_add_string(list, "type", "UNKNOWN");
1950*ce4dcb97SMartin Matuska 		break;
1951*ce4dcb97SMartin Matuska 	}
1952*ce4dcb97SMartin Matuska 
1953*ce4dcb97SMartin Matuska 	if (type != ZFS_TYPE_POOL)
1954*ce4dcb97SMartin Matuska 		fnvlist_add_string(list, "pool", zfs_get_pool_name(zhp));
1955*ce4dcb97SMartin Matuska 
1956*ce4dcb97SMartin Matuska 	if (as_int) {
1957*ce4dcb97SMartin Matuska 		fnvlist_add_uint64(list, "createtxg", zfs_prop_get_int(zhp,
1958*ce4dcb97SMartin Matuska 		    ZFS_PROP_CREATETXG));
1959*ce4dcb97SMartin Matuska 	} else {
1960*ce4dcb97SMartin Matuska 		if (zfs_prop_get(zhp, ZFS_PROP_CREATETXG, createtxg,
1961*ce4dcb97SMartin Matuska 		    sizeof (createtxg), NULL, NULL, 0, B_TRUE) == 0)
1962*ce4dcb97SMartin Matuska 			fnvlist_add_string(list, "createtxg", createtxg);
1963*ce4dcb97SMartin Matuska 	}
1964*ce4dcb97SMartin Matuska 
1965*ce4dcb97SMartin Matuska 	if (type == ZFS_TYPE_SNAPSHOT) {
1966*ce4dcb97SMartin Matuska 		char *ds, *snap;
1967*ce4dcb97SMartin Matuska 		ds = snap = strdup(zfs_get_name(zhp));
1968*ce4dcb97SMartin Matuska 		ds = strsep(&snap, "@");
1969*ce4dcb97SMartin Matuska 		fnvlist_add_string(list, "dataset", ds);
1970*ce4dcb97SMartin Matuska 		fnvlist_add_string(list, "snapshot_name", snap);
1971*ce4dcb97SMartin Matuska 		free(ds);
1972*ce4dcb97SMartin Matuska 	}
1973*ce4dcb97SMartin Matuska }
1974*ce4dcb97SMartin Matuska 
1975*ce4dcb97SMartin Matuska /*
1976*ce4dcb97SMartin Matuska  * zfs get [-rHp] [-j [--json-int]] [-o all | field[,field]...]
1977*ce4dcb97SMartin Matuska  *		[-s source[,source]...]
1978eda14cbcSMatt Macy  *	< all | property[,property]... > < fs | snap | vol > ...
1979eda14cbcSMatt Macy  *
1980eda14cbcSMatt Macy  *	-r	recurse over any child datasets
1981eda14cbcSMatt Macy  *	-H	scripted mode.  Headers are stripped, and fields are separated
1982eda14cbcSMatt Macy  *		by tabs instead of spaces.
1983eda14cbcSMatt Macy  *	-o	Set of fields to display.  One of "name,property,value,
1984eda14cbcSMatt Macy  *		received,source". Default is "name,property,value,source".
1985eda14cbcSMatt Macy  *		"all" is an alias for all five.
1986eda14cbcSMatt Macy  *	-s	Set of sources to allow.  One of
1987eda14cbcSMatt Macy  *		"local,default,inherited,received,temporary,none".  Default is
1988eda14cbcSMatt Macy  *		all six.
1989eda14cbcSMatt Macy  *	-p	Display values in parsable (literal) format.
1990*ce4dcb97SMartin Matuska  *	-j	Display output in JSON format.
1991*ce4dcb97SMartin Matuska  *	--json-int	Display numbers as integers instead of strings.
1992eda14cbcSMatt Macy  *
1993eda14cbcSMatt Macy  *  Prints properties for the given datasets.  The user can control which
1994eda14cbcSMatt Macy  *  columns to display as well as which property types to allow.
1995eda14cbcSMatt Macy  */
1996eda14cbcSMatt Macy 
1997eda14cbcSMatt Macy /*
1998eda14cbcSMatt Macy  * Invoked to display the properties for a single dataset.
1999eda14cbcSMatt Macy  */
2000eda14cbcSMatt Macy static int
2001eda14cbcSMatt Macy get_callback(zfs_handle_t *zhp, void *data)
2002eda14cbcSMatt Macy {
2003eda14cbcSMatt Macy 	char buf[ZFS_MAXPROPLEN];
2004eda14cbcSMatt Macy 	char rbuf[ZFS_MAXPROPLEN];
2005eda14cbcSMatt Macy 	zprop_source_t sourcetype;
2006eda14cbcSMatt Macy 	char source[ZFS_MAX_DATASET_NAME_LEN];
2007eda14cbcSMatt Macy 	zprop_get_cbdata_t *cbp = data;
2008eda14cbcSMatt Macy 	nvlist_t *user_props = zfs_get_user_props(zhp);
2009eda14cbcSMatt Macy 	zprop_list_t *pl = cbp->cb_proplist;
2010eda14cbcSMatt Macy 	nvlist_t *propval;
2011*ce4dcb97SMartin Matuska 	nvlist_t *item, *d, *props;
2012*ce4dcb97SMartin Matuska 	item = d = props = NULL;
2013a0b956f5SMartin Matuska 	const char *strval;
2014a0b956f5SMartin Matuska 	const char *sourceval;
2015eda14cbcSMatt Macy 	boolean_t received = is_recvd_column(cbp);
2016*ce4dcb97SMartin Matuska 	int err = 0;
2017*ce4dcb97SMartin Matuska 
2018*ce4dcb97SMartin Matuska 	if (cbp->cb_json) {
2019*ce4dcb97SMartin Matuska 		d = fnvlist_lookup_nvlist(cbp->cb_jsobj, "datasets");
2020*ce4dcb97SMartin Matuska 		if (d == NULL) {
2021*ce4dcb97SMartin Matuska 			fprintf(stderr, "datasets obj not found.\n");
2022*ce4dcb97SMartin Matuska 			exit(1);
2023*ce4dcb97SMartin Matuska 		}
2024*ce4dcb97SMartin Matuska 		props = fnvlist_alloc();
2025*ce4dcb97SMartin Matuska 	}
2026eda14cbcSMatt Macy 
2027eda14cbcSMatt Macy 	for (; pl != NULL; pl = pl->pl_next) {
2028eda14cbcSMatt Macy 		char *recvdval = NULL;
2029eda14cbcSMatt Macy 		/*
2030eda14cbcSMatt Macy 		 * Skip the special fake placeholder.  This will also skip over
2031eda14cbcSMatt Macy 		 * the name property when 'all' is specified.
2032eda14cbcSMatt Macy 		 */
2033eda14cbcSMatt Macy 		if (pl->pl_prop == ZFS_PROP_NAME &&
2034eda14cbcSMatt Macy 		    pl == cbp->cb_proplist)
2035eda14cbcSMatt Macy 			continue;
2036eda14cbcSMatt Macy 
20371f1e2261SMartin Matuska 		if (pl->pl_prop != ZPROP_USERPROP) {
2038eda14cbcSMatt Macy 			if (zfs_prop_get(zhp, pl->pl_prop, buf,
2039eda14cbcSMatt Macy 			    sizeof (buf), &sourcetype, source,
2040eda14cbcSMatt Macy 			    sizeof (source),
2041eda14cbcSMatt Macy 			    cbp->cb_literal) != 0) {
2042eda14cbcSMatt Macy 				if (pl->pl_all)
2043eda14cbcSMatt Macy 					continue;
2044eda14cbcSMatt Macy 				if (!zfs_prop_valid_for_type(pl->pl_prop,
2045eda14cbcSMatt Macy 				    ZFS_TYPE_DATASET, B_FALSE)) {
2046eda14cbcSMatt Macy 					(void) fprintf(stderr,
2047eda14cbcSMatt Macy 					    gettext("No such property '%s'\n"),
2048eda14cbcSMatt Macy 					    zfs_prop_to_name(pl->pl_prop));
2049eda14cbcSMatt Macy 					continue;
2050eda14cbcSMatt Macy 				}
2051eda14cbcSMatt Macy 				sourcetype = ZPROP_SRC_NONE;
2052eda14cbcSMatt Macy 				(void) strlcpy(buf, "-", sizeof (buf));
2053eda14cbcSMatt Macy 			}
2054eda14cbcSMatt Macy 
2055eda14cbcSMatt Macy 			if (received && (zfs_prop_get_recvd(zhp,
2056eda14cbcSMatt Macy 			    zfs_prop_to_name(pl->pl_prop), rbuf, sizeof (rbuf),
2057eda14cbcSMatt Macy 			    cbp->cb_literal) == 0))
2058eda14cbcSMatt Macy 				recvdval = rbuf;
2059eda14cbcSMatt Macy 
2060*ce4dcb97SMartin Matuska 			err = zprop_collect_property(zfs_get_name(zhp), cbp,
2061eda14cbcSMatt Macy 			    zfs_prop_to_name(pl->pl_prop),
2062*ce4dcb97SMartin Matuska 			    buf, sourcetype, source, recvdval, props);
2063eda14cbcSMatt Macy 		} else if (zfs_prop_userquota(pl->pl_user_prop)) {
2064eda14cbcSMatt Macy 			sourcetype = ZPROP_SRC_LOCAL;
2065eda14cbcSMatt Macy 
2066eda14cbcSMatt Macy 			if (zfs_prop_get_userquota(zhp, pl->pl_user_prop,
2067eda14cbcSMatt Macy 			    buf, sizeof (buf), cbp->cb_literal) != 0) {
2068eda14cbcSMatt Macy 				sourcetype = ZPROP_SRC_NONE;
2069eda14cbcSMatt Macy 				(void) strlcpy(buf, "-", sizeof (buf));
2070eda14cbcSMatt Macy 			}
2071eda14cbcSMatt Macy 
2072*ce4dcb97SMartin Matuska 			err = zprop_collect_property(zfs_get_name(zhp), cbp,
2073*ce4dcb97SMartin Matuska 			    pl->pl_user_prop, buf, sourcetype, source, NULL,
2074*ce4dcb97SMartin Matuska 			    props);
2075eda14cbcSMatt Macy 		} else if (zfs_prop_written(pl->pl_user_prop)) {
2076eda14cbcSMatt Macy 			sourcetype = ZPROP_SRC_LOCAL;
2077eda14cbcSMatt Macy 
2078eda14cbcSMatt Macy 			if (zfs_prop_get_written(zhp, pl->pl_user_prop,
2079eda14cbcSMatt Macy 			    buf, sizeof (buf), cbp->cb_literal) != 0) {
2080eda14cbcSMatt Macy 				sourcetype = ZPROP_SRC_NONE;
2081eda14cbcSMatt Macy 				(void) strlcpy(buf, "-", sizeof (buf));
2082eda14cbcSMatt Macy 			}
2083eda14cbcSMatt Macy 
2084*ce4dcb97SMartin Matuska 			err = zprop_collect_property(zfs_get_name(zhp), cbp,
2085*ce4dcb97SMartin Matuska 			    pl->pl_user_prop, buf, sourcetype, source, NULL,
2086*ce4dcb97SMartin Matuska 			    props);
2087eda14cbcSMatt Macy 		} else {
2088eda14cbcSMatt Macy 			if (nvlist_lookup_nvlist(user_props,
2089eda14cbcSMatt Macy 			    pl->pl_user_prop, &propval) != 0) {
2090eda14cbcSMatt Macy 				if (pl->pl_all)
2091eda14cbcSMatt Macy 					continue;
2092eda14cbcSMatt Macy 				sourcetype = ZPROP_SRC_NONE;
2093eda14cbcSMatt Macy 				strval = "-";
2094eda14cbcSMatt Macy 			} else {
2095a0b956f5SMartin Matuska 				strval = fnvlist_lookup_string(propval,
2096a0b956f5SMartin Matuska 				    ZPROP_VALUE);
2097a0b956f5SMartin Matuska 				sourceval = fnvlist_lookup_string(propval,
2098a0b956f5SMartin Matuska 				    ZPROP_SOURCE);
2099eda14cbcSMatt Macy 
2100eda14cbcSMatt Macy 				if (strcmp(sourceval,
2101eda14cbcSMatt Macy 				    zfs_get_name(zhp)) == 0) {
2102eda14cbcSMatt Macy 					sourcetype = ZPROP_SRC_LOCAL;
2103eda14cbcSMatt Macy 				} else if (strcmp(sourceval,
2104eda14cbcSMatt Macy 				    ZPROP_SOURCE_VAL_RECVD) == 0) {
2105eda14cbcSMatt Macy 					sourcetype = ZPROP_SRC_RECEIVED;
2106eda14cbcSMatt Macy 				} else {
2107eda14cbcSMatt Macy 					sourcetype = ZPROP_SRC_INHERITED;
2108eda14cbcSMatt Macy 					(void) strlcpy(source,
2109eda14cbcSMatt Macy 					    sourceval, sizeof (source));
2110eda14cbcSMatt Macy 				}
2111eda14cbcSMatt Macy 			}
2112eda14cbcSMatt Macy 
2113eda14cbcSMatt Macy 			if (received && (zfs_prop_get_recvd(zhp,
2114eda14cbcSMatt Macy 			    pl->pl_user_prop, rbuf, sizeof (rbuf),
2115eda14cbcSMatt Macy 			    cbp->cb_literal) == 0))
2116eda14cbcSMatt Macy 				recvdval = rbuf;
2117eda14cbcSMatt Macy 
2118*ce4dcb97SMartin Matuska 			err = zprop_collect_property(zfs_get_name(zhp), cbp,
2119eda14cbcSMatt Macy 			    pl->pl_user_prop, strval, sourcetype,
2120*ce4dcb97SMartin Matuska 			    source, recvdval, props);
2121*ce4dcb97SMartin Matuska 		}
2122*ce4dcb97SMartin Matuska 		if (err != 0)
2123*ce4dcb97SMartin Matuska 			return (err);
2124*ce4dcb97SMartin Matuska 	}
2125*ce4dcb97SMartin Matuska 
2126*ce4dcb97SMartin Matuska 	if (cbp->cb_json) {
2127*ce4dcb97SMartin Matuska 		if (!nvlist_empty(props)) {
2128*ce4dcb97SMartin Matuska 			item = fnvlist_alloc();
2129*ce4dcb97SMartin Matuska 			fill_dataset_info(item, zhp, cbp->cb_json_as_int);
2130*ce4dcb97SMartin Matuska 			fnvlist_add_nvlist(item, "properties", props);
2131*ce4dcb97SMartin Matuska 			fnvlist_add_nvlist(d, zfs_get_name(zhp), item);
2132*ce4dcb97SMartin Matuska 			fnvlist_free(props);
2133*ce4dcb97SMartin Matuska 			fnvlist_free(item);
2134*ce4dcb97SMartin Matuska 		} else {
2135*ce4dcb97SMartin Matuska 			fnvlist_free(props);
2136eda14cbcSMatt Macy 		}
2137eda14cbcSMatt Macy 	}
2138eda14cbcSMatt Macy 
2139eda14cbcSMatt Macy 	return (0);
2140eda14cbcSMatt Macy }
2141eda14cbcSMatt Macy 
2142eda14cbcSMatt Macy static int
2143eda14cbcSMatt Macy zfs_do_get(int argc, char **argv)
2144eda14cbcSMatt Macy {
2145eda14cbcSMatt Macy 	zprop_get_cbdata_t cb = { 0 };
2146eda14cbcSMatt Macy 	int i, c, flags = ZFS_ITER_ARGS_CAN_BE_PATHS;
2147eda14cbcSMatt Macy 	int types = ZFS_TYPE_DATASET | ZFS_TYPE_BOOKMARK;
2148da5137abSMartin Matuska 	char *fields;
2149eda14cbcSMatt Macy 	int ret = 0;
2150eda14cbcSMatt Macy 	int limit = 0;
2151eda14cbcSMatt Macy 	zprop_list_t fake_name = { 0 };
2152*ce4dcb97SMartin Matuska 	nvlist_t *data;
2153eda14cbcSMatt Macy 
2154eda14cbcSMatt Macy 	/*
2155eda14cbcSMatt Macy 	 * Set up default columns and sources.
2156eda14cbcSMatt Macy 	 */
2157eda14cbcSMatt Macy 	cb.cb_sources = ZPROP_SRC_ALL;
2158eda14cbcSMatt Macy 	cb.cb_columns[0] = GET_COL_NAME;
2159eda14cbcSMatt Macy 	cb.cb_columns[1] = GET_COL_PROPERTY;
2160eda14cbcSMatt Macy 	cb.cb_columns[2] = GET_COL_VALUE;
2161eda14cbcSMatt Macy 	cb.cb_columns[3] = GET_COL_SOURCE;
2162eda14cbcSMatt Macy 	cb.cb_type = ZFS_TYPE_DATASET;
2163eda14cbcSMatt Macy 
2164*ce4dcb97SMartin Matuska 	struct option long_options[] = {
2165*ce4dcb97SMartin Matuska 		{"json-int", no_argument, NULL, ZFS_OPTION_JSON_NUMS_AS_INT},
2166*ce4dcb97SMartin Matuska 		{0, 0, 0, 0}
2167*ce4dcb97SMartin Matuska 	};
2168*ce4dcb97SMartin Matuska 
2169eda14cbcSMatt Macy 	/* check options */
2170*ce4dcb97SMartin Matuska 	while ((c = getopt_long(argc, argv, ":d:o:s:jrt:Hp", long_options,
2171*ce4dcb97SMartin Matuska 	    NULL)) != -1) {
2172eda14cbcSMatt Macy 		switch (c) {
2173eda14cbcSMatt Macy 		case 'p':
2174eda14cbcSMatt Macy 			cb.cb_literal = B_TRUE;
2175eda14cbcSMatt Macy 			break;
2176eda14cbcSMatt Macy 		case 'd':
2177eda14cbcSMatt Macy 			limit = parse_depth(optarg, &flags);
2178eda14cbcSMatt Macy 			break;
2179eda14cbcSMatt Macy 		case 'r':
2180eda14cbcSMatt Macy 			flags |= ZFS_ITER_RECURSE;
2181eda14cbcSMatt Macy 			break;
2182eda14cbcSMatt Macy 		case 'H':
2183eda14cbcSMatt Macy 			cb.cb_scripted = B_TRUE;
2184eda14cbcSMatt Macy 			break;
2185*ce4dcb97SMartin Matuska 		case 'j':
2186*ce4dcb97SMartin Matuska 			cb.cb_json = B_TRUE;
2187*ce4dcb97SMartin Matuska 			cb.cb_jsobj = zfs_json_schema(0, 1);
2188*ce4dcb97SMartin Matuska 			data = fnvlist_alloc();
2189*ce4dcb97SMartin Matuska 			fnvlist_add_nvlist(cb.cb_jsobj, "datasets", data);
2190*ce4dcb97SMartin Matuska 			fnvlist_free(data);
2191*ce4dcb97SMartin Matuska 			break;
2192*ce4dcb97SMartin Matuska 		case ZFS_OPTION_JSON_NUMS_AS_INT:
2193*ce4dcb97SMartin Matuska 			cb.cb_json_as_int = B_TRUE;
2194*ce4dcb97SMartin Matuska 			cb.cb_literal = B_TRUE;
2195*ce4dcb97SMartin Matuska 			break;
2196eda14cbcSMatt Macy 		case ':':
2197eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("missing argument for "
2198eda14cbcSMatt Macy 			    "'%c' option\n"), optopt);
2199eda14cbcSMatt Macy 			usage(B_FALSE);
2200eda14cbcSMatt Macy 			break;
2201eda14cbcSMatt Macy 		case 'o':
2202eda14cbcSMatt Macy 			/*
2203eda14cbcSMatt Macy 			 * Process the set of columns to display.  We zero out
2204eda14cbcSMatt Macy 			 * the structure to give us a blank slate.
2205eda14cbcSMatt Macy 			 */
2206da5137abSMartin Matuska 			memset(&cb.cb_columns, 0, sizeof (cb.cb_columns));
2207da5137abSMartin Matuska 
2208eda14cbcSMatt Macy 			i = 0;
2209da5137abSMartin Matuska 			for (char *tok; (tok = strsep(&optarg, ",")); ) {
2210da5137abSMartin Matuska 				static const char *const col_subopts[] =
2211da5137abSMartin Matuska 				{ "name", "property", "value",
2212da5137abSMartin Matuska 				    "received", "source", "all" };
2213da5137abSMartin Matuska 				static const zfs_get_column_t col_subopt_col[] =
2214da5137abSMartin Matuska 				{ GET_COL_NAME, GET_COL_PROPERTY, GET_COL_VALUE,
2215da5137abSMartin Matuska 				    GET_COL_RECVD, GET_COL_SOURCE };
2216da5137abSMartin Matuska 				static const int col_subopt_flags[] =
2217da5137abSMartin Matuska 				{ 0, 0, 0, ZFS_ITER_RECVD_PROPS, 0 };
2218eda14cbcSMatt Macy 
2219eda14cbcSMatt Macy 				if (i == ZFS_GET_NCOLS) {
2220eda14cbcSMatt Macy 					(void) fprintf(stderr, gettext("too "
2221eda14cbcSMatt Macy 					    "many fields given to -o "
2222eda14cbcSMatt Macy 					    "option\n"));
2223eda14cbcSMatt Macy 					usage(B_FALSE);
2224eda14cbcSMatt Macy 				}
2225eda14cbcSMatt Macy 
2226da5137abSMartin Matuska 				for (c = 0; c < ARRAY_SIZE(col_subopts); ++c)
2227da5137abSMartin Matuska 					if (strcmp(tok, col_subopts[c]) == 0)
2228da5137abSMartin Matuska 						goto found;
2229da5137abSMartin Matuska 
2230da5137abSMartin Matuska 				(void) fprintf(stderr,
2231da5137abSMartin Matuska 				    gettext("invalid column name '%s'\n"), tok);
2232da5137abSMartin Matuska 				usage(B_FALSE);
2233da5137abSMartin Matuska 
2234da5137abSMartin Matuska found:
2235da5137abSMartin Matuska 				if (c >= 5) {
2236eda14cbcSMatt Macy 					if (i > 0) {
2237eda14cbcSMatt Macy 						(void) fprintf(stderr,
2238eda14cbcSMatt Macy 						    gettext("\"all\" conflicts "
2239eda14cbcSMatt Macy 						    "with specific fields "
2240eda14cbcSMatt Macy 						    "given to -o option\n"));
2241eda14cbcSMatt Macy 						usage(B_FALSE);
2242eda14cbcSMatt Macy 					}
2243da5137abSMartin Matuska 
2244da5137abSMartin Matuska 					memcpy(cb.cb_columns, col_subopt_col,
2245da5137abSMartin Matuska 					    sizeof (col_subopt_col));
2246eda14cbcSMatt Macy 					flags |= ZFS_ITER_RECVD_PROPS;
2247eda14cbcSMatt Macy 					i = ZFS_GET_NCOLS;
2248da5137abSMartin Matuska 				} else {
2249da5137abSMartin Matuska 					cb.cb_columns[i++] = col_subopt_col[c];
2250da5137abSMartin Matuska 					flags |= col_subopt_flags[c];
2251eda14cbcSMatt Macy 				}
2252eda14cbcSMatt Macy 			}
2253eda14cbcSMatt Macy 			break;
2254eda14cbcSMatt Macy 
2255eda14cbcSMatt Macy 		case 's':
2256eda14cbcSMatt Macy 			cb.cb_sources = 0;
2257eda14cbcSMatt Macy 
2258da5137abSMartin Matuska 			for (char *tok; (tok = strsep(&optarg, ",")); ) {
2259da5137abSMartin Matuska 				static const char *const source_opt[] = {
2260da5137abSMartin Matuska 					"local", "default",
2261da5137abSMartin Matuska 					"inherited", "received",
2262da5137abSMartin Matuska 					"temporary", "none" };
2263da5137abSMartin Matuska 				static const int source_flg[] = {
2264da5137abSMartin Matuska 					ZPROP_SRC_LOCAL, ZPROP_SRC_DEFAULT,
2265da5137abSMartin Matuska 					ZPROP_SRC_INHERITED, ZPROP_SRC_RECEIVED,
2266da5137abSMartin Matuska 					ZPROP_SRC_TEMPORARY, ZPROP_SRC_NONE };
2267da5137abSMartin Matuska 
2268da5137abSMartin Matuska 				for (i = 0; i < ARRAY_SIZE(source_opt); ++i)
2269da5137abSMartin Matuska 					if (strcmp(tok, source_opt[i]) == 0) {
2270da5137abSMartin Matuska 						cb.cb_sources |= source_flg[i];
2271da5137abSMartin Matuska 						goto found2;
2272eda14cbcSMatt Macy 					}
2273da5137abSMartin Matuska 
2274da5137abSMartin Matuska 				(void) fprintf(stderr,
2275da5137abSMartin Matuska 				    gettext("invalid source '%s'\n"), tok);
2276da5137abSMartin Matuska 				usage(B_FALSE);
2277da5137abSMartin Matuska found2:;
2278eda14cbcSMatt Macy 			}
2279eda14cbcSMatt Macy 			break;
2280eda14cbcSMatt Macy 
2281eda14cbcSMatt Macy 		case 't':
2282eda14cbcSMatt Macy 			types = 0;
2283eda14cbcSMatt Macy 			flags &= ~ZFS_ITER_PROP_LISTSNAPS;
2284eda14cbcSMatt Macy 
2285da5137abSMartin Matuska 			for (char *tok; (tok = strsep(&optarg, ",")); ) {
2286da5137abSMartin Matuska 				static const char *const type_opts[] = {
22870d4ad640SMartin Matuska 					"filesystem",
22880d4ad640SMartin Matuska 					"fs",
22890d4ad640SMartin Matuska 					"volume",
22900d4ad640SMartin Matuska 					"vol",
22910d4ad640SMartin Matuska 					"snapshot",
22920d4ad640SMartin Matuska 					"snap",
2293da5137abSMartin Matuska 					"bookmark",
22940d4ad640SMartin Matuska 					"all"
22950d4ad640SMartin Matuska 				};
2296da5137abSMartin Matuska 				static const int type_types[] = {
22970d4ad640SMartin Matuska 					ZFS_TYPE_FILESYSTEM,
22980d4ad640SMartin Matuska 					ZFS_TYPE_FILESYSTEM,
22990d4ad640SMartin Matuska 					ZFS_TYPE_VOLUME,
23000d4ad640SMartin Matuska 					ZFS_TYPE_VOLUME,
23010d4ad640SMartin Matuska 					ZFS_TYPE_SNAPSHOT,
23020d4ad640SMartin Matuska 					ZFS_TYPE_SNAPSHOT,
2303da5137abSMartin Matuska 					ZFS_TYPE_BOOKMARK,
23040d4ad640SMartin Matuska 					ZFS_TYPE_DATASET | ZFS_TYPE_BOOKMARK
23050d4ad640SMartin Matuska 				};
2306eda14cbcSMatt Macy 
2307da5137abSMartin Matuska 				for (i = 0; i < ARRAY_SIZE(type_opts); ++i)
2308da5137abSMartin Matuska 					if (strcmp(tok, type_opts[i]) == 0) {
2309da5137abSMartin Matuska 						types |= type_types[i];
2310da5137abSMartin Matuska 						goto found3;
2311eda14cbcSMatt Macy 					}
2312da5137abSMartin Matuska 
2313da5137abSMartin Matuska 				(void) fprintf(stderr,
2314da5137abSMartin Matuska 				    gettext("invalid type '%s'\n"), tok);
2315da5137abSMartin Matuska 				usage(B_FALSE);
2316da5137abSMartin Matuska found3:;
2317eda14cbcSMatt Macy 			}
2318eda14cbcSMatt Macy 			break;
2319eda14cbcSMatt Macy 		case '?':
2320eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
2321eda14cbcSMatt Macy 			    optopt);
2322eda14cbcSMatt Macy 			usage(B_FALSE);
2323eda14cbcSMatt Macy 		}
2324eda14cbcSMatt Macy 	}
2325eda14cbcSMatt Macy 
2326eda14cbcSMatt Macy 	argc -= optind;
2327eda14cbcSMatt Macy 	argv += optind;
2328eda14cbcSMatt Macy 
2329eda14cbcSMatt Macy 	if (argc < 1) {
2330eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("missing property "
2331eda14cbcSMatt Macy 		    "argument\n"));
2332eda14cbcSMatt Macy 		usage(B_FALSE);
2333eda14cbcSMatt Macy 	}
2334eda14cbcSMatt Macy 
2335*ce4dcb97SMartin Matuska 	if (!cb.cb_json && cb.cb_json_as_int) {
2336*ce4dcb97SMartin Matuska 		(void) fprintf(stderr, gettext("'--json-int' only works with"
2337*ce4dcb97SMartin Matuska 		    " '-j' option\n"));
2338*ce4dcb97SMartin Matuska 		usage(B_FALSE);
2339*ce4dcb97SMartin Matuska 	}
2340*ce4dcb97SMartin Matuska 
2341eda14cbcSMatt Macy 	fields = argv[0];
2342eda14cbcSMatt Macy 
2343eda14cbcSMatt Macy 	/*
2344eda14cbcSMatt Macy 	 * Handle users who want to get all snapshots or bookmarks
2345eda14cbcSMatt Macy 	 * of a dataset (ex. 'zfs get -t snapshot refer <dataset>').
2346eda14cbcSMatt Macy 	 */
2347eda14cbcSMatt Macy 	if ((types == ZFS_TYPE_SNAPSHOT || types == ZFS_TYPE_BOOKMARK) &&
2348eda14cbcSMatt Macy 	    argc > 1 && (flags & ZFS_ITER_RECURSE) == 0 && limit == 0) {
2349eda14cbcSMatt Macy 		flags |= (ZFS_ITER_DEPTH_LIMIT | ZFS_ITER_RECURSE);
2350eda14cbcSMatt Macy 		limit = 1;
2351eda14cbcSMatt Macy 	}
2352eda14cbcSMatt Macy 
2353eda14cbcSMatt Macy 	if (zprop_get_list(g_zfs, fields, &cb.cb_proplist, ZFS_TYPE_DATASET)
2354eda14cbcSMatt Macy 	    != 0)
2355eda14cbcSMatt Macy 		usage(B_FALSE);
2356eda14cbcSMatt Macy 
2357eda14cbcSMatt Macy 	argc--;
2358eda14cbcSMatt Macy 	argv++;
2359eda14cbcSMatt Macy 
2360eda14cbcSMatt Macy 	/*
2361eda14cbcSMatt Macy 	 * As part of zfs_expand_proplist(), we keep track of the maximum column
2362eda14cbcSMatt Macy 	 * width for each property.  For the 'NAME' (and 'SOURCE') columns, we
2363eda14cbcSMatt Macy 	 * need to know the maximum name length.  However, the user likely did
2364eda14cbcSMatt Macy 	 * not specify 'name' as one of the properties to fetch, so we need to
2365eda14cbcSMatt Macy 	 * make sure we always include at least this property for
2366eda14cbcSMatt Macy 	 * print_get_headers() to work properly.
2367eda14cbcSMatt Macy 	 */
2368eda14cbcSMatt Macy 	if (cb.cb_proplist != NULL) {
2369eda14cbcSMatt Macy 		fake_name.pl_prop = ZFS_PROP_NAME;
2370eda14cbcSMatt Macy 		fake_name.pl_width = strlen(gettext("NAME"));
2371eda14cbcSMatt Macy 		fake_name.pl_next = cb.cb_proplist;
2372eda14cbcSMatt Macy 		cb.cb_proplist = &fake_name;
2373eda14cbcSMatt Macy 	}
2374eda14cbcSMatt Macy 
2375eda14cbcSMatt Macy 	cb.cb_first = B_TRUE;
2376eda14cbcSMatt Macy 
2377eda14cbcSMatt Macy 	/* run for each object */
2378eda14cbcSMatt Macy 	ret = zfs_for_each(argc, argv, flags, types, NULL,
2379eda14cbcSMatt Macy 	    &cb.cb_proplist, limit, get_callback, &cb);
2380eda14cbcSMatt Macy 
2381*ce4dcb97SMartin Matuska 	if (ret == 0 && cb.cb_json)
2382*ce4dcb97SMartin Matuska 		zcmd_print_json(cb.cb_jsobj);
2383*ce4dcb97SMartin Matuska 	else if (ret != 0 && cb.cb_json)
2384*ce4dcb97SMartin Matuska 		nvlist_free(cb.cb_jsobj);
2385*ce4dcb97SMartin Matuska 
2386eda14cbcSMatt Macy 	if (cb.cb_proplist == &fake_name)
2387eda14cbcSMatt Macy 		zprop_free_list(fake_name.pl_next);
2388eda14cbcSMatt Macy 	else
2389eda14cbcSMatt Macy 		zprop_free_list(cb.cb_proplist);
2390eda14cbcSMatt Macy 
2391eda14cbcSMatt Macy 	return (ret);
2392eda14cbcSMatt Macy }
2393eda14cbcSMatt Macy 
2394eda14cbcSMatt Macy /*
2395eda14cbcSMatt Macy  * inherit [-rS] <property> <fs|vol> ...
2396eda14cbcSMatt Macy  *
2397eda14cbcSMatt Macy  *	-r	Recurse over all children
2398eda14cbcSMatt Macy  *	-S	Revert to received value, if any
2399eda14cbcSMatt Macy  *
2400eda14cbcSMatt Macy  * For each dataset specified on the command line, inherit the given property
2401eda14cbcSMatt Macy  * from its parent.  Inheriting a property at the pool level will cause it to
2402eda14cbcSMatt Macy  * use the default value.  The '-r' flag will recurse over all children, and is
2403eda14cbcSMatt Macy  * useful for setting a property on a hierarchy-wide basis, regardless of any
2404eda14cbcSMatt Macy  * local modifications for each dataset.
2405eda14cbcSMatt Macy  */
2406eda14cbcSMatt Macy 
2407eda14cbcSMatt Macy typedef struct inherit_cbdata {
2408eda14cbcSMatt Macy 	const char *cb_propname;
2409eda14cbcSMatt Macy 	boolean_t cb_received;
2410eda14cbcSMatt Macy } inherit_cbdata_t;
2411eda14cbcSMatt Macy 
2412eda14cbcSMatt Macy static int
2413eda14cbcSMatt Macy inherit_recurse_cb(zfs_handle_t *zhp, void *data)
2414eda14cbcSMatt Macy {
2415eda14cbcSMatt Macy 	inherit_cbdata_t *cb = data;
2416eda14cbcSMatt Macy 	zfs_prop_t prop = zfs_name_to_prop(cb->cb_propname);
2417eda14cbcSMatt Macy 
2418eda14cbcSMatt Macy 	/*
2419eda14cbcSMatt Macy 	 * If we're doing it recursively, then ignore properties that
2420eda14cbcSMatt Macy 	 * are not valid for this type of dataset.
2421eda14cbcSMatt Macy 	 */
2422eda14cbcSMatt Macy 	if (prop != ZPROP_INVAL &&
2423eda14cbcSMatt Macy 	    !zfs_prop_valid_for_type(prop, zfs_get_type(zhp), B_FALSE))
2424eda14cbcSMatt Macy 		return (0);
2425eda14cbcSMatt Macy 
2426eda14cbcSMatt Macy 	return (zfs_prop_inherit(zhp, cb->cb_propname, cb->cb_received) != 0);
2427eda14cbcSMatt Macy }
2428eda14cbcSMatt Macy 
2429eda14cbcSMatt Macy static int
2430eda14cbcSMatt Macy inherit_cb(zfs_handle_t *zhp, void *data)
2431eda14cbcSMatt Macy {
2432eda14cbcSMatt Macy 	inherit_cbdata_t *cb = data;
2433eda14cbcSMatt Macy 
2434eda14cbcSMatt Macy 	return (zfs_prop_inherit(zhp, cb->cb_propname, cb->cb_received) != 0);
2435eda14cbcSMatt Macy }
2436eda14cbcSMatt Macy 
2437eda14cbcSMatt Macy static int
2438eda14cbcSMatt Macy zfs_do_inherit(int argc, char **argv)
2439eda14cbcSMatt Macy {
2440eda14cbcSMatt Macy 	int c;
2441eda14cbcSMatt Macy 	zfs_prop_t prop;
2442eda14cbcSMatt Macy 	inherit_cbdata_t cb = { 0 };
2443eda14cbcSMatt Macy 	char *propname;
2444eda14cbcSMatt Macy 	int ret = 0;
2445eda14cbcSMatt Macy 	int flags = 0;
2446eda14cbcSMatt Macy 	boolean_t received = B_FALSE;
2447eda14cbcSMatt Macy 
2448eda14cbcSMatt Macy 	/* check options */
2449eda14cbcSMatt Macy 	while ((c = getopt(argc, argv, "rS")) != -1) {
2450eda14cbcSMatt Macy 		switch (c) {
2451eda14cbcSMatt Macy 		case 'r':
2452eda14cbcSMatt Macy 			flags |= ZFS_ITER_RECURSE;
2453eda14cbcSMatt Macy 			break;
2454eda14cbcSMatt Macy 		case 'S':
2455eda14cbcSMatt Macy 			received = B_TRUE;
2456eda14cbcSMatt Macy 			break;
2457eda14cbcSMatt Macy 		case '?':
2458eda14cbcSMatt Macy 		default:
2459eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
2460eda14cbcSMatt Macy 			    optopt);
2461eda14cbcSMatt Macy 			usage(B_FALSE);
2462eda14cbcSMatt Macy 		}
2463eda14cbcSMatt Macy 	}
2464eda14cbcSMatt Macy 
2465eda14cbcSMatt Macy 	argc -= optind;
2466eda14cbcSMatt Macy 	argv += optind;
2467eda14cbcSMatt Macy 
2468eda14cbcSMatt Macy 	/* check number of arguments */
2469eda14cbcSMatt Macy 	if (argc < 1) {
2470eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("missing property argument\n"));
2471eda14cbcSMatt Macy 		usage(B_FALSE);
2472eda14cbcSMatt Macy 	}
2473eda14cbcSMatt Macy 	if (argc < 2) {
2474eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("missing dataset argument\n"));
2475eda14cbcSMatt Macy 		usage(B_FALSE);
2476eda14cbcSMatt Macy 	}
2477eda14cbcSMatt Macy 
2478eda14cbcSMatt Macy 	propname = argv[0];
2479eda14cbcSMatt Macy 	argc--;
2480eda14cbcSMatt Macy 	argv++;
2481eda14cbcSMatt Macy 
24821f1e2261SMartin Matuska 	if ((prop = zfs_name_to_prop(propname)) != ZPROP_USERPROP) {
2483eda14cbcSMatt Macy 		if (zfs_prop_readonly(prop)) {
2484eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext(
2485eda14cbcSMatt Macy 			    "%s property is read-only\n"),
2486eda14cbcSMatt Macy 			    propname);
2487eda14cbcSMatt Macy 			return (1);
2488eda14cbcSMatt Macy 		}
2489eda14cbcSMatt Macy 		if (!zfs_prop_inheritable(prop) && !received) {
2490eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("'%s' property cannot "
2491eda14cbcSMatt Macy 			    "be inherited\n"), propname);
2492eda14cbcSMatt Macy 			if (prop == ZFS_PROP_QUOTA ||
2493eda14cbcSMatt Macy 			    prop == ZFS_PROP_RESERVATION ||
2494eda14cbcSMatt Macy 			    prop == ZFS_PROP_REFQUOTA ||
2495eda14cbcSMatt Macy 			    prop == ZFS_PROP_REFRESERVATION) {
2496eda14cbcSMatt Macy 				(void) fprintf(stderr, gettext("use 'zfs set "
2497eda14cbcSMatt Macy 				    "%s=none' to clear\n"), propname);
2498eda14cbcSMatt Macy 				(void) fprintf(stderr, gettext("use 'zfs "
2499eda14cbcSMatt Macy 				    "inherit -S %s' to revert to received "
2500eda14cbcSMatt Macy 				    "value\n"), propname);
2501eda14cbcSMatt Macy 			}
2502eda14cbcSMatt Macy 			return (1);
2503eda14cbcSMatt Macy 		}
2504eda14cbcSMatt Macy 		if (received && (prop == ZFS_PROP_VOLSIZE ||
2505eda14cbcSMatt Macy 		    prop == ZFS_PROP_VERSION)) {
2506eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("'%s' property cannot "
2507eda14cbcSMatt Macy 			    "be reverted to a received value\n"), propname);
2508eda14cbcSMatt Macy 			return (1);
2509eda14cbcSMatt Macy 		}
2510eda14cbcSMatt Macy 	} else if (!zfs_prop_user(propname)) {
2511eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("invalid property '%s'\n"),
2512eda14cbcSMatt Macy 		    propname);
2513eda14cbcSMatt Macy 		usage(B_FALSE);
2514eda14cbcSMatt Macy 	}
2515eda14cbcSMatt Macy 
2516eda14cbcSMatt Macy 	cb.cb_propname = propname;
2517eda14cbcSMatt Macy 	cb.cb_received = received;
2518eda14cbcSMatt Macy 
2519eda14cbcSMatt Macy 	if (flags & ZFS_ITER_RECURSE) {
2520eda14cbcSMatt Macy 		ret = zfs_for_each(argc, argv, flags, ZFS_TYPE_DATASET,
2521eda14cbcSMatt Macy 		    NULL, NULL, 0, inherit_recurse_cb, &cb);
2522eda14cbcSMatt Macy 	} else {
2523eda14cbcSMatt Macy 		ret = zfs_for_each(argc, argv, flags, ZFS_TYPE_DATASET,
2524eda14cbcSMatt Macy 		    NULL, NULL, 0, inherit_cb, &cb);
2525eda14cbcSMatt Macy 	}
2526eda14cbcSMatt Macy 
2527eda14cbcSMatt Macy 	return (ret);
2528eda14cbcSMatt Macy }
2529eda14cbcSMatt Macy 
2530eda14cbcSMatt Macy typedef struct upgrade_cbdata {
2531eda14cbcSMatt Macy 	uint64_t cb_numupgraded;
2532eda14cbcSMatt Macy 	uint64_t cb_numsamegraded;
2533eda14cbcSMatt Macy 	uint64_t cb_numfailed;
2534eda14cbcSMatt Macy 	uint64_t cb_version;
2535eda14cbcSMatt Macy 	boolean_t cb_newer;
2536eda14cbcSMatt Macy 	boolean_t cb_foundone;
2537eda14cbcSMatt Macy 	char cb_lastfs[ZFS_MAX_DATASET_NAME_LEN];
2538eda14cbcSMatt Macy } upgrade_cbdata_t;
2539eda14cbcSMatt Macy 
2540eda14cbcSMatt Macy static int
2541eda14cbcSMatt Macy same_pool(zfs_handle_t *zhp, const char *name)
2542eda14cbcSMatt Macy {
2543eda14cbcSMatt Macy 	int len1 = strcspn(name, "/@");
2544eda14cbcSMatt Macy 	const char *zhname = zfs_get_name(zhp);
2545eda14cbcSMatt Macy 	int len2 = strcspn(zhname, "/@");
2546eda14cbcSMatt Macy 
2547eda14cbcSMatt Macy 	if (len1 != len2)
2548eda14cbcSMatt Macy 		return (B_FALSE);
2549eda14cbcSMatt Macy 	return (strncmp(name, zhname, len1) == 0);
2550eda14cbcSMatt Macy }
2551eda14cbcSMatt Macy 
2552eda14cbcSMatt Macy static int
2553eda14cbcSMatt Macy upgrade_list_callback(zfs_handle_t *zhp, void *data)
2554eda14cbcSMatt Macy {
2555eda14cbcSMatt Macy 	upgrade_cbdata_t *cb = data;
2556eda14cbcSMatt Macy 	int version = zfs_prop_get_int(zhp, ZFS_PROP_VERSION);
2557eda14cbcSMatt Macy 
2558eda14cbcSMatt Macy 	/* list if it's old/new */
2559eda14cbcSMatt Macy 	if ((!cb->cb_newer && version < ZPL_VERSION) ||
2560eda14cbcSMatt Macy 	    (cb->cb_newer && version > ZPL_VERSION)) {
2561eda14cbcSMatt Macy 		char *str;
2562eda14cbcSMatt Macy 		if (cb->cb_newer) {
2563eda14cbcSMatt Macy 			str = gettext("The following filesystems are "
2564eda14cbcSMatt Macy 			    "formatted using a newer software version and\n"
2565eda14cbcSMatt Macy 			    "cannot be accessed on the current system.\n\n");
2566eda14cbcSMatt Macy 		} else {
2567eda14cbcSMatt Macy 			str = gettext("The following filesystems are "
2568eda14cbcSMatt Macy 			    "out of date, and can be upgraded.  After being\n"
2569eda14cbcSMatt Macy 			    "upgraded, these filesystems (and any 'zfs send' "
2570eda14cbcSMatt Macy 			    "streams generated from\n"
2571eda14cbcSMatt Macy 			    "subsequent snapshots) will no longer be "
2572eda14cbcSMatt Macy 			    "accessible by older software versions.\n\n");
2573eda14cbcSMatt Macy 		}
2574eda14cbcSMatt Macy 
2575eda14cbcSMatt Macy 		if (!cb->cb_foundone) {
2576eda14cbcSMatt Macy 			(void) puts(str);
2577eda14cbcSMatt Macy 			(void) printf(gettext("VER  FILESYSTEM\n"));
2578eda14cbcSMatt Macy 			(void) printf(gettext("---  ------------\n"));
2579eda14cbcSMatt Macy 			cb->cb_foundone = B_TRUE;
2580eda14cbcSMatt Macy 		}
2581eda14cbcSMatt Macy 
2582eda14cbcSMatt Macy 		(void) printf("%2u   %s\n", version, zfs_get_name(zhp));
2583eda14cbcSMatt Macy 	}
2584eda14cbcSMatt Macy 
2585eda14cbcSMatt Macy 	return (0);
2586eda14cbcSMatt Macy }
2587eda14cbcSMatt Macy 
2588eda14cbcSMatt Macy static int
2589eda14cbcSMatt Macy upgrade_set_callback(zfs_handle_t *zhp, void *data)
2590eda14cbcSMatt Macy {
2591eda14cbcSMatt Macy 	upgrade_cbdata_t *cb = data;
2592eda14cbcSMatt Macy 	int version = zfs_prop_get_int(zhp, ZFS_PROP_VERSION);
2593eda14cbcSMatt Macy 	int needed_spa_version;
2594eda14cbcSMatt Macy 	int spa_version;
2595eda14cbcSMatt Macy 
2596eda14cbcSMatt Macy 	if (zfs_spa_version(zhp, &spa_version) < 0)
2597eda14cbcSMatt Macy 		return (-1);
2598eda14cbcSMatt Macy 
2599eda14cbcSMatt Macy 	needed_spa_version = zfs_spa_version_map(cb->cb_version);
2600eda14cbcSMatt Macy 
2601eda14cbcSMatt Macy 	if (needed_spa_version < 0)
2602eda14cbcSMatt Macy 		return (-1);
2603eda14cbcSMatt Macy 
2604eda14cbcSMatt Macy 	if (spa_version < needed_spa_version) {
2605eda14cbcSMatt Macy 		/* can't upgrade */
2606eda14cbcSMatt Macy 		(void) printf(gettext("%s: can not be "
2607eda14cbcSMatt Macy 		    "upgraded; the pool version needs to first "
2608eda14cbcSMatt Macy 		    "be upgraded\nto version %d\n\n"),
2609eda14cbcSMatt Macy 		    zfs_get_name(zhp), needed_spa_version);
2610eda14cbcSMatt Macy 		cb->cb_numfailed++;
2611eda14cbcSMatt Macy 		return (0);
2612eda14cbcSMatt Macy 	}
2613eda14cbcSMatt Macy 
2614eda14cbcSMatt Macy 	/* upgrade */
2615eda14cbcSMatt Macy 	if (version < cb->cb_version) {
2616a0b956f5SMartin Matuska 		char verstr[24];
2617eda14cbcSMatt Macy 		(void) snprintf(verstr, sizeof (verstr),
2618eda14cbcSMatt Macy 		    "%llu", (u_longlong_t)cb->cb_version);
2619eda14cbcSMatt Macy 		if (cb->cb_lastfs[0] && !same_pool(zhp, cb->cb_lastfs)) {
2620eda14cbcSMatt Macy 			/*
2621eda14cbcSMatt Macy 			 * If they did "zfs upgrade -a", then we could
2622eda14cbcSMatt Macy 			 * be doing ioctls to different pools.  We need
2623eda14cbcSMatt Macy 			 * to log this history once to each pool, and bypass
2624eda14cbcSMatt Macy 			 * the normal history logging that happens in main().
2625eda14cbcSMatt Macy 			 */
2626eda14cbcSMatt Macy 			(void) zpool_log_history(g_zfs, history_str);
2627eda14cbcSMatt Macy 			log_history = B_FALSE;
2628eda14cbcSMatt Macy 		}
2629eda14cbcSMatt Macy 		if (zfs_prop_set(zhp, "version", verstr) == 0)
2630eda14cbcSMatt Macy 			cb->cb_numupgraded++;
2631eda14cbcSMatt Macy 		else
2632eda14cbcSMatt Macy 			cb->cb_numfailed++;
2633be181ee2SMartin Matuska 		(void) strlcpy(cb->cb_lastfs, zfs_get_name(zhp),
2634be181ee2SMartin Matuska 		    sizeof (cb->cb_lastfs));
2635eda14cbcSMatt Macy 	} else if (version > cb->cb_version) {
2636eda14cbcSMatt Macy 		/* can't downgrade */
2637eda14cbcSMatt Macy 		(void) printf(gettext("%s: can not be downgraded; "
2638eda14cbcSMatt Macy 		    "it is already at version %u\n"),
2639eda14cbcSMatt Macy 		    zfs_get_name(zhp), version);
2640eda14cbcSMatt Macy 		cb->cb_numfailed++;
2641eda14cbcSMatt Macy 	} else {
2642eda14cbcSMatt Macy 		cb->cb_numsamegraded++;
2643eda14cbcSMatt Macy 	}
2644eda14cbcSMatt Macy 	return (0);
2645eda14cbcSMatt Macy }
2646eda14cbcSMatt Macy 
2647eda14cbcSMatt Macy /*
2648eda14cbcSMatt Macy  * zfs upgrade
2649eda14cbcSMatt Macy  * zfs upgrade -v
2650eda14cbcSMatt Macy  * zfs upgrade [-r] [-V <version>] <-a | filesystem>
2651eda14cbcSMatt Macy  */
2652eda14cbcSMatt Macy static int
2653eda14cbcSMatt Macy zfs_do_upgrade(int argc, char **argv)
2654eda14cbcSMatt Macy {
2655eda14cbcSMatt Macy 	boolean_t all = B_FALSE;
2656eda14cbcSMatt Macy 	boolean_t showversions = B_FALSE;
2657eda14cbcSMatt Macy 	int ret = 0;
2658eda14cbcSMatt Macy 	upgrade_cbdata_t cb = { 0 };
2659eda14cbcSMatt Macy 	int c;
2660eda14cbcSMatt Macy 	int flags = ZFS_ITER_ARGS_CAN_BE_PATHS;
2661eda14cbcSMatt Macy 
2662eda14cbcSMatt Macy 	/* check options */
2663eda14cbcSMatt Macy 	while ((c = getopt(argc, argv, "rvV:a")) != -1) {
2664eda14cbcSMatt Macy 		switch (c) {
2665eda14cbcSMatt Macy 		case 'r':
2666eda14cbcSMatt Macy 			flags |= ZFS_ITER_RECURSE;
2667eda14cbcSMatt Macy 			break;
2668eda14cbcSMatt Macy 		case 'v':
2669eda14cbcSMatt Macy 			showversions = B_TRUE;
2670eda14cbcSMatt Macy 			break;
2671eda14cbcSMatt Macy 		case 'V':
2672eda14cbcSMatt Macy 			if (zfs_prop_string_to_index(ZFS_PROP_VERSION,
2673eda14cbcSMatt Macy 			    optarg, &cb.cb_version) != 0) {
2674eda14cbcSMatt Macy 				(void) fprintf(stderr,
2675eda14cbcSMatt Macy 				    gettext("invalid version %s\n"), optarg);
2676eda14cbcSMatt Macy 				usage(B_FALSE);
2677eda14cbcSMatt Macy 			}
2678eda14cbcSMatt Macy 			break;
2679eda14cbcSMatt Macy 		case 'a':
2680eda14cbcSMatt Macy 			all = B_TRUE;
2681eda14cbcSMatt Macy 			break;
2682eda14cbcSMatt Macy 		case '?':
2683eda14cbcSMatt Macy 		default:
2684eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
2685eda14cbcSMatt Macy 			    optopt);
2686eda14cbcSMatt Macy 			usage(B_FALSE);
2687eda14cbcSMatt Macy 		}
2688eda14cbcSMatt Macy 	}
2689eda14cbcSMatt Macy 
2690eda14cbcSMatt Macy 	argc -= optind;
2691eda14cbcSMatt Macy 	argv += optind;
2692eda14cbcSMatt Macy 
2693eda14cbcSMatt Macy 	if ((!all && !argc) && ((flags & ZFS_ITER_RECURSE) | cb.cb_version))
2694eda14cbcSMatt Macy 		usage(B_FALSE);
2695eda14cbcSMatt Macy 	if (showversions && (flags & ZFS_ITER_RECURSE || all ||
2696eda14cbcSMatt Macy 	    cb.cb_version || argc))
2697eda14cbcSMatt Macy 		usage(B_FALSE);
2698eda14cbcSMatt Macy 	if ((all || argc) && (showversions))
2699eda14cbcSMatt Macy 		usage(B_FALSE);
2700eda14cbcSMatt Macy 	if (all && argc)
2701eda14cbcSMatt Macy 		usage(B_FALSE);
2702eda14cbcSMatt Macy 
2703eda14cbcSMatt Macy 	if (showversions) {
2704eda14cbcSMatt Macy 		/* Show info on available versions. */
2705eda14cbcSMatt Macy 		(void) printf(gettext("The following filesystem versions are "
2706eda14cbcSMatt Macy 		    "supported:\n\n"));
2707eda14cbcSMatt Macy 		(void) printf(gettext("VER  DESCRIPTION\n"));
2708eda14cbcSMatt Macy 		(void) printf("---  -----------------------------------------"
2709eda14cbcSMatt Macy 		    "---------------\n");
2710eda14cbcSMatt Macy 		(void) printf(gettext(" 1   Initial ZFS filesystem version\n"));
2711eda14cbcSMatt Macy 		(void) printf(gettext(" 2   Enhanced directory entries\n"));
2712eda14cbcSMatt Macy 		(void) printf(gettext(" 3   Case insensitive and filesystem "
2713eda14cbcSMatt Macy 		    "user identifier (FUID)\n"));
2714eda14cbcSMatt Macy 		(void) printf(gettext(" 4   userquota, groupquota "
2715eda14cbcSMatt Macy 		    "properties\n"));
2716eda14cbcSMatt Macy 		(void) printf(gettext(" 5   System attributes\n"));
2717eda14cbcSMatt Macy 		(void) printf(gettext("\nFor more information on a particular "
2718eda14cbcSMatt Macy 		    "version, including supported releases,\n"));
2719eda14cbcSMatt Macy 		(void) printf("see the ZFS Administration Guide.\n\n");
2720eda14cbcSMatt Macy 		ret = 0;
2721eda14cbcSMatt Macy 	} else if (argc || all) {
2722eda14cbcSMatt Macy 		/* Upgrade filesystems */
2723eda14cbcSMatt Macy 		if (cb.cb_version == 0)
2724eda14cbcSMatt Macy 			cb.cb_version = ZPL_VERSION;
2725eda14cbcSMatt Macy 		ret = zfs_for_each(argc, argv, flags, ZFS_TYPE_FILESYSTEM,
2726eda14cbcSMatt Macy 		    NULL, NULL, 0, upgrade_set_callback, &cb);
2727eda14cbcSMatt Macy 		(void) printf(gettext("%llu filesystems upgraded\n"),
2728eda14cbcSMatt Macy 		    (u_longlong_t)cb.cb_numupgraded);
2729eda14cbcSMatt Macy 		if (cb.cb_numsamegraded) {
2730eda14cbcSMatt Macy 			(void) printf(gettext("%llu filesystems already at "
2731eda14cbcSMatt Macy 			    "this version\n"),
2732eda14cbcSMatt Macy 			    (u_longlong_t)cb.cb_numsamegraded);
2733eda14cbcSMatt Macy 		}
2734eda14cbcSMatt Macy 		if (cb.cb_numfailed != 0)
2735eda14cbcSMatt Macy 			ret = 1;
2736eda14cbcSMatt Macy 	} else {
2737eda14cbcSMatt Macy 		/* List old-version filesystems */
2738eda14cbcSMatt Macy 		boolean_t found;
2739eda14cbcSMatt Macy 		(void) printf(gettext("This system is currently running "
2740eda14cbcSMatt Macy 		    "ZFS filesystem version %llu.\n\n"), ZPL_VERSION);
2741eda14cbcSMatt Macy 
2742eda14cbcSMatt Macy 		flags |= ZFS_ITER_RECURSE;
2743eda14cbcSMatt Macy 		ret = zfs_for_each(0, NULL, flags, ZFS_TYPE_FILESYSTEM,
2744eda14cbcSMatt Macy 		    NULL, NULL, 0, upgrade_list_callback, &cb);
2745eda14cbcSMatt Macy 
2746eda14cbcSMatt Macy 		found = cb.cb_foundone;
2747eda14cbcSMatt Macy 		cb.cb_foundone = B_FALSE;
2748eda14cbcSMatt Macy 		cb.cb_newer = B_TRUE;
2749eda14cbcSMatt Macy 
2750dbd5678dSMartin Matuska 		ret |= zfs_for_each(0, NULL, flags, ZFS_TYPE_FILESYSTEM,
2751eda14cbcSMatt Macy 		    NULL, NULL, 0, upgrade_list_callback, &cb);
2752eda14cbcSMatt Macy 
2753eda14cbcSMatt Macy 		if (!cb.cb_foundone && !found) {
2754eda14cbcSMatt Macy 			(void) printf(gettext("All filesystems are "
2755eda14cbcSMatt Macy 			    "formatted with the current version.\n"));
2756eda14cbcSMatt Macy 		}
2757eda14cbcSMatt Macy 	}
2758eda14cbcSMatt Macy 
2759eda14cbcSMatt Macy 	return (ret);
2760eda14cbcSMatt Macy }
2761eda14cbcSMatt Macy 
2762eda14cbcSMatt Macy /*
2763eda14cbcSMatt Macy  * zfs userspace [-Hinp] [-o field[,...]] [-s field [-s field]...]
2764c40487d4SMatt Macy  *               [-S field [-S field]...] [-t type[,...]]
2765c40487d4SMatt Macy  *               filesystem | snapshot | path
2766eda14cbcSMatt Macy  * zfs groupspace [-Hinp] [-o field[,...]] [-s field [-s field]...]
2767c40487d4SMatt Macy  *                [-S field [-S field]...] [-t type[,...]]
2768c40487d4SMatt Macy  *                filesystem | snapshot | path
2769eda14cbcSMatt Macy  * zfs projectspace [-Hp] [-o field[,...]] [-s field [-s field]...]
2770c40487d4SMatt Macy  *                [-S field [-S field]...] filesystem | snapshot | path
2771eda14cbcSMatt Macy  *
2772eda14cbcSMatt Macy  *	-H      Scripted mode; elide headers and separate columns by tabs.
2773eda14cbcSMatt Macy  *	-i	Translate SID to POSIX ID.
2774eda14cbcSMatt Macy  *	-n	Print numeric ID instead of user/group name.
2775eda14cbcSMatt Macy  *	-o      Control which fields to display.
2776eda14cbcSMatt Macy  *	-p	Use exact (parsable) numeric output.
2777eda14cbcSMatt Macy  *	-s      Specify sort columns, descending order.
2778eda14cbcSMatt Macy  *	-S      Specify sort columns, ascending order.
2779eda14cbcSMatt Macy  *	-t      Control which object types to display.
2780eda14cbcSMatt Macy  *
2781eda14cbcSMatt Macy  *	Displays space consumed by, and quotas on, each user in the specified
2782eda14cbcSMatt Macy  *	filesystem or snapshot.
2783eda14cbcSMatt Macy  */
2784eda14cbcSMatt Macy 
2785eda14cbcSMatt Macy /* us_field_types, us_field_hdr and us_field_names should be kept in sync */
2786eda14cbcSMatt Macy enum us_field_types {
2787eda14cbcSMatt Macy 	USFIELD_TYPE,
2788eda14cbcSMatt Macy 	USFIELD_NAME,
2789eda14cbcSMatt Macy 	USFIELD_USED,
2790eda14cbcSMatt Macy 	USFIELD_QUOTA,
2791eda14cbcSMatt Macy 	USFIELD_OBJUSED,
2792eda14cbcSMatt Macy 	USFIELD_OBJQUOTA
2793eda14cbcSMatt Macy };
2794a0b956f5SMartin Matuska static const char *const us_field_hdr[] = { "TYPE", "NAME", "USED", "QUOTA",
2795eda14cbcSMatt Macy 				    "OBJUSED", "OBJQUOTA" };
2796a0b956f5SMartin Matuska static const char *const us_field_names[] = { "type", "name", "used", "quota",
2797eda14cbcSMatt Macy 				    "objused", "objquota" };
2798eda14cbcSMatt Macy #define	USFIELD_LAST	(sizeof (us_field_names) / sizeof (char *))
2799eda14cbcSMatt Macy 
2800eda14cbcSMatt Macy #define	USTYPE_PSX_GRP	(1 << 0)
2801eda14cbcSMatt Macy #define	USTYPE_PSX_USR	(1 << 1)
2802eda14cbcSMatt Macy #define	USTYPE_SMB_GRP	(1 << 2)
2803eda14cbcSMatt Macy #define	USTYPE_SMB_USR	(1 << 3)
2804eda14cbcSMatt Macy #define	USTYPE_PROJ	(1 << 4)
2805eda14cbcSMatt Macy #define	USTYPE_ALL	\
2806eda14cbcSMatt Macy 	(USTYPE_PSX_GRP | USTYPE_PSX_USR | USTYPE_SMB_GRP | USTYPE_SMB_USR | \
2807eda14cbcSMatt Macy 	    USTYPE_PROJ)
2808eda14cbcSMatt Macy 
2809eda14cbcSMatt Macy static int us_type_bits[] = {
2810eda14cbcSMatt Macy 	USTYPE_PSX_GRP,
2811eda14cbcSMatt Macy 	USTYPE_PSX_USR,
2812eda14cbcSMatt Macy 	USTYPE_SMB_GRP,
2813eda14cbcSMatt Macy 	USTYPE_SMB_USR,
2814eda14cbcSMatt Macy 	USTYPE_ALL
2815eda14cbcSMatt Macy };
2816a0b956f5SMartin Matuska static const char *const us_type_names[] = { "posixgroup", "posixuser",
2817a0b956f5SMartin Matuska 	"smbgroup", "smbuser", "all" };
2818eda14cbcSMatt Macy 
2819eda14cbcSMatt Macy typedef struct us_node {
2820eda14cbcSMatt Macy 	nvlist_t	*usn_nvl;
2821eda14cbcSMatt Macy 	uu_avl_node_t	usn_avlnode;
2822eda14cbcSMatt Macy 	uu_list_node_t	usn_listnode;
2823eda14cbcSMatt Macy } us_node_t;
2824eda14cbcSMatt Macy 
2825eda14cbcSMatt Macy typedef struct us_cbdata {
2826eda14cbcSMatt Macy 	nvlist_t	**cb_nvlp;
2827eda14cbcSMatt Macy 	uu_avl_pool_t	*cb_avl_pool;
2828eda14cbcSMatt Macy 	uu_avl_t	*cb_avl;
2829eda14cbcSMatt Macy 	boolean_t	cb_numname;
2830eda14cbcSMatt Macy 	boolean_t	cb_nicenum;
2831eda14cbcSMatt Macy 	boolean_t	cb_sid2posix;
2832eda14cbcSMatt Macy 	zfs_userquota_prop_t cb_prop;
2833eda14cbcSMatt Macy 	zfs_sort_column_t *cb_sortcol;
2834eda14cbcSMatt Macy 	size_t		cb_width[USFIELD_LAST];
2835eda14cbcSMatt Macy } us_cbdata_t;
2836eda14cbcSMatt Macy 
2837eda14cbcSMatt Macy static boolean_t us_populated = B_FALSE;
2838eda14cbcSMatt Macy 
2839eda14cbcSMatt Macy typedef struct {
2840eda14cbcSMatt Macy 	zfs_sort_column_t *si_sortcol;
2841eda14cbcSMatt Macy 	boolean_t	si_numname;
2842eda14cbcSMatt Macy } us_sort_info_t;
2843eda14cbcSMatt Macy 
2844eda14cbcSMatt Macy static int
2845a0b956f5SMartin Matuska us_field_index(const char *field)
2846eda14cbcSMatt Macy {
2847a0b956f5SMartin Matuska 	for (int i = 0; i < USFIELD_LAST; i++) {
2848eda14cbcSMatt Macy 		if (strcmp(field, us_field_names[i]) == 0)
2849eda14cbcSMatt Macy 			return (i);
2850eda14cbcSMatt Macy 	}
2851eda14cbcSMatt Macy 
2852eda14cbcSMatt Macy 	return (-1);
2853eda14cbcSMatt Macy }
2854eda14cbcSMatt Macy 
2855eda14cbcSMatt Macy static int
2856eda14cbcSMatt Macy us_compare(const void *larg, const void *rarg, void *unused)
2857eda14cbcSMatt Macy {
2858eda14cbcSMatt Macy 	const us_node_t *l = larg;
2859eda14cbcSMatt Macy 	const us_node_t *r = rarg;
2860eda14cbcSMatt Macy 	us_sort_info_t *si = (us_sort_info_t *)unused;
2861eda14cbcSMatt Macy 	zfs_sort_column_t *sortcol = si->si_sortcol;
2862eda14cbcSMatt Macy 	boolean_t numname = si->si_numname;
2863eda14cbcSMatt Macy 	nvlist_t *lnvl = l->usn_nvl;
2864eda14cbcSMatt Macy 	nvlist_t *rnvl = r->usn_nvl;
2865eda14cbcSMatt Macy 	int rc = 0;
2866eda14cbcSMatt Macy 	boolean_t lvb, rvb;
2867eda14cbcSMatt Macy 
2868eda14cbcSMatt Macy 	for (; sortcol != NULL; sortcol = sortcol->sc_next) {
28692a58b312SMartin Matuska 		const char *lvstr = "";
28702a58b312SMartin Matuska 		const char *rvstr = "";
2871eda14cbcSMatt Macy 		uint32_t lv32 = 0;
2872eda14cbcSMatt Macy 		uint32_t rv32 = 0;
2873eda14cbcSMatt Macy 		uint64_t lv64 = 0;
2874eda14cbcSMatt Macy 		uint64_t rv64 = 0;
2875eda14cbcSMatt Macy 		zfs_prop_t prop = sortcol->sc_prop;
2876eda14cbcSMatt Macy 		const char *propname = NULL;
2877eda14cbcSMatt Macy 		boolean_t reverse = sortcol->sc_reverse;
2878eda14cbcSMatt Macy 
2879eda14cbcSMatt Macy 		switch (prop) {
2880eda14cbcSMatt Macy 		case ZFS_PROP_TYPE:
2881eda14cbcSMatt Macy 			propname = "type";
2882eda14cbcSMatt Macy 			(void) nvlist_lookup_uint32(lnvl, propname, &lv32);
2883eda14cbcSMatt Macy 			(void) nvlist_lookup_uint32(rnvl, propname, &rv32);
2884eda14cbcSMatt Macy 			if (rv32 != lv32)
2885eda14cbcSMatt Macy 				rc = (rv32 < lv32) ? 1 : -1;
2886eda14cbcSMatt Macy 			break;
2887eda14cbcSMatt Macy 		case ZFS_PROP_NAME:
2888eda14cbcSMatt Macy 			propname = "name";
2889eda14cbcSMatt Macy 			if (numname) {
2890eda14cbcSMatt Macy compare_nums:
2891eda14cbcSMatt Macy 				(void) nvlist_lookup_uint64(lnvl, propname,
2892eda14cbcSMatt Macy 				    &lv64);
2893eda14cbcSMatt Macy 				(void) nvlist_lookup_uint64(rnvl, propname,
2894eda14cbcSMatt Macy 				    &rv64);
2895eda14cbcSMatt Macy 				if (rv64 != lv64)
2896eda14cbcSMatt Macy 					rc = (rv64 < lv64) ? 1 : -1;
2897eda14cbcSMatt Macy 			} else {
2898eda14cbcSMatt Macy 				if ((nvlist_lookup_string(lnvl, propname,
2899eda14cbcSMatt Macy 				    &lvstr) == ENOENT) ||
2900eda14cbcSMatt Macy 				    (nvlist_lookup_string(rnvl, propname,
2901eda14cbcSMatt Macy 				    &rvstr) == ENOENT)) {
2902eda14cbcSMatt Macy 					goto compare_nums;
2903eda14cbcSMatt Macy 				}
2904eda14cbcSMatt Macy 				rc = strcmp(lvstr, rvstr);
2905eda14cbcSMatt Macy 			}
2906eda14cbcSMatt Macy 			break;
2907eda14cbcSMatt Macy 		case ZFS_PROP_USED:
2908eda14cbcSMatt Macy 		case ZFS_PROP_QUOTA:
2909eda14cbcSMatt Macy 			if (!us_populated)
2910eda14cbcSMatt Macy 				break;
2911eda14cbcSMatt Macy 			if (prop == ZFS_PROP_USED)
2912eda14cbcSMatt Macy 				propname = "used";
2913eda14cbcSMatt Macy 			else
2914eda14cbcSMatt Macy 				propname = "quota";
2915eda14cbcSMatt Macy 			(void) nvlist_lookup_uint64(lnvl, propname, &lv64);
2916eda14cbcSMatt Macy 			(void) nvlist_lookup_uint64(rnvl, propname, &rv64);
2917eda14cbcSMatt Macy 			if (rv64 != lv64)
2918eda14cbcSMatt Macy 				rc = (rv64 < lv64) ? 1 : -1;
2919eda14cbcSMatt Macy 			break;
2920eda14cbcSMatt Macy 
2921eda14cbcSMatt Macy 		default:
2922eda14cbcSMatt Macy 			break;
2923eda14cbcSMatt Macy 		}
2924eda14cbcSMatt Macy 
2925eda14cbcSMatt Macy 		if (rc != 0) {
2926eda14cbcSMatt Macy 			if (rc < 0)
2927eda14cbcSMatt Macy 				return (reverse ? 1 : -1);
2928eda14cbcSMatt Macy 			else
2929eda14cbcSMatt Macy 				return (reverse ? -1 : 1);
2930eda14cbcSMatt Macy 		}
2931eda14cbcSMatt Macy 	}
2932eda14cbcSMatt Macy 
2933eda14cbcSMatt Macy 	/*
2934eda14cbcSMatt Macy 	 * If entries still seem to be the same, check if they are of the same
2935eda14cbcSMatt Macy 	 * type (smbentity is added only if we are doing SID to POSIX ID
2936eda14cbcSMatt Macy 	 * translation where we can have duplicate type/name combinations).
2937eda14cbcSMatt Macy 	 */
2938eda14cbcSMatt Macy 	if (nvlist_lookup_boolean_value(lnvl, "smbentity", &lvb) == 0 &&
2939eda14cbcSMatt Macy 	    nvlist_lookup_boolean_value(rnvl, "smbentity", &rvb) == 0 &&
2940eda14cbcSMatt Macy 	    lvb != rvb)
2941eda14cbcSMatt Macy 		return (lvb < rvb ? -1 : 1);
2942eda14cbcSMatt Macy 
2943eda14cbcSMatt Macy 	return (0);
2944eda14cbcSMatt Macy }
2945eda14cbcSMatt Macy 
2946eda14cbcSMatt Macy static boolean_t
2947eda14cbcSMatt Macy zfs_prop_is_user(unsigned p)
2948eda14cbcSMatt Macy {
2949eda14cbcSMatt Macy 	return (p == ZFS_PROP_USERUSED || p == ZFS_PROP_USERQUOTA ||
2950eda14cbcSMatt Macy 	    p == ZFS_PROP_USEROBJUSED || p == ZFS_PROP_USEROBJQUOTA);
2951eda14cbcSMatt Macy }
2952eda14cbcSMatt Macy 
2953eda14cbcSMatt Macy static boolean_t
2954eda14cbcSMatt Macy zfs_prop_is_group(unsigned p)
2955eda14cbcSMatt Macy {
2956eda14cbcSMatt Macy 	return (p == ZFS_PROP_GROUPUSED || p == ZFS_PROP_GROUPQUOTA ||
2957eda14cbcSMatt Macy 	    p == ZFS_PROP_GROUPOBJUSED || p == ZFS_PROP_GROUPOBJQUOTA);
2958eda14cbcSMatt Macy }
2959eda14cbcSMatt Macy 
2960eda14cbcSMatt Macy static boolean_t
2961eda14cbcSMatt Macy zfs_prop_is_project(unsigned p)
2962eda14cbcSMatt Macy {
2963eda14cbcSMatt Macy 	return (p == ZFS_PROP_PROJECTUSED || p == ZFS_PROP_PROJECTQUOTA ||
2964eda14cbcSMatt Macy 	    p == ZFS_PROP_PROJECTOBJUSED || p == ZFS_PROP_PROJECTOBJQUOTA);
2965eda14cbcSMatt Macy }
2966eda14cbcSMatt Macy 
2967eda14cbcSMatt Macy static inline const char *
2968eda14cbcSMatt Macy us_type2str(unsigned field_type)
2969eda14cbcSMatt Macy {
2970eda14cbcSMatt Macy 	switch (field_type) {
2971eda14cbcSMatt Macy 	case USTYPE_PSX_USR:
2972eda14cbcSMatt Macy 		return ("POSIX User");
2973eda14cbcSMatt Macy 	case USTYPE_PSX_GRP:
2974eda14cbcSMatt Macy 		return ("POSIX Group");
2975eda14cbcSMatt Macy 	case USTYPE_SMB_USR:
2976eda14cbcSMatt Macy 		return ("SMB User");
2977eda14cbcSMatt Macy 	case USTYPE_SMB_GRP:
2978eda14cbcSMatt Macy 		return ("SMB Group");
2979eda14cbcSMatt Macy 	case USTYPE_PROJ:
2980eda14cbcSMatt Macy 		return ("Project");
2981eda14cbcSMatt Macy 	default:
2982eda14cbcSMatt Macy 		return ("Undefined");
2983eda14cbcSMatt Macy 	}
2984eda14cbcSMatt Macy }
2985eda14cbcSMatt Macy 
2986eda14cbcSMatt Macy static int
2987eda14cbcSMatt Macy userspace_cb(void *arg, const char *domain, uid_t rid, uint64_t space)
2988eda14cbcSMatt Macy {
2989eda14cbcSMatt Macy 	us_cbdata_t *cb = (us_cbdata_t *)arg;
2990eda14cbcSMatt Macy 	zfs_userquota_prop_t prop = cb->cb_prop;
2991eda14cbcSMatt Macy 	char *name = NULL;
2992a0b956f5SMartin Matuska 	const char *propname;
2993eda14cbcSMatt Macy 	char sizebuf[32];
2994eda14cbcSMatt Macy 	us_node_t *node;
2995eda14cbcSMatt Macy 	uu_avl_pool_t *avl_pool = cb->cb_avl_pool;
2996eda14cbcSMatt Macy 	uu_avl_t *avl = cb->cb_avl;
2997eda14cbcSMatt Macy 	uu_avl_index_t idx;
2998eda14cbcSMatt Macy 	nvlist_t *props;
2999eda14cbcSMatt Macy 	us_node_t *n;
3000eda14cbcSMatt Macy 	zfs_sort_column_t *sortcol = cb->cb_sortcol;
3001eda14cbcSMatt Macy 	unsigned type = 0;
3002eda14cbcSMatt Macy 	const char *typestr;
3003eda14cbcSMatt Macy 	size_t namelen;
3004eda14cbcSMatt Macy 	size_t typelen;
3005eda14cbcSMatt Macy 	size_t sizelen;
3006eda14cbcSMatt Macy 	int typeidx, nameidx, sizeidx;
3007eda14cbcSMatt Macy 	us_sort_info_t sortinfo = { sortcol, cb->cb_numname };
3008eda14cbcSMatt Macy 	boolean_t smbentity = B_FALSE;
3009eda14cbcSMatt Macy 
3010eda14cbcSMatt Macy 	if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0)
3011eda14cbcSMatt Macy 		nomem();
3012eda14cbcSMatt Macy 	node = safe_malloc(sizeof (us_node_t));
3013eda14cbcSMatt Macy 	uu_avl_node_init(node, &node->usn_avlnode, avl_pool);
3014eda14cbcSMatt Macy 	node->usn_nvl = props;
3015eda14cbcSMatt Macy 
3016eda14cbcSMatt Macy 	if (domain != NULL && domain[0] != '\0') {
3017eda14cbcSMatt Macy #ifdef HAVE_IDMAP
3018eda14cbcSMatt Macy 		/* SMB */
3019eda14cbcSMatt Macy 		char sid[MAXNAMELEN + 32];
3020eda14cbcSMatt Macy 		uid_t id;
3021eda14cbcSMatt Macy 		uint64_t classes;
3022eda14cbcSMatt Macy 		int err;
3023eda14cbcSMatt Macy 		directory_error_t e;
3024eda14cbcSMatt Macy 
3025eda14cbcSMatt Macy 		smbentity = B_TRUE;
3026eda14cbcSMatt Macy 
3027eda14cbcSMatt Macy 		(void) snprintf(sid, sizeof (sid), "%s-%u", domain, rid);
3028eda14cbcSMatt Macy 
3029eda14cbcSMatt Macy 		if (prop == ZFS_PROP_GROUPUSED || prop == ZFS_PROP_GROUPQUOTA) {
3030eda14cbcSMatt Macy 			type = USTYPE_SMB_GRP;
3031eda14cbcSMatt Macy 			err = sid_to_id(sid, B_FALSE, &id);
3032eda14cbcSMatt Macy 		} else {
3033eda14cbcSMatt Macy 			type = USTYPE_SMB_USR;
3034eda14cbcSMatt Macy 			err = sid_to_id(sid, B_TRUE, &id);
3035eda14cbcSMatt Macy 		}
3036eda14cbcSMatt Macy 
3037eda14cbcSMatt Macy 		if (err == 0) {
3038eda14cbcSMatt Macy 			rid = id;
3039eda14cbcSMatt Macy 			if (!cb->cb_sid2posix) {
3040eda14cbcSMatt Macy 				e = directory_name_from_sid(NULL, sid, &name,
3041eda14cbcSMatt Macy 				    &classes);
3042eda14cbcSMatt Macy 				if (e != NULL)
3043eda14cbcSMatt Macy 					directory_error_free(e);
3044eda14cbcSMatt Macy 				if (name == NULL)
3045eda14cbcSMatt Macy 					name = sid;
3046eda14cbcSMatt Macy 			}
3047eda14cbcSMatt Macy 		}
3048eda14cbcSMatt Macy #else
3049eda14cbcSMatt Macy 		nvlist_free(props);
3050eda14cbcSMatt Macy 		free(node);
3051eda14cbcSMatt Macy 
3052eda14cbcSMatt Macy 		return (-1);
3053eda14cbcSMatt Macy #endif /* HAVE_IDMAP */
3054eda14cbcSMatt Macy 	}
3055eda14cbcSMatt Macy 
3056eda14cbcSMatt Macy 	if (cb->cb_sid2posix || domain == NULL || domain[0] == '\0') {
3057eda14cbcSMatt Macy 		/* POSIX or -i */
3058eda14cbcSMatt Macy 		if (zfs_prop_is_group(prop)) {
3059eda14cbcSMatt Macy 			type = USTYPE_PSX_GRP;
3060eda14cbcSMatt Macy 			if (!cb->cb_numname) {
3061eda14cbcSMatt Macy 				struct group *g;
3062eda14cbcSMatt Macy 
3063eda14cbcSMatt Macy 				if ((g = getgrgid(rid)) != NULL)
3064eda14cbcSMatt Macy 					name = g->gr_name;
3065eda14cbcSMatt Macy 			}
3066eda14cbcSMatt Macy 		} else if (zfs_prop_is_user(prop)) {
3067eda14cbcSMatt Macy 			type = USTYPE_PSX_USR;
3068eda14cbcSMatt Macy 			if (!cb->cb_numname) {
3069eda14cbcSMatt Macy 				struct passwd *p;
3070eda14cbcSMatt Macy 
3071eda14cbcSMatt Macy 				if ((p = getpwuid(rid)) != NULL)
3072eda14cbcSMatt Macy 					name = p->pw_name;
3073eda14cbcSMatt Macy 			}
3074eda14cbcSMatt Macy 		} else {
3075eda14cbcSMatt Macy 			type = USTYPE_PROJ;
3076eda14cbcSMatt Macy 		}
3077eda14cbcSMatt Macy 	}
3078eda14cbcSMatt Macy 
3079eda14cbcSMatt Macy 	/*
3080eda14cbcSMatt Macy 	 * Make sure that the type/name combination is unique when doing
3081eda14cbcSMatt Macy 	 * SID to POSIX ID translation (hence changing the type from SMB to
3082eda14cbcSMatt Macy 	 * POSIX).
3083eda14cbcSMatt Macy 	 */
3084eda14cbcSMatt Macy 	if (cb->cb_sid2posix &&
3085eda14cbcSMatt Macy 	    nvlist_add_boolean_value(props, "smbentity", smbentity) != 0)
3086eda14cbcSMatt Macy 		nomem();
3087eda14cbcSMatt Macy 
3088eda14cbcSMatt Macy 	/* Calculate/update width of TYPE field */
3089eda14cbcSMatt Macy 	typestr = us_type2str(type);
3090eda14cbcSMatt Macy 	typelen = strlen(gettext(typestr));
3091eda14cbcSMatt Macy 	typeidx = us_field_index("type");
3092eda14cbcSMatt Macy 	if (typelen > cb->cb_width[typeidx])
3093eda14cbcSMatt Macy 		cb->cb_width[typeidx] = typelen;
3094eda14cbcSMatt Macy 	if (nvlist_add_uint32(props, "type", type) != 0)
3095eda14cbcSMatt Macy 		nomem();
3096eda14cbcSMatt Macy 
3097eda14cbcSMatt Macy 	/* Calculate/update width of NAME field */
3098eda14cbcSMatt Macy 	if ((cb->cb_numname && cb->cb_sid2posix) || name == NULL) {
3099eda14cbcSMatt Macy 		if (nvlist_add_uint64(props, "name", rid) != 0)
3100eda14cbcSMatt Macy 			nomem();
3101eda14cbcSMatt Macy 		namelen = snprintf(NULL, 0, "%u", rid);
3102eda14cbcSMatt Macy 	} else {
3103eda14cbcSMatt Macy 		if (nvlist_add_string(props, "name", name) != 0)
3104eda14cbcSMatt Macy 			nomem();
3105eda14cbcSMatt Macy 		namelen = strlen(name);
3106eda14cbcSMatt Macy 	}
3107eda14cbcSMatt Macy 	nameidx = us_field_index("name");
3108eda14cbcSMatt Macy 	if (nameidx >= 0 && namelen > cb->cb_width[nameidx])
3109eda14cbcSMatt Macy 		cb->cb_width[nameidx] = namelen;
3110eda14cbcSMatt Macy 
3111eda14cbcSMatt Macy 	/*
3112eda14cbcSMatt Macy 	 * Check if this type/name combination is in the list and update it;
3113eda14cbcSMatt Macy 	 * otherwise add new node to the list.
3114eda14cbcSMatt Macy 	 */
3115eda14cbcSMatt Macy 	if ((n = uu_avl_find(avl, node, &sortinfo, &idx)) == NULL) {
3116eda14cbcSMatt Macy 		uu_avl_insert(avl, node, idx);
3117eda14cbcSMatt Macy 	} else {
3118eda14cbcSMatt Macy 		nvlist_free(props);
3119eda14cbcSMatt Macy 		free(node);
3120eda14cbcSMatt Macy 		node = n;
3121eda14cbcSMatt Macy 		props = node->usn_nvl;
3122eda14cbcSMatt Macy 	}
3123eda14cbcSMatt Macy 
3124eda14cbcSMatt Macy 	/* Calculate/update width of USED/QUOTA fields */
3125eda14cbcSMatt Macy 	if (cb->cb_nicenum) {
3126eda14cbcSMatt Macy 		if (prop == ZFS_PROP_USERUSED || prop == ZFS_PROP_GROUPUSED ||
3127eda14cbcSMatt Macy 		    prop == ZFS_PROP_USERQUOTA || prop == ZFS_PROP_GROUPQUOTA ||
3128eda14cbcSMatt Macy 		    prop == ZFS_PROP_PROJECTUSED ||
3129eda14cbcSMatt Macy 		    prop == ZFS_PROP_PROJECTQUOTA) {
3130eda14cbcSMatt Macy 			zfs_nicebytes(space, sizebuf, sizeof (sizebuf));
3131eda14cbcSMatt Macy 		} else {
3132eda14cbcSMatt Macy 			zfs_nicenum(space, sizebuf, sizeof (sizebuf));
3133eda14cbcSMatt Macy 		}
3134eda14cbcSMatt Macy 	} else {
3135eda14cbcSMatt Macy 		(void) snprintf(sizebuf, sizeof (sizebuf), "%llu",
3136eda14cbcSMatt Macy 		    (u_longlong_t)space);
3137eda14cbcSMatt Macy 	}
3138eda14cbcSMatt Macy 	sizelen = strlen(sizebuf);
3139eda14cbcSMatt Macy 	if (prop == ZFS_PROP_USERUSED || prop == ZFS_PROP_GROUPUSED ||
3140eda14cbcSMatt Macy 	    prop == ZFS_PROP_PROJECTUSED) {
3141eda14cbcSMatt Macy 		propname = "used";
3142eda14cbcSMatt Macy 		if (!nvlist_exists(props, "quota"))
3143eda14cbcSMatt Macy 			(void) nvlist_add_uint64(props, "quota", 0);
3144eda14cbcSMatt Macy 	} else if (prop == ZFS_PROP_USERQUOTA || prop == ZFS_PROP_GROUPQUOTA ||
3145eda14cbcSMatt Macy 	    prop == ZFS_PROP_PROJECTQUOTA) {
3146eda14cbcSMatt Macy 		propname = "quota";
3147eda14cbcSMatt Macy 		if (!nvlist_exists(props, "used"))
3148eda14cbcSMatt Macy 			(void) nvlist_add_uint64(props, "used", 0);
3149eda14cbcSMatt Macy 	} else if (prop == ZFS_PROP_USEROBJUSED ||
3150eda14cbcSMatt Macy 	    prop == ZFS_PROP_GROUPOBJUSED || prop == ZFS_PROP_PROJECTOBJUSED) {
3151eda14cbcSMatt Macy 		propname = "objused";
3152eda14cbcSMatt Macy 		if (!nvlist_exists(props, "objquota"))
3153eda14cbcSMatt Macy 			(void) nvlist_add_uint64(props, "objquota", 0);
3154eda14cbcSMatt Macy 	} else if (prop == ZFS_PROP_USEROBJQUOTA ||
3155eda14cbcSMatt Macy 	    prop == ZFS_PROP_GROUPOBJQUOTA ||
3156eda14cbcSMatt Macy 	    prop == ZFS_PROP_PROJECTOBJQUOTA) {
3157eda14cbcSMatt Macy 		propname = "objquota";
3158eda14cbcSMatt Macy 		if (!nvlist_exists(props, "objused"))
3159eda14cbcSMatt Macy 			(void) nvlist_add_uint64(props, "objused", 0);
3160eda14cbcSMatt Macy 	} else {
3161eda14cbcSMatt Macy 		return (-1);
3162eda14cbcSMatt Macy 	}
3163eda14cbcSMatt Macy 	sizeidx = us_field_index(propname);
3164eda14cbcSMatt Macy 	if (sizeidx >= 0 && sizelen > cb->cb_width[sizeidx])
3165eda14cbcSMatt Macy 		cb->cb_width[sizeidx] = sizelen;
3166eda14cbcSMatt Macy 
3167eda14cbcSMatt Macy 	if (nvlist_add_uint64(props, propname, space) != 0)
3168eda14cbcSMatt Macy 		nomem();
3169eda14cbcSMatt Macy 
3170eda14cbcSMatt Macy 	return (0);
3171eda14cbcSMatt Macy }
3172eda14cbcSMatt Macy 
3173eda14cbcSMatt Macy static void
3174eda14cbcSMatt Macy print_us_node(boolean_t scripted, boolean_t parsable, int *fields, int types,
3175eda14cbcSMatt Macy     size_t *width, us_node_t *node)
3176eda14cbcSMatt Macy {
3177eda14cbcSMatt Macy 	nvlist_t *nvl = node->usn_nvl;
3178eda14cbcSMatt Macy 	char valstr[MAXNAMELEN];
3179eda14cbcSMatt Macy 	boolean_t first = B_TRUE;
3180eda14cbcSMatt Macy 	int cfield = 0;
3181eda14cbcSMatt Macy 	int field;
3182eda14cbcSMatt Macy 	uint32_t ustype;
3183eda14cbcSMatt Macy 
3184eda14cbcSMatt Macy 	/* Check type */
3185eda14cbcSMatt Macy 	(void) nvlist_lookup_uint32(nvl, "type", &ustype);
3186eda14cbcSMatt Macy 	if (!(ustype & types))
3187eda14cbcSMatt Macy 		return;
3188eda14cbcSMatt Macy 
3189eda14cbcSMatt Macy 	while ((field = fields[cfield]) != USFIELD_LAST) {
3190eda14cbcSMatt Macy 		nvpair_t *nvp = NULL;
3191eda14cbcSMatt Macy 		data_type_t type;
3192a0b956f5SMartin Matuska 		uint32_t val32 = -1;
3193a0b956f5SMartin Matuska 		uint64_t val64 = -1;
3194a0b956f5SMartin Matuska 		const char *strval = "-";
3195eda14cbcSMatt Macy 
3196a0b956f5SMartin Matuska 		while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL)
3197eda14cbcSMatt Macy 			if (strcmp(nvpair_name(nvp),
3198eda14cbcSMatt Macy 			    us_field_names[field]) == 0)
3199eda14cbcSMatt Macy 				break;
3200eda14cbcSMatt Macy 
3201eda14cbcSMatt Macy 		type = nvp == NULL ? DATA_TYPE_UNKNOWN : nvpair_type(nvp);
3202eda14cbcSMatt Macy 		switch (type) {
3203eda14cbcSMatt Macy 		case DATA_TYPE_UINT32:
3204a0b956f5SMartin Matuska 			val32 = fnvpair_value_uint32(nvp);
3205eda14cbcSMatt Macy 			break;
3206eda14cbcSMatt Macy 		case DATA_TYPE_UINT64:
3207a0b956f5SMartin Matuska 			val64 = fnvpair_value_uint64(nvp);
3208eda14cbcSMatt Macy 			break;
3209eda14cbcSMatt Macy 		case DATA_TYPE_STRING:
3210a0b956f5SMartin Matuska 			strval = fnvpair_value_string(nvp);
3211eda14cbcSMatt Macy 			break;
3212eda14cbcSMatt Macy 		case DATA_TYPE_UNKNOWN:
3213eda14cbcSMatt Macy 			break;
3214eda14cbcSMatt Macy 		default:
3215eda14cbcSMatt Macy 			(void) fprintf(stderr, "invalid data type\n");
3216eda14cbcSMatt Macy 		}
3217eda14cbcSMatt Macy 
3218eda14cbcSMatt Macy 		switch (field) {
3219eda14cbcSMatt Macy 		case USFIELD_TYPE:
3220eda14cbcSMatt Macy 			if (type == DATA_TYPE_UINT32)
3221a0b956f5SMartin Matuska 				strval = us_type2str(val32);
3222eda14cbcSMatt Macy 			break;
3223eda14cbcSMatt Macy 		case USFIELD_NAME:
3224eda14cbcSMatt Macy 			if (type == DATA_TYPE_UINT64) {
3225eda14cbcSMatt Macy 				(void) sprintf(valstr, "%llu",
3226eda14cbcSMatt Macy 				    (u_longlong_t)val64);
3227eda14cbcSMatt Macy 				strval = valstr;
3228eda14cbcSMatt Macy 			}
3229eda14cbcSMatt Macy 			break;
3230eda14cbcSMatt Macy 		case USFIELD_USED:
3231eda14cbcSMatt Macy 		case USFIELD_QUOTA:
3232eda14cbcSMatt Macy 			if (type == DATA_TYPE_UINT64) {
3233eda14cbcSMatt Macy 				if (parsable) {
3234eda14cbcSMatt Macy 					(void) sprintf(valstr, "%llu",
3235eda14cbcSMatt Macy 					    (u_longlong_t)val64);
3236eda14cbcSMatt Macy 					strval = valstr;
3237eda14cbcSMatt Macy 				} else if (field == USFIELD_QUOTA &&
3238eda14cbcSMatt Macy 				    val64 == 0) {
3239eda14cbcSMatt Macy 					strval = "none";
3240eda14cbcSMatt Macy 				} else {
3241eda14cbcSMatt Macy 					zfs_nicebytes(val64, valstr,
3242eda14cbcSMatt Macy 					    sizeof (valstr));
3243eda14cbcSMatt Macy 					strval = valstr;
3244eda14cbcSMatt Macy 				}
3245eda14cbcSMatt Macy 			}
3246eda14cbcSMatt Macy 			break;
3247eda14cbcSMatt Macy 		case USFIELD_OBJUSED:
3248eda14cbcSMatt Macy 		case USFIELD_OBJQUOTA:
3249eda14cbcSMatt Macy 			if (type == DATA_TYPE_UINT64) {
3250eda14cbcSMatt Macy 				if (parsable) {
3251eda14cbcSMatt Macy 					(void) sprintf(valstr, "%llu",
3252eda14cbcSMatt Macy 					    (u_longlong_t)val64);
3253eda14cbcSMatt Macy 					strval = valstr;
3254eda14cbcSMatt Macy 				} else if (field == USFIELD_OBJQUOTA &&
3255eda14cbcSMatt Macy 				    val64 == 0) {
3256eda14cbcSMatt Macy 					strval = "none";
3257eda14cbcSMatt Macy 				} else {
3258eda14cbcSMatt Macy 					zfs_nicenum(val64, valstr,
3259eda14cbcSMatt Macy 					    sizeof (valstr));
3260eda14cbcSMatt Macy 					strval = valstr;
3261eda14cbcSMatt Macy 				}
3262eda14cbcSMatt Macy 			}
3263eda14cbcSMatt Macy 			break;
3264eda14cbcSMatt Macy 		}
3265eda14cbcSMatt Macy 
3266eda14cbcSMatt Macy 		if (!first) {
3267eda14cbcSMatt Macy 			if (scripted)
3268a0b956f5SMartin Matuska 				(void) putchar('\t');
3269eda14cbcSMatt Macy 			else
3270a0b956f5SMartin Matuska 				(void) fputs("  ", stdout);
3271eda14cbcSMatt Macy 		}
3272eda14cbcSMatt Macy 		if (scripted)
3273a0b956f5SMartin Matuska 			(void) fputs(strval, stdout);
3274eda14cbcSMatt Macy 		else if (field == USFIELD_TYPE || field == USFIELD_NAME)
3275eda14cbcSMatt Macy 			(void) printf("%-*s", (int)width[field], strval);
3276eda14cbcSMatt Macy 		else
3277eda14cbcSMatt Macy 			(void) printf("%*s", (int)width[field], strval);
3278eda14cbcSMatt Macy 
3279eda14cbcSMatt Macy 		first = B_FALSE;
3280eda14cbcSMatt Macy 		cfield++;
3281eda14cbcSMatt Macy 	}
3282eda14cbcSMatt Macy 
3283a0b956f5SMartin Matuska 	(void) putchar('\n');
3284eda14cbcSMatt Macy }
3285eda14cbcSMatt Macy 
3286eda14cbcSMatt Macy static void
3287eda14cbcSMatt Macy print_us(boolean_t scripted, boolean_t parsable, int *fields, int types,
3288eda14cbcSMatt Macy     size_t *width, boolean_t rmnode, uu_avl_t *avl)
3289eda14cbcSMatt Macy {
3290eda14cbcSMatt Macy 	us_node_t *node;
3291eda14cbcSMatt Macy 	const char *col;
3292eda14cbcSMatt Macy 	int cfield = 0;
3293eda14cbcSMatt Macy 	int field;
3294eda14cbcSMatt Macy 
3295eda14cbcSMatt Macy 	if (!scripted) {
3296eda14cbcSMatt Macy 		boolean_t first = B_TRUE;
3297eda14cbcSMatt Macy 
3298eda14cbcSMatt Macy 		while ((field = fields[cfield]) != USFIELD_LAST) {
3299eda14cbcSMatt Macy 			col = gettext(us_field_hdr[field]);
3300eda14cbcSMatt Macy 			if (field == USFIELD_TYPE || field == USFIELD_NAME) {
3301eda14cbcSMatt Macy 				(void) printf(first ? "%-*s" : "  %-*s",
3302eda14cbcSMatt Macy 				    (int)width[field], col);
3303eda14cbcSMatt Macy 			} else {
3304eda14cbcSMatt Macy 				(void) printf(first ? "%*s" : "  %*s",
3305eda14cbcSMatt Macy 				    (int)width[field], col);
3306eda14cbcSMatt Macy 			}
3307eda14cbcSMatt Macy 			first = B_FALSE;
3308eda14cbcSMatt Macy 			cfield++;
3309eda14cbcSMatt Macy 		}
3310eda14cbcSMatt Macy 		(void) printf("\n");
3311eda14cbcSMatt Macy 	}
3312eda14cbcSMatt Macy 
3313eda14cbcSMatt Macy 	for (node = uu_avl_first(avl); node; node = uu_avl_next(avl, node)) {
3314eda14cbcSMatt Macy 		print_us_node(scripted, parsable, fields, types, width, node);
3315eda14cbcSMatt Macy 		if (rmnode)
3316eda14cbcSMatt Macy 			nvlist_free(node->usn_nvl);
3317eda14cbcSMatt Macy 	}
3318eda14cbcSMatt Macy }
3319eda14cbcSMatt Macy 
3320eda14cbcSMatt Macy static int
3321eda14cbcSMatt Macy zfs_do_userspace(int argc, char **argv)
3322eda14cbcSMatt Macy {
3323eda14cbcSMatt Macy 	zfs_handle_t *zhp;
3324eda14cbcSMatt Macy 	zfs_userquota_prop_t p;
3325eda14cbcSMatt Macy 	uu_avl_pool_t *avl_pool;
3326eda14cbcSMatt Macy 	uu_avl_t *avl_tree;
3327eda14cbcSMatt Macy 	uu_avl_walk_t *walk;
3328eda14cbcSMatt Macy 	char *delim;
3329eda14cbcSMatt Macy 	char deffields[] = "type,name,used,quota,objused,objquota";
3330eda14cbcSMatt Macy 	char *ofield = NULL;
3331eda14cbcSMatt Macy 	char *tfield = NULL;
3332eda14cbcSMatt Macy 	int cfield = 0;
3333eda14cbcSMatt Macy 	int fields[256];
3334eda14cbcSMatt Macy 	int i;
3335eda14cbcSMatt Macy 	boolean_t scripted = B_FALSE;
3336eda14cbcSMatt Macy 	boolean_t prtnum = B_FALSE;
3337eda14cbcSMatt Macy 	boolean_t parsable = B_FALSE;
3338eda14cbcSMatt Macy 	boolean_t sid2posix = B_FALSE;
3339eda14cbcSMatt Macy 	int ret = 0;
3340eda14cbcSMatt Macy 	int c;
3341eda14cbcSMatt Macy 	zfs_sort_column_t *sortcol = NULL;
3342eda14cbcSMatt Macy 	int types = USTYPE_PSX_USR | USTYPE_SMB_USR;
3343eda14cbcSMatt Macy 	us_cbdata_t cb;
3344eda14cbcSMatt Macy 	us_node_t *node;
3345eda14cbcSMatt Macy 	us_node_t *rmnode;
3346eda14cbcSMatt Macy 	uu_list_pool_t *listpool;
3347eda14cbcSMatt Macy 	uu_list_t *list;
3348eda14cbcSMatt Macy 	uu_avl_index_t idx = 0;
3349eda14cbcSMatt Macy 	uu_list_index_t idx2 = 0;
3350eda14cbcSMatt Macy 
3351eda14cbcSMatt Macy 	if (argc < 2)
3352eda14cbcSMatt Macy 		usage(B_FALSE);
3353eda14cbcSMatt Macy 
3354eda14cbcSMatt Macy 	if (strcmp(argv[0], "groupspace") == 0) {
3355eda14cbcSMatt Macy 		/* Toggle default group types */
3356eda14cbcSMatt Macy 		types = USTYPE_PSX_GRP | USTYPE_SMB_GRP;
3357eda14cbcSMatt Macy 	} else if (strcmp(argv[0], "projectspace") == 0) {
3358eda14cbcSMatt Macy 		types = USTYPE_PROJ;
3359eda14cbcSMatt Macy 		prtnum = B_TRUE;
3360eda14cbcSMatt Macy 	}
3361eda14cbcSMatt Macy 
3362eda14cbcSMatt Macy 	while ((c = getopt(argc, argv, "nHpo:s:S:t:i")) != -1) {
3363eda14cbcSMatt Macy 		switch (c) {
3364eda14cbcSMatt Macy 		case 'n':
3365eda14cbcSMatt Macy 			if (types == USTYPE_PROJ) {
3366eda14cbcSMatt Macy 				(void) fprintf(stderr,
3367eda14cbcSMatt Macy 				    gettext("invalid option 'n'\n"));
3368eda14cbcSMatt Macy 				usage(B_FALSE);
3369eda14cbcSMatt Macy 			}
3370eda14cbcSMatt Macy 			prtnum = B_TRUE;
3371eda14cbcSMatt Macy 			break;
3372eda14cbcSMatt Macy 		case 'H':
3373eda14cbcSMatt Macy 			scripted = B_TRUE;
3374eda14cbcSMatt Macy 			break;
3375eda14cbcSMatt Macy 		case 'p':
3376eda14cbcSMatt Macy 			parsable = B_TRUE;
3377eda14cbcSMatt Macy 			break;
3378eda14cbcSMatt Macy 		case 'o':
3379eda14cbcSMatt Macy 			ofield = optarg;
3380eda14cbcSMatt Macy 			break;
3381eda14cbcSMatt Macy 		case 's':
3382eda14cbcSMatt Macy 		case 'S':
3383eda14cbcSMatt Macy 			if (zfs_add_sort_column(&sortcol, optarg,
3384eda14cbcSMatt Macy 			    c == 's' ? B_FALSE : B_TRUE) != 0) {
3385eda14cbcSMatt Macy 				(void) fprintf(stderr,
3386eda14cbcSMatt Macy 				    gettext("invalid field '%s'\n"), optarg);
3387eda14cbcSMatt Macy 				usage(B_FALSE);
3388eda14cbcSMatt Macy 			}
3389eda14cbcSMatt Macy 			break;
3390eda14cbcSMatt Macy 		case 't':
3391eda14cbcSMatt Macy 			if (types == USTYPE_PROJ) {
3392eda14cbcSMatt Macy 				(void) fprintf(stderr,
3393eda14cbcSMatt Macy 				    gettext("invalid option 't'\n"));
3394eda14cbcSMatt Macy 				usage(B_FALSE);
3395eda14cbcSMatt Macy 			}
3396eda14cbcSMatt Macy 			tfield = optarg;
3397eda14cbcSMatt Macy 			break;
3398eda14cbcSMatt Macy 		case 'i':
3399eda14cbcSMatt Macy 			if (types == USTYPE_PROJ) {
3400eda14cbcSMatt Macy 				(void) fprintf(stderr,
3401eda14cbcSMatt Macy 				    gettext("invalid option 'i'\n"));
3402eda14cbcSMatt Macy 				usage(B_FALSE);
3403eda14cbcSMatt Macy 			}
3404eda14cbcSMatt Macy 			sid2posix = B_TRUE;
3405eda14cbcSMatt Macy 			break;
3406eda14cbcSMatt Macy 		case ':':
3407eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("missing argument for "
3408eda14cbcSMatt Macy 			    "'%c' option\n"), optopt);
3409eda14cbcSMatt Macy 			usage(B_FALSE);
3410eda14cbcSMatt Macy 			break;
3411eda14cbcSMatt Macy 		case '?':
3412eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
3413eda14cbcSMatt Macy 			    optopt);
3414eda14cbcSMatt Macy 			usage(B_FALSE);
3415eda14cbcSMatt Macy 		}
3416eda14cbcSMatt Macy 	}
3417eda14cbcSMatt Macy 
3418eda14cbcSMatt Macy 	argc -= optind;
3419eda14cbcSMatt Macy 	argv += optind;
3420eda14cbcSMatt Macy 
3421eda14cbcSMatt Macy 	if (argc < 1) {
3422eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("missing dataset name\n"));
3423eda14cbcSMatt Macy 		usage(B_FALSE);
3424eda14cbcSMatt Macy 	}
3425eda14cbcSMatt Macy 	if (argc > 1) {
3426eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("too many arguments\n"));
3427eda14cbcSMatt Macy 		usage(B_FALSE);
3428eda14cbcSMatt Macy 	}
3429eda14cbcSMatt Macy 
3430eda14cbcSMatt Macy 	/* Use default output fields if not specified using -o */
3431eda14cbcSMatt Macy 	if (ofield == NULL)
3432eda14cbcSMatt Macy 		ofield = deffields;
3433eda14cbcSMatt Macy 	do {
3434eda14cbcSMatt Macy 		if ((delim = strchr(ofield, ',')) != NULL)
3435eda14cbcSMatt Macy 			*delim = '\0';
3436eda14cbcSMatt Macy 		if ((fields[cfield++] = us_field_index(ofield)) == -1) {
3437eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("invalid type '%s' "
3438eda14cbcSMatt Macy 			    "for -o option\n"), ofield);
3439eda14cbcSMatt Macy 			return (-1);
3440eda14cbcSMatt Macy 		}
3441eda14cbcSMatt Macy 		if (delim != NULL)
3442eda14cbcSMatt Macy 			ofield = delim + 1;
3443eda14cbcSMatt Macy 	} while (delim != NULL);
3444eda14cbcSMatt Macy 	fields[cfield] = USFIELD_LAST;
3445eda14cbcSMatt Macy 
3446eda14cbcSMatt Macy 	/* Override output types (-t option) */
3447eda14cbcSMatt Macy 	if (tfield != NULL) {
3448eda14cbcSMatt Macy 		types = 0;
3449eda14cbcSMatt Macy 
3450eda14cbcSMatt Macy 		do {
3451eda14cbcSMatt Macy 			boolean_t found = B_FALSE;
3452eda14cbcSMatt Macy 
3453eda14cbcSMatt Macy 			if ((delim = strchr(tfield, ',')) != NULL)
3454eda14cbcSMatt Macy 				*delim = '\0';
3455eda14cbcSMatt Macy 			for (i = 0; i < sizeof (us_type_bits) / sizeof (int);
3456eda14cbcSMatt Macy 			    i++) {
3457eda14cbcSMatt Macy 				if (strcmp(tfield, us_type_names[i]) == 0) {
3458eda14cbcSMatt Macy 					found = B_TRUE;
3459eda14cbcSMatt Macy 					types |= us_type_bits[i];
3460eda14cbcSMatt Macy 					break;
3461eda14cbcSMatt Macy 				}
3462eda14cbcSMatt Macy 			}
3463eda14cbcSMatt Macy 			if (!found) {
3464eda14cbcSMatt Macy 				(void) fprintf(stderr, gettext("invalid type "
3465eda14cbcSMatt Macy 				    "'%s' for -t option\n"), tfield);
3466eda14cbcSMatt Macy 				return (-1);
3467eda14cbcSMatt Macy 			}
3468eda14cbcSMatt Macy 			if (delim != NULL)
3469eda14cbcSMatt Macy 				tfield = delim + 1;
3470eda14cbcSMatt Macy 		} while (delim != NULL);
3471eda14cbcSMatt Macy 	}
3472eda14cbcSMatt Macy 
3473c40487d4SMatt Macy 	if ((zhp = zfs_path_to_zhandle(g_zfs, argv[0], ZFS_TYPE_FILESYSTEM |
3474eda14cbcSMatt Macy 	    ZFS_TYPE_SNAPSHOT)) == NULL)
3475eda14cbcSMatt Macy 		return (1);
347616038816SMartin Matuska 	if (zfs_get_underlying_type(zhp) != ZFS_TYPE_FILESYSTEM) {
3477eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("operation is only applicable "
3478eda14cbcSMatt Macy 		    "to filesystems and their snapshots\n"));
3479eda14cbcSMatt Macy 		zfs_close(zhp);
3480eda14cbcSMatt Macy 		return (1);
3481eda14cbcSMatt Macy 	}
3482eda14cbcSMatt Macy 
3483eda14cbcSMatt Macy 	if ((avl_pool = uu_avl_pool_create("us_avl_pool", sizeof (us_node_t),
3484eda14cbcSMatt Macy 	    offsetof(us_node_t, usn_avlnode), us_compare, UU_DEFAULT)) == NULL)
3485eda14cbcSMatt Macy 		nomem();
3486eda14cbcSMatt Macy 	if ((avl_tree = uu_avl_create(avl_pool, NULL, UU_DEFAULT)) == NULL)
3487eda14cbcSMatt Macy 		nomem();
3488eda14cbcSMatt Macy 
3489eda14cbcSMatt Macy 	/* Always add default sorting columns */
3490eda14cbcSMatt Macy 	(void) zfs_add_sort_column(&sortcol, "type", B_FALSE);
3491eda14cbcSMatt Macy 	(void) zfs_add_sort_column(&sortcol, "name", B_FALSE);
3492eda14cbcSMatt Macy 
3493eda14cbcSMatt Macy 	cb.cb_sortcol = sortcol;
3494eda14cbcSMatt Macy 	cb.cb_numname = prtnum;
3495eda14cbcSMatt Macy 	cb.cb_nicenum = !parsable;
3496eda14cbcSMatt Macy 	cb.cb_avl_pool = avl_pool;
3497eda14cbcSMatt Macy 	cb.cb_avl = avl_tree;
3498eda14cbcSMatt Macy 	cb.cb_sid2posix = sid2posix;
3499eda14cbcSMatt Macy 
3500eda14cbcSMatt Macy 	for (i = 0; i < USFIELD_LAST; i++)
3501eda14cbcSMatt Macy 		cb.cb_width[i] = strlen(gettext(us_field_hdr[i]));
3502eda14cbcSMatt Macy 
3503eda14cbcSMatt Macy 	for (p = 0; p < ZFS_NUM_USERQUOTA_PROPS; p++) {
3504eda14cbcSMatt Macy 		if ((zfs_prop_is_user(p) &&
3505eda14cbcSMatt Macy 		    !(types & (USTYPE_PSX_USR | USTYPE_SMB_USR))) ||
3506eda14cbcSMatt Macy 		    (zfs_prop_is_group(p) &&
3507eda14cbcSMatt Macy 		    !(types & (USTYPE_PSX_GRP | USTYPE_SMB_GRP))) ||
3508eda14cbcSMatt Macy 		    (zfs_prop_is_project(p) && types != USTYPE_PROJ))
3509eda14cbcSMatt Macy 			continue;
3510eda14cbcSMatt Macy 
3511eda14cbcSMatt Macy 		cb.cb_prop = p;
3512eda14cbcSMatt Macy 		if ((ret = zfs_userspace(zhp, p, userspace_cb, &cb)) != 0) {
3513eda14cbcSMatt Macy 			zfs_close(zhp);
3514eda14cbcSMatt Macy 			return (ret);
3515eda14cbcSMatt Macy 		}
3516eda14cbcSMatt Macy 	}
3517eda14cbcSMatt Macy 	zfs_close(zhp);
3518eda14cbcSMatt Macy 
3519eda14cbcSMatt Macy 	/* Sort the list */
3520eda14cbcSMatt Macy 	if ((node = uu_avl_first(avl_tree)) == NULL)
3521eda14cbcSMatt Macy 		return (0);
3522eda14cbcSMatt Macy 
3523eda14cbcSMatt Macy 	us_populated = B_TRUE;
3524eda14cbcSMatt Macy 
3525eda14cbcSMatt Macy 	listpool = uu_list_pool_create("tmplist", sizeof (us_node_t),
3526eda14cbcSMatt Macy 	    offsetof(us_node_t, usn_listnode), NULL, UU_DEFAULT);
3527eda14cbcSMatt Macy 	list = uu_list_create(listpool, NULL, UU_DEFAULT);
3528eda14cbcSMatt Macy 	uu_list_node_init(node, &node->usn_listnode, listpool);
3529eda14cbcSMatt Macy 
3530eda14cbcSMatt Macy 	while (node != NULL) {
3531eda14cbcSMatt Macy 		rmnode = node;
3532eda14cbcSMatt Macy 		node = uu_avl_next(avl_tree, node);
3533eda14cbcSMatt Macy 		uu_avl_remove(avl_tree, rmnode);
3534eda14cbcSMatt Macy 		if (uu_list_find(list, rmnode, NULL, &idx2) == NULL)
3535eda14cbcSMatt Macy 			uu_list_insert(list, rmnode, idx2);
3536eda14cbcSMatt Macy 	}
3537eda14cbcSMatt Macy 
3538eda14cbcSMatt Macy 	for (node = uu_list_first(list); node != NULL;
3539eda14cbcSMatt Macy 	    node = uu_list_next(list, node)) {
3540eda14cbcSMatt Macy 		us_sort_info_t sortinfo = { sortcol, cb.cb_numname };
3541eda14cbcSMatt Macy 
3542eda14cbcSMatt Macy 		if (uu_avl_find(avl_tree, node, &sortinfo, &idx) == NULL)
3543eda14cbcSMatt Macy 			uu_avl_insert(avl_tree, node, idx);
3544eda14cbcSMatt Macy 	}
3545eda14cbcSMatt Macy 
3546eda14cbcSMatt Macy 	uu_list_destroy(list);
3547eda14cbcSMatt Macy 	uu_list_pool_destroy(listpool);
3548eda14cbcSMatt Macy 
3549eda14cbcSMatt Macy 	/* Print and free node nvlist memory */
3550eda14cbcSMatt Macy 	print_us(scripted, parsable, fields, types, cb.cb_width, B_TRUE,
3551eda14cbcSMatt Macy 	    cb.cb_avl);
3552eda14cbcSMatt Macy 
3553eda14cbcSMatt Macy 	zfs_free_sort_columns(sortcol);
3554eda14cbcSMatt Macy 
3555eda14cbcSMatt Macy 	/* Clean up the AVL tree */
3556eda14cbcSMatt Macy 	if ((walk = uu_avl_walk_start(cb.cb_avl, UU_WALK_ROBUST)) == NULL)
3557eda14cbcSMatt Macy 		nomem();
3558eda14cbcSMatt Macy 
3559eda14cbcSMatt Macy 	while ((node = uu_avl_walk_next(walk)) != NULL) {
3560eda14cbcSMatt Macy 		uu_avl_remove(cb.cb_avl, node);
3561eda14cbcSMatt Macy 		free(node);
3562eda14cbcSMatt Macy 	}
3563eda14cbcSMatt Macy 
3564eda14cbcSMatt Macy 	uu_avl_walk_end(walk);
3565eda14cbcSMatt Macy 	uu_avl_destroy(avl_tree);
3566eda14cbcSMatt Macy 	uu_avl_pool_destroy(avl_pool);
3567eda14cbcSMatt Macy 
3568eda14cbcSMatt Macy 	return (ret);
3569eda14cbcSMatt Macy }
3570eda14cbcSMatt Macy 
3571eda14cbcSMatt Macy /*
3572eda14cbcSMatt Macy  * list [-Hp][-r|-d max] [-o property[,...]] [-s property] ... [-S property]
3573eda14cbcSMatt Macy  *      [-t type[,...]] [filesystem|volume|snapshot] ...
3574eda14cbcSMatt Macy  *
3575eda14cbcSMatt Macy  *	-H	Scripted mode; elide headers and separate columns by tabs
3576eda14cbcSMatt Macy  *	-p	Display values in parsable (literal) format.
3577eda14cbcSMatt Macy  *	-r	Recurse over all children
3578eda14cbcSMatt Macy  *	-d	Limit recursion by depth.
3579eda14cbcSMatt Macy  *	-o	Control which fields to display.
3580eda14cbcSMatt Macy  *	-s	Specify sort columns, descending order.
3581eda14cbcSMatt Macy  *	-S	Specify sort columns, ascending order.
3582eda14cbcSMatt Macy  *	-t	Control which object types to display.
3583eda14cbcSMatt Macy  *
3584eda14cbcSMatt Macy  * When given no arguments, list all filesystems in the system.
3585eda14cbcSMatt Macy  * Otherwise, list the specified datasets, optionally recursing down them if
3586eda14cbcSMatt Macy  * '-r' is specified.
3587eda14cbcSMatt Macy  */
3588eda14cbcSMatt Macy typedef struct list_cbdata {
3589eda14cbcSMatt Macy 	boolean_t	cb_first;
3590eda14cbcSMatt Macy 	boolean_t	cb_literal;
3591eda14cbcSMatt Macy 	boolean_t	cb_scripted;
3592eda14cbcSMatt Macy 	zprop_list_t	*cb_proplist;
3593*ce4dcb97SMartin Matuska 	boolean_t	cb_json;
3594*ce4dcb97SMartin Matuska 	nvlist_t	*cb_jsobj;
3595*ce4dcb97SMartin Matuska 	boolean_t	cb_json_as_int;
3596eda14cbcSMatt Macy } list_cbdata_t;
3597eda14cbcSMatt Macy 
3598eda14cbcSMatt Macy /*
3599eda14cbcSMatt Macy  * Given a list of columns to display, output appropriate headers for each one.
3600eda14cbcSMatt Macy  */
3601eda14cbcSMatt Macy static void
3602eda14cbcSMatt Macy print_header(list_cbdata_t *cb)
3603eda14cbcSMatt Macy {
3604eda14cbcSMatt Macy 	zprop_list_t *pl = cb->cb_proplist;
3605eda14cbcSMatt Macy 	char headerbuf[ZFS_MAXPROPLEN];
3606eda14cbcSMatt Macy 	const char *header;
3607eda14cbcSMatt Macy 	int i;
3608eda14cbcSMatt Macy 	boolean_t first = B_TRUE;
3609eda14cbcSMatt Macy 	boolean_t right_justify;
3610eda14cbcSMatt Macy 
36112a58b312SMartin Matuska 	color_start(ANSI_BOLD);
36122a58b312SMartin Matuska 
3613eda14cbcSMatt Macy 	for (; pl != NULL; pl = pl->pl_next) {
3614eda14cbcSMatt Macy 		if (!first) {
3615eda14cbcSMatt Macy 			(void) printf("  ");
3616eda14cbcSMatt Macy 		} else {
3617eda14cbcSMatt Macy 			first = B_FALSE;
3618eda14cbcSMatt Macy 		}
3619eda14cbcSMatt Macy 
3620eda14cbcSMatt Macy 		right_justify = B_FALSE;
36211f1e2261SMartin Matuska 		if (pl->pl_prop != ZPROP_USERPROP) {
3622eda14cbcSMatt Macy 			header = zfs_prop_column_name(pl->pl_prop);
3623eda14cbcSMatt Macy 			right_justify = zfs_prop_align_right(pl->pl_prop);
3624eda14cbcSMatt Macy 		} else {
3625eda14cbcSMatt Macy 			for (i = 0; pl->pl_user_prop[i] != '\0'; i++)
3626eda14cbcSMatt Macy 				headerbuf[i] = toupper(pl->pl_user_prop[i]);
3627eda14cbcSMatt Macy 			headerbuf[i] = '\0';
3628eda14cbcSMatt Macy 			header = headerbuf;
3629eda14cbcSMatt Macy 		}
3630eda14cbcSMatt Macy 
3631eda14cbcSMatt Macy 		if (pl->pl_next == NULL && !right_justify)
3632eda14cbcSMatt Macy 			(void) printf("%s", header);
3633eda14cbcSMatt Macy 		else if (right_justify)
3634eda14cbcSMatt Macy 			(void) printf("%*s", (int)pl->pl_width, header);
3635eda14cbcSMatt Macy 		else
3636eda14cbcSMatt Macy 			(void) printf("%-*s", (int)pl->pl_width, header);
3637eda14cbcSMatt Macy 	}
3638eda14cbcSMatt Macy 
36392a58b312SMartin Matuska 	color_end();
36402a58b312SMartin Matuska 
3641eda14cbcSMatt Macy 	(void) printf("\n");
3642eda14cbcSMatt Macy }
3643eda14cbcSMatt Macy 
3644eda14cbcSMatt Macy /*
36452a58b312SMartin Matuska  * Decides on the color that the avail value should be printed in.
36462a58b312SMartin Matuska  * > 80% used = yellow
36472a58b312SMartin Matuska  * > 90% used = red
36482a58b312SMartin Matuska  */
36492a58b312SMartin Matuska static const char *
36502a58b312SMartin Matuska zfs_list_avail_color(zfs_handle_t *zhp)
36512a58b312SMartin Matuska {
36522a58b312SMartin Matuska 	uint64_t used = zfs_prop_get_int(zhp, ZFS_PROP_USED);
36532a58b312SMartin Matuska 	uint64_t avail = zfs_prop_get_int(zhp, ZFS_PROP_AVAILABLE);
36542a58b312SMartin Matuska 	int percentage = (int)((double)avail / MAX(avail + used, 1) * 100);
36552a58b312SMartin Matuska 
36562a58b312SMartin Matuska 	if (percentage > 20)
36572a58b312SMartin Matuska 		return (NULL);
36582a58b312SMartin Matuska 	else if (percentage > 10)
36592a58b312SMartin Matuska 		return (ANSI_YELLOW);
36602a58b312SMartin Matuska 	else
36612a58b312SMartin Matuska 		return (ANSI_RED);
36622a58b312SMartin Matuska }
36632a58b312SMartin Matuska 
36642a58b312SMartin Matuska /*
3665eda14cbcSMatt Macy  * Given a dataset and a list of fields, print out all the properties according
3666*ce4dcb97SMartin Matuska  * to the described layout, or return an nvlist containing all the fields, later
3667*ce4dcb97SMartin Matuska  * to be printed out as JSON object.
3668eda14cbcSMatt Macy  */
3669eda14cbcSMatt Macy static void
3670*ce4dcb97SMartin Matuska collect_dataset(zfs_handle_t *zhp, list_cbdata_t *cb)
3671eda14cbcSMatt Macy {
3672eda14cbcSMatt Macy 	zprop_list_t *pl = cb->cb_proplist;
3673eda14cbcSMatt Macy 	boolean_t first = B_TRUE;
3674eda14cbcSMatt Macy 	char property[ZFS_MAXPROPLEN];
3675eda14cbcSMatt Macy 	nvlist_t *userprops = zfs_get_user_props(zhp);
3676eda14cbcSMatt Macy 	nvlist_t *propval;
3677a0b956f5SMartin Matuska 	const char *propstr;
3678eda14cbcSMatt Macy 	boolean_t right_justify;
3679*ce4dcb97SMartin Matuska 	nvlist_t *item, *d, *props;
3680*ce4dcb97SMartin Matuska 	item = d = props = NULL;
3681*ce4dcb97SMartin Matuska 	zprop_source_t sourcetype = ZPROP_SRC_NONE;
3682*ce4dcb97SMartin Matuska 	char source[ZFS_MAX_DATASET_NAME_LEN];
3683*ce4dcb97SMartin Matuska 	if (cb->cb_json) {
3684*ce4dcb97SMartin Matuska 		d = fnvlist_lookup_nvlist(cb->cb_jsobj, "datasets");
3685*ce4dcb97SMartin Matuska 		if (d == NULL) {
3686*ce4dcb97SMartin Matuska 			fprintf(stderr, "datasets obj not found.\n");
3687*ce4dcb97SMartin Matuska 			exit(1);
3688*ce4dcb97SMartin Matuska 		}
3689*ce4dcb97SMartin Matuska 		item = fnvlist_alloc();
3690*ce4dcb97SMartin Matuska 		props = fnvlist_alloc();
3691*ce4dcb97SMartin Matuska 		fill_dataset_info(item, zhp, cb->cb_json_as_int);
3692*ce4dcb97SMartin Matuska 	}
3693eda14cbcSMatt Macy 
3694eda14cbcSMatt Macy 	for (; pl != NULL; pl = pl->pl_next) {
3695*ce4dcb97SMartin Matuska 		if (!cb->cb_json && !first) {
3696eda14cbcSMatt Macy 			if (cb->cb_scripted)
3697a0b956f5SMartin Matuska 				(void) putchar('\t');
3698eda14cbcSMatt Macy 			else
3699a0b956f5SMartin Matuska 				(void) fputs("  ", stdout);
3700eda14cbcSMatt Macy 		} else {
3701eda14cbcSMatt Macy 			first = B_FALSE;
3702eda14cbcSMatt Macy 		}
3703eda14cbcSMatt Macy 
3704eda14cbcSMatt Macy 		if (pl->pl_prop == ZFS_PROP_NAME) {
3705eda14cbcSMatt Macy 			(void) strlcpy(property, zfs_get_name(zhp),
3706eda14cbcSMatt Macy 			    sizeof (property));
3707eda14cbcSMatt Macy 			propstr = property;
3708eda14cbcSMatt Macy 			right_justify = zfs_prop_align_right(pl->pl_prop);
37091f1e2261SMartin Matuska 		} else if (pl->pl_prop != ZPROP_USERPROP) {
3710eda14cbcSMatt Macy 			if (zfs_prop_get(zhp, pl->pl_prop, property,
3711*ce4dcb97SMartin Matuska 			    sizeof (property), &sourcetype, source,
3712*ce4dcb97SMartin Matuska 			    sizeof (source), cb->cb_literal) != 0)
3713eda14cbcSMatt Macy 				propstr = "-";
3714eda14cbcSMatt Macy 			else
3715eda14cbcSMatt Macy 				propstr = property;
3716eda14cbcSMatt Macy 			right_justify = zfs_prop_align_right(pl->pl_prop);
3717eda14cbcSMatt Macy 		} else if (zfs_prop_userquota(pl->pl_user_prop)) {
3718*ce4dcb97SMartin Matuska 			sourcetype = ZPROP_SRC_LOCAL;
3719eda14cbcSMatt Macy 			if (zfs_prop_get_userquota(zhp, pl->pl_user_prop,
3720*ce4dcb97SMartin Matuska 			    property, sizeof (property), cb->cb_literal) != 0) {
3721*ce4dcb97SMartin Matuska 				sourcetype = ZPROP_SRC_NONE;
3722eda14cbcSMatt Macy 				propstr = "-";
3723*ce4dcb97SMartin Matuska 			} else {
3724eda14cbcSMatt Macy 				propstr = property;
3725*ce4dcb97SMartin Matuska 			}
3726eda14cbcSMatt Macy 			right_justify = B_TRUE;
3727eda14cbcSMatt Macy 		} else if (zfs_prop_written(pl->pl_user_prop)) {
3728*ce4dcb97SMartin Matuska 			sourcetype = ZPROP_SRC_LOCAL;
3729eda14cbcSMatt Macy 			if (zfs_prop_get_written(zhp, pl->pl_user_prop,
3730*ce4dcb97SMartin Matuska 			    property, sizeof (property), cb->cb_literal) != 0) {
3731*ce4dcb97SMartin Matuska 				sourcetype = ZPROP_SRC_NONE;
3732eda14cbcSMatt Macy 				propstr = "-";
3733*ce4dcb97SMartin Matuska 			} else {
3734eda14cbcSMatt Macy 				propstr = property;
3735*ce4dcb97SMartin Matuska 			}
3736eda14cbcSMatt Macy 			right_justify = B_TRUE;
3737eda14cbcSMatt Macy 		} else {
3738eda14cbcSMatt Macy 			if (nvlist_lookup_nvlist(userprops,
3739*ce4dcb97SMartin Matuska 			    pl->pl_user_prop, &propval) != 0) {
3740eda14cbcSMatt Macy 				propstr = "-";
3741*ce4dcb97SMartin Matuska 			} else {
3742a0b956f5SMartin Matuska 				propstr = fnvlist_lookup_string(propval,
3743a0b956f5SMartin Matuska 				    ZPROP_VALUE);
3744*ce4dcb97SMartin Matuska 				strlcpy(source,
3745*ce4dcb97SMartin Matuska 				    fnvlist_lookup_string(propval,
3746*ce4dcb97SMartin Matuska 				    ZPROP_SOURCE), ZFS_MAX_DATASET_NAME_LEN);
3747*ce4dcb97SMartin Matuska 				if (strcmp(source,
3748*ce4dcb97SMartin Matuska 				    zfs_get_name(zhp)) == 0) {
3749*ce4dcb97SMartin Matuska 					sourcetype = ZPROP_SRC_LOCAL;
3750*ce4dcb97SMartin Matuska 				} else if (strcmp(source,
3751*ce4dcb97SMartin Matuska 				    ZPROP_SOURCE_VAL_RECVD) == 0) {
3752*ce4dcb97SMartin Matuska 					sourcetype = ZPROP_SRC_RECEIVED;
3753*ce4dcb97SMartin Matuska 				} else {
3754*ce4dcb97SMartin Matuska 					sourcetype = ZPROP_SRC_INHERITED;
3755*ce4dcb97SMartin Matuska 				}
3756*ce4dcb97SMartin Matuska 			}
3757eda14cbcSMatt Macy 			right_justify = B_FALSE;
3758eda14cbcSMatt Macy 		}
3759eda14cbcSMatt Macy 
3760*ce4dcb97SMartin Matuska 		if (cb->cb_json) {
3761*ce4dcb97SMartin Matuska 			if (pl->pl_prop == ZFS_PROP_NAME)
3762*ce4dcb97SMartin Matuska 				continue;
3763*ce4dcb97SMartin Matuska 			if (zprop_nvlist_one_property(
3764*ce4dcb97SMartin Matuska 			    zfs_prop_to_name(pl->pl_prop), propstr,
3765*ce4dcb97SMartin Matuska 			    sourcetype, source, NULL, props,
3766*ce4dcb97SMartin Matuska 			    cb->cb_json_as_int) != 0)
3767*ce4dcb97SMartin Matuska 				nomem();
3768*ce4dcb97SMartin Matuska 		} else {
3769d411c1d6SMartin Matuska 			/*
3770*ce4dcb97SMartin Matuska 			 * zfs_list_avail_color() needs
3771*ce4dcb97SMartin Matuska 			 * ZFS_PROP_AVAILABLE + USED, so we need another
3772*ce4dcb97SMartin Matuska 			 * for() search for the USED part when no colors
3773*ce4dcb97SMartin Matuska 			 * wanted, we can skip the whole thing
3774d411c1d6SMartin Matuska 			 */
3775d411c1d6SMartin Matuska 			if (use_color() && pl->pl_prop == ZFS_PROP_AVAILABLE) {
3776d411c1d6SMartin Matuska 				zprop_list_t *pl2 = cb->cb_proplist;
3777d411c1d6SMartin Matuska 				for (; pl2 != NULL; pl2 = pl2->pl_next) {
3778d411c1d6SMartin Matuska 					if (pl2->pl_prop == ZFS_PROP_USED) {
3779*ce4dcb97SMartin Matuska 						color_start(
3780*ce4dcb97SMartin Matuska 						    zfs_list_avail_color(zhp));
3781*ce4dcb97SMartin Matuska 						/*
3782*ce4dcb97SMartin Matuska 						 * found it, no need for more
3783*ce4dcb97SMartin Matuska 						 * loops
3784*ce4dcb97SMartin Matuska 						 */
3785d411c1d6SMartin Matuska 						break;
3786d411c1d6SMartin Matuska 					}
3787d411c1d6SMartin Matuska 				}
3788d411c1d6SMartin Matuska 			}
37892a58b312SMartin Matuska 
3790eda14cbcSMatt Macy 			/*
3791*ce4dcb97SMartin Matuska 			 * If this is being called in scripted mode, or if
3792*ce4dcb97SMartin Matuska 			 * this is the last column and it is left-justified,
3793*ce4dcb97SMartin Matuska 			 * don't include a width format specifier.
3794eda14cbcSMatt Macy 			 */
3795*ce4dcb97SMartin Matuska 			if (cb->cb_scripted || (pl->pl_next == NULL &&
3796*ce4dcb97SMartin Matuska 			    !right_justify))
3797a0b956f5SMartin Matuska 				(void) fputs(propstr, stdout);
3798*ce4dcb97SMartin Matuska 			else if (right_justify) {
3799*ce4dcb97SMartin Matuska 				(void) printf("%*s", (int)pl->pl_width,
3800*ce4dcb97SMartin Matuska 				    propstr);
3801*ce4dcb97SMartin Matuska 			} else {
3802*ce4dcb97SMartin Matuska 				(void) printf("%-*s", (int)pl->pl_width,
3803*ce4dcb97SMartin Matuska 				    propstr);
3804*ce4dcb97SMartin Matuska 			}
38052a58b312SMartin Matuska 
38062a58b312SMartin Matuska 			if (pl->pl_prop == ZFS_PROP_AVAILABLE)
38072a58b312SMartin Matuska 				color_end();
3808eda14cbcSMatt Macy 		}
3809*ce4dcb97SMartin Matuska 	}
3810*ce4dcb97SMartin Matuska 	if (cb->cb_json) {
3811*ce4dcb97SMartin Matuska 		fnvlist_add_nvlist(item, "properties", props);
3812*ce4dcb97SMartin Matuska 		fnvlist_add_nvlist(d, zfs_get_name(zhp), item);
3813*ce4dcb97SMartin Matuska 		fnvlist_free(props);
3814*ce4dcb97SMartin Matuska 		fnvlist_free(item);
3815*ce4dcb97SMartin Matuska 	} else
3816a0b956f5SMartin Matuska 		(void) putchar('\n');
3817eda14cbcSMatt Macy }
3818eda14cbcSMatt Macy 
3819eda14cbcSMatt Macy /*
3820eda14cbcSMatt Macy  * Generic callback function to list a dataset or snapshot.
3821eda14cbcSMatt Macy  */
3822eda14cbcSMatt Macy static int
3823eda14cbcSMatt Macy list_callback(zfs_handle_t *zhp, void *data)
3824eda14cbcSMatt Macy {
3825eda14cbcSMatt Macy 	list_cbdata_t *cbp = data;
3826eda14cbcSMatt Macy 
3827eda14cbcSMatt Macy 	if (cbp->cb_first) {
3828*ce4dcb97SMartin Matuska 		if (!cbp->cb_scripted && !cbp->cb_json)
3829eda14cbcSMatt Macy 			print_header(cbp);
3830eda14cbcSMatt Macy 		cbp->cb_first = B_FALSE;
3831eda14cbcSMatt Macy 	}
3832eda14cbcSMatt Macy 
3833*ce4dcb97SMartin Matuska 	collect_dataset(zhp, cbp);
3834eda14cbcSMatt Macy 
3835eda14cbcSMatt Macy 	return (0);
3836eda14cbcSMatt Macy }
3837eda14cbcSMatt Macy 
3838eda14cbcSMatt Macy static int
3839eda14cbcSMatt Macy zfs_do_list(int argc, char **argv)
3840eda14cbcSMatt Macy {
3841eda14cbcSMatt Macy 	int c;
3842da5137abSMartin Matuska 	char default_fields[] =
3843eda14cbcSMatt Macy 	    "name,used,available,referenced,mountpoint";
3844eda14cbcSMatt Macy 	int types = ZFS_TYPE_DATASET;
3845eda14cbcSMatt Macy 	boolean_t types_specified = B_FALSE;
3846da5137abSMartin Matuska 	char *fields = default_fields;
3847eda14cbcSMatt Macy 	list_cbdata_t cb = { 0 };
3848eda14cbcSMatt Macy 	int limit = 0;
3849eda14cbcSMatt Macy 	int ret = 0;
3850eda14cbcSMatt Macy 	zfs_sort_column_t *sortcol = NULL;
3851eda14cbcSMatt Macy 	int flags = ZFS_ITER_PROP_LISTSNAPS | ZFS_ITER_ARGS_CAN_BE_PATHS;
3852*ce4dcb97SMartin Matuska 	nvlist_t *data = NULL;
3853*ce4dcb97SMartin Matuska 
3854*ce4dcb97SMartin Matuska 	struct option long_options[] = {
3855*ce4dcb97SMartin Matuska 		{"json-int", no_argument, NULL, ZFS_OPTION_JSON_NUMS_AS_INT},
3856*ce4dcb97SMartin Matuska 		{0, 0, 0, 0}
3857*ce4dcb97SMartin Matuska 	};
3858eda14cbcSMatt Macy 
3859eda14cbcSMatt Macy 	/* check options */
3860*ce4dcb97SMartin Matuska 	while ((c = getopt_long(argc, argv, "jHS:d:o:prs:t:", long_options,
3861*ce4dcb97SMartin Matuska 	    NULL)) != -1) {
3862eda14cbcSMatt Macy 		switch (c) {
3863eda14cbcSMatt Macy 		case 'o':
3864eda14cbcSMatt Macy 			fields = optarg;
3865eda14cbcSMatt Macy 			break;
3866eda14cbcSMatt Macy 		case 'p':
3867eda14cbcSMatt Macy 			cb.cb_literal = B_TRUE;
3868eda14cbcSMatt Macy 			flags |= ZFS_ITER_LITERAL_PROPS;
3869eda14cbcSMatt Macy 			break;
3870eda14cbcSMatt Macy 		case 'd':
3871eda14cbcSMatt Macy 			limit = parse_depth(optarg, &flags);
3872eda14cbcSMatt Macy 			break;
3873eda14cbcSMatt Macy 		case 'r':
3874eda14cbcSMatt Macy 			flags |= ZFS_ITER_RECURSE;
3875eda14cbcSMatt Macy 			break;
3876*ce4dcb97SMartin Matuska 		case 'j':
3877*ce4dcb97SMartin Matuska 			cb.cb_json = B_TRUE;
3878*ce4dcb97SMartin Matuska 			cb.cb_jsobj = zfs_json_schema(0, 1);
3879*ce4dcb97SMartin Matuska 			data = fnvlist_alloc();
3880*ce4dcb97SMartin Matuska 			fnvlist_add_nvlist(cb.cb_jsobj, "datasets", data);
3881*ce4dcb97SMartin Matuska 			fnvlist_free(data);
3882*ce4dcb97SMartin Matuska 			break;
3883*ce4dcb97SMartin Matuska 		case ZFS_OPTION_JSON_NUMS_AS_INT:
3884*ce4dcb97SMartin Matuska 			cb.cb_json_as_int = B_TRUE;
3885*ce4dcb97SMartin Matuska 			cb.cb_literal = B_TRUE;
3886*ce4dcb97SMartin Matuska 			break;
3887eda14cbcSMatt Macy 		case 'H':
3888eda14cbcSMatt Macy 			cb.cb_scripted = B_TRUE;
3889eda14cbcSMatt Macy 			break;
3890eda14cbcSMatt Macy 		case 's':
3891eda14cbcSMatt Macy 			if (zfs_add_sort_column(&sortcol, optarg,
3892eda14cbcSMatt Macy 			    B_FALSE) != 0) {
3893eda14cbcSMatt Macy 				(void) fprintf(stderr,
3894eda14cbcSMatt Macy 				    gettext("invalid property '%s'\n"), optarg);
3895eda14cbcSMatt Macy 				usage(B_FALSE);
3896eda14cbcSMatt Macy 			}
3897eda14cbcSMatt Macy 			break;
3898eda14cbcSMatt Macy 		case 'S':
3899eda14cbcSMatt Macy 			if (zfs_add_sort_column(&sortcol, optarg,
3900eda14cbcSMatt Macy 			    B_TRUE) != 0) {
3901eda14cbcSMatt Macy 				(void) fprintf(stderr,
3902eda14cbcSMatt Macy 				    gettext("invalid property '%s'\n"), optarg);
3903eda14cbcSMatt Macy 				usage(B_FALSE);
3904eda14cbcSMatt Macy 			}
3905eda14cbcSMatt Macy 			break;
3906eda14cbcSMatt Macy 		case 't':
3907eda14cbcSMatt Macy 			types = 0;
3908eda14cbcSMatt Macy 			types_specified = B_TRUE;
3909eda14cbcSMatt Macy 			flags &= ~ZFS_ITER_PROP_LISTSNAPS;
3910eda14cbcSMatt Macy 
3911da5137abSMartin Matuska 			for (char *tok; (tok = strsep(&optarg, ",")); ) {
3912da5137abSMartin Matuska 				static const char *const type_subopts[] = {
3913e2257b31SMartin Matuska 					"filesystem",
3914e2257b31SMartin Matuska 					"fs",
3915e2257b31SMartin Matuska 					"volume",
3916e2257b31SMartin Matuska 					"vol",
3917e2257b31SMartin Matuska 					"snapshot",
3918e2257b31SMartin Matuska 					"snap",
3919da5137abSMartin Matuska 					"bookmark",
3920e2257b31SMartin Matuska 					"all"
3921e2257b31SMartin Matuska 				};
3922da5137abSMartin Matuska 				static const int type_types[] = {
3923e2257b31SMartin Matuska 					ZFS_TYPE_FILESYSTEM,
3924e2257b31SMartin Matuska 					ZFS_TYPE_FILESYSTEM,
3925e2257b31SMartin Matuska 					ZFS_TYPE_VOLUME,
3926e2257b31SMartin Matuska 					ZFS_TYPE_VOLUME,
3927e2257b31SMartin Matuska 					ZFS_TYPE_SNAPSHOT,
3928e2257b31SMartin Matuska 					ZFS_TYPE_SNAPSHOT,
3929da5137abSMartin Matuska 					ZFS_TYPE_BOOKMARK,
3930e2257b31SMartin Matuska 					ZFS_TYPE_DATASET | ZFS_TYPE_BOOKMARK
3931e2257b31SMartin Matuska 				};
3932da5137abSMartin Matuska 
3933da5137abSMartin Matuska 				for (c = 0; c < ARRAY_SIZE(type_subopts); ++c)
3934da5137abSMartin Matuska 					if (strcmp(tok, type_subopts[c]) == 0) {
3935da5137abSMartin Matuska 						types |= type_types[c];
3936da5137abSMartin Matuska 						goto found3;
3937eda14cbcSMatt Macy 					}
3938da5137abSMartin Matuska 
3939da5137abSMartin Matuska 				(void) fprintf(stderr,
3940da5137abSMartin Matuska 				    gettext("invalid type '%s'\n"), tok);
3941da5137abSMartin Matuska 				usage(B_FALSE);
3942da5137abSMartin Matuska found3:;
3943eda14cbcSMatt Macy 			}
3944eda14cbcSMatt Macy 			break;
3945eda14cbcSMatt Macy 		case ':':
3946eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("missing argument for "
3947eda14cbcSMatt Macy 			    "'%c' option\n"), optopt);
3948eda14cbcSMatt Macy 			usage(B_FALSE);
3949eda14cbcSMatt Macy 			break;
3950eda14cbcSMatt Macy 		case '?':
3951eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
3952eda14cbcSMatt Macy 			    optopt);
3953eda14cbcSMatt Macy 			usage(B_FALSE);
3954eda14cbcSMatt Macy 		}
3955eda14cbcSMatt Macy 	}
3956eda14cbcSMatt Macy 
3957eda14cbcSMatt Macy 	argc -= optind;
3958eda14cbcSMatt Macy 	argv += optind;
3959eda14cbcSMatt Macy 
3960*ce4dcb97SMartin Matuska 	if (!cb.cb_json && cb.cb_json_as_int) {
3961*ce4dcb97SMartin Matuska 		(void) fprintf(stderr, gettext("'--json-int' only works with"
3962*ce4dcb97SMartin Matuska 		    " '-j' option\n"));
3963*ce4dcb97SMartin Matuska 		usage(B_FALSE);
3964*ce4dcb97SMartin Matuska 	}
3965*ce4dcb97SMartin Matuska 
3966eda14cbcSMatt Macy 	/*
3967eda14cbcSMatt Macy 	 * If "-o space" and no types were specified, don't display snapshots.
3968eda14cbcSMatt Macy 	 */
3969eda14cbcSMatt Macy 	if (strcmp(fields, "space") == 0 && types_specified == B_FALSE)
3970eda14cbcSMatt Macy 		types &= ~ZFS_TYPE_SNAPSHOT;
3971eda14cbcSMatt Macy 
3972eda14cbcSMatt Macy 	/*
3973eda14cbcSMatt Macy 	 * Handle users who want to list all snapshots or bookmarks
3974eda14cbcSMatt Macy 	 * of the current dataset (ex. 'zfs list -t snapshot <dataset>').
3975eda14cbcSMatt Macy 	 */
3976eda14cbcSMatt Macy 	if ((types == ZFS_TYPE_SNAPSHOT || types == ZFS_TYPE_BOOKMARK) &&
3977eda14cbcSMatt Macy 	    argc > 0 && (flags & ZFS_ITER_RECURSE) == 0 && limit == 0) {
3978eda14cbcSMatt Macy 		flags |= (ZFS_ITER_DEPTH_LIMIT | ZFS_ITER_RECURSE);
3979eda14cbcSMatt Macy 		limit = 1;
3980eda14cbcSMatt Macy 	}
3981eda14cbcSMatt Macy 
3982eda14cbcSMatt Macy 	/*
3983eda14cbcSMatt Macy 	 * If the user specifies '-o all', the zprop_get_list() doesn't
3984eda14cbcSMatt Macy 	 * normally include the name of the dataset.  For 'zfs list', we always
3985eda14cbcSMatt Macy 	 * want this property to be first.
3986eda14cbcSMatt Macy 	 */
3987eda14cbcSMatt Macy 	if (zprop_get_list(g_zfs, fields, &cb.cb_proplist, ZFS_TYPE_DATASET)
3988eda14cbcSMatt Macy 	    != 0)
3989eda14cbcSMatt Macy 		usage(B_FALSE);
3990eda14cbcSMatt Macy 
3991eda14cbcSMatt Macy 	cb.cb_first = B_TRUE;
3992eda14cbcSMatt Macy 
399315f0b8c3SMartin Matuska 	/*
399415f0b8c3SMartin Matuska 	 * If we are only going to list and sort by properties that are "fast"
399515f0b8c3SMartin Matuska 	 * then we can use "simple" mode and avoid populating the properties
399615f0b8c3SMartin Matuska 	 * nvlist.
399715f0b8c3SMartin Matuska 	 */
399815f0b8c3SMartin Matuska 	if (zfs_list_only_by_fast(cb.cb_proplist) &&
399915f0b8c3SMartin Matuska 	    zfs_sort_only_by_fast(sortcol))
400015f0b8c3SMartin Matuska 		flags |= ZFS_ITER_SIMPLE;
400115f0b8c3SMartin Matuska 
4002eda14cbcSMatt Macy 	ret = zfs_for_each(argc, argv, flags, types, sortcol, &cb.cb_proplist,
4003eda14cbcSMatt Macy 	    limit, list_callback, &cb);
4004eda14cbcSMatt Macy 
4005*ce4dcb97SMartin Matuska 	if (ret == 0 && cb.cb_json)
4006*ce4dcb97SMartin Matuska 		zcmd_print_json(cb.cb_jsobj);
4007*ce4dcb97SMartin Matuska 	else if (ret != 0 && cb.cb_json)
4008*ce4dcb97SMartin Matuska 		nvlist_free(cb.cb_jsobj);
4009*ce4dcb97SMartin Matuska 
4010eda14cbcSMatt Macy 	zprop_free_list(cb.cb_proplist);
4011eda14cbcSMatt Macy 	zfs_free_sort_columns(sortcol);
4012eda14cbcSMatt Macy 
4013eda14cbcSMatt Macy 	if (ret == 0 && cb.cb_first && !cb.cb_scripted)
4014eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("no datasets available\n"));
4015eda14cbcSMatt Macy 
4016eda14cbcSMatt Macy 	return (ret);
4017eda14cbcSMatt Macy }
4018eda14cbcSMatt Macy 
4019eda14cbcSMatt Macy /*
4020eac7052fSMatt Macy  * zfs rename [-fu] <fs | snap | vol> <fs | snap | vol>
4021eda14cbcSMatt Macy  * zfs rename [-f] -p <fs | vol> <fs | vol>
4022eac7052fSMatt Macy  * zfs rename [-u] -r <snap> <snap>
4023eda14cbcSMatt Macy  *
4024eda14cbcSMatt Macy  * Renames the given dataset to another of the same type.
4025eda14cbcSMatt Macy  *
4026eda14cbcSMatt Macy  * The '-p' flag creates all the non-existing ancestors of the target first.
4027eac7052fSMatt Macy  * The '-u' flag prevents file systems from being remounted during rename.
4028eda14cbcSMatt Macy  */
4029eda14cbcSMatt Macy static int
4030eda14cbcSMatt Macy zfs_do_rename(int argc, char **argv)
4031eda14cbcSMatt Macy {
4032eda14cbcSMatt Macy 	zfs_handle_t *zhp;
4033eac7052fSMatt Macy 	renameflags_t flags = { 0 };
4034eda14cbcSMatt Macy 	int c;
4035eda14cbcSMatt Macy 	int ret = 0;
4036eac7052fSMatt Macy 	int types;
4037eda14cbcSMatt Macy 	boolean_t parents = B_FALSE;
4038eda14cbcSMatt Macy 
4039eda14cbcSMatt Macy 	/* check options */
4040eac7052fSMatt Macy 	while ((c = getopt(argc, argv, "pruf")) != -1) {
4041eda14cbcSMatt Macy 		switch (c) {
4042eda14cbcSMatt Macy 		case 'p':
4043eda14cbcSMatt Macy 			parents = B_TRUE;
4044eda14cbcSMatt Macy 			break;
4045eda14cbcSMatt Macy 		case 'r':
4046eac7052fSMatt Macy 			flags.recursive = B_TRUE;
4047eac7052fSMatt Macy 			break;
4048eac7052fSMatt Macy 		case 'u':
4049eac7052fSMatt Macy 			flags.nounmount = B_TRUE;
4050eda14cbcSMatt Macy 			break;
4051eda14cbcSMatt Macy 		case 'f':
4052eac7052fSMatt Macy 			flags.forceunmount = B_TRUE;
4053eda14cbcSMatt Macy 			break;
4054eda14cbcSMatt Macy 		case '?':
4055eda14cbcSMatt Macy 		default:
4056eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
4057eda14cbcSMatt Macy 			    optopt);
4058eda14cbcSMatt Macy 			usage(B_FALSE);
4059eda14cbcSMatt Macy 		}
4060eda14cbcSMatt Macy 	}
4061eda14cbcSMatt Macy 
4062eda14cbcSMatt Macy 	argc -= optind;
4063eda14cbcSMatt Macy 	argv += optind;
4064eda14cbcSMatt Macy 
4065eda14cbcSMatt Macy 	/* check number of arguments */
4066eda14cbcSMatt Macy 	if (argc < 1) {
4067eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("missing source dataset "
4068eda14cbcSMatt Macy 		    "argument\n"));
4069eda14cbcSMatt Macy 		usage(B_FALSE);
4070eda14cbcSMatt Macy 	}
4071eda14cbcSMatt Macy 	if (argc < 2) {
4072eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("missing target dataset "
4073eda14cbcSMatt Macy 		    "argument\n"));
4074eda14cbcSMatt Macy 		usage(B_FALSE);
4075eda14cbcSMatt Macy 	}
4076eda14cbcSMatt Macy 	if (argc > 2) {
4077eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("too many arguments\n"));
4078eda14cbcSMatt Macy 		usage(B_FALSE);
4079eda14cbcSMatt Macy 	}
4080eda14cbcSMatt Macy 
4081eac7052fSMatt Macy 	if (flags.recursive && parents) {
4082eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("-p and -r options are mutually "
4083eda14cbcSMatt Macy 		    "exclusive\n"));
4084eda14cbcSMatt Macy 		usage(B_FALSE);
4085eda14cbcSMatt Macy 	}
4086eda14cbcSMatt Macy 
4087eac7052fSMatt Macy 	if (flags.nounmount && parents) {
4088eac7052fSMatt Macy 		(void) fprintf(stderr, gettext("-u and -p options are mutually "
4089eac7052fSMatt Macy 		    "exclusive\n"));
4090eac7052fSMatt Macy 		usage(B_FALSE);
4091eac7052fSMatt Macy 	}
4092eac7052fSMatt Macy 
4093eac7052fSMatt Macy 	if (flags.recursive && strchr(argv[0], '@') == 0) {
4094eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("source dataset for recursive "
4095eda14cbcSMatt Macy 		    "rename must be a snapshot\n"));
4096eda14cbcSMatt Macy 		usage(B_FALSE);
4097eda14cbcSMatt Macy 	}
4098eda14cbcSMatt Macy 
4099eac7052fSMatt Macy 	if (flags.nounmount)
4100eac7052fSMatt Macy 		types = ZFS_TYPE_FILESYSTEM;
4101eac7052fSMatt Macy 	else if (parents)
4102eac7052fSMatt Macy 		types = ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME;
4103eac7052fSMatt Macy 	else
4104eac7052fSMatt Macy 		types = ZFS_TYPE_DATASET;
4105eac7052fSMatt Macy 
4106eac7052fSMatt Macy 	if ((zhp = zfs_open(g_zfs, argv[0], types)) == NULL)
4107eda14cbcSMatt Macy 		return (1);
4108eda14cbcSMatt Macy 
4109eda14cbcSMatt Macy 	/* If we were asked and the name looks good, try to create ancestors. */
4110eda14cbcSMatt Macy 	if (parents && zfs_name_valid(argv[1], zfs_get_type(zhp)) &&
4111eda14cbcSMatt Macy 	    zfs_create_ancestors(g_zfs, argv[1]) != 0) {
4112eda14cbcSMatt Macy 		zfs_close(zhp);
4113eda14cbcSMatt Macy 		return (1);
4114eda14cbcSMatt Macy 	}
4115eda14cbcSMatt Macy 
4116eac7052fSMatt Macy 	ret = (zfs_rename(zhp, argv[1], flags) != 0);
4117eda14cbcSMatt Macy 
4118eda14cbcSMatt Macy 	zfs_close(zhp);
4119eda14cbcSMatt Macy 	return (ret);
4120eda14cbcSMatt Macy }
4121eda14cbcSMatt Macy 
4122eda14cbcSMatt Macy /*
4123eda14cbcSMatt Macy  * zfs promote <fs>
4124eda14cbcSMatt Macy  *
4125eda14cbcSMatt Macy  * Promotes the given clone fs to be the parent
4126eda14cbcSMatt Macy  */
4127eda14cbcSMatt Macy static int
4128eda14cbcSMatt Macy zfs_do_promote(int argc, char **argv)
4129eda14cbcSMatt Macy {
4130eda14cbcSMatt Macy 	zfs_handle_t *zhp;
4131eda14cbcSMatt Macy 	int ret = 0;
4132eda14cbcSMatt Macy 
4133eda14cbcSMatt Macy 	/* check options */
4134eda14cbcSMatt Macy 	if (argc > 1 && argv[1][0] == '-') {
4135eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("invalid option '%c'\n"),
4136eda14cbcSMatt Macy 		    argv[1][1]);
4137eda14cbcSMatt Macy 		usage(B_FALSE);
4138eda14cbcSMatt Macy 	}
4139eda14cbcSMatt Macy 
4140eda14cbcSMatt Macy 	/* check number of arguments */
4141eda14cbcSMatt Macy 	if (argc < 2) {
4142eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("missing clone filesystem"
4143eda14cbcSMatt Macy 		    " argument\n"));
4144eda14cbcSMatt Macy 		usage(B_FALSE);
4145eda14cbcSMatt Macy 	}
4146eda14cbcSMatt Macy 	if (argc > 2) {
4147eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("too many arguments\n"));
4148eda14cbcSMatt Macy 		usage(B_FALSE);
4149eda14cbcSMatt Macy 	}
4150eda14cbcSMatt Macy 
4151eda14cbcSMatt Macy 	zhp = zfs_open(g_zfs, argv[1], ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
4152eda14cbcSMatt Macy 	if (zhp == NULL)
4153eda14cbcSMatt Macy 		return (1);
4154eda14cbcSMatt Macy 
4155eda14cbcSMatt Macy 	ret = (zfs_promote(zhp) != 0);
4156eda14cbcSMatt Macy 
4157eda14cbcSMatt Macy 
4158eda14cbcSMatt Macy 	zfs_close(zhp);
4159eda14cbcSMatt Macy 	return (ret);
4160eda14cbcSMatt Macy }
4161eda14cbcSMatt Macy 
4162eda14cbcSMatt Macy static int
4163eda14cbcSMatt Macy zfs_do_redact(int argc, char **argv)
4164eda14cbcSMatt Macy {
4165eda14cbcSMatt Macy 	char *snap = NULL;
4166eda14cbcSMatt Macy 	char *bookname = NULL;
4167eda14cbcSMatt Macy 	char **rsnaps = NULL;
4168eda14cbcSMatt Macy 	int numrsnaps = 0;
4169eda14cbcSMatt Macy 	argv++;
4170eda14cbcSMatt Macy 	argc--;
4171eda14cbcSMatt Macy 	if (argc < 3) {
4172eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("too few arguments\n"));
4173eda14cbcSMatt Macy 		usage(B_FALSE);
4174eda14cbcSMatt Macy 	}
4175eda14cbcSMatt Macy 
4176eda14cbcSMatt Macy 	snap = argv[0];
4177eda14cbcSMatt Macy 	bookname = argv[1];
4178eda14cbcSMatt Macy 	rsnaps = argv + 2;
4179eda14cbcSMatt Macy 	numrsnaps = argc - 2;
4180eda14cbcSMatt Macy 
4181eda14cbcSMatt Macy 	nvlist_t *rsnapnv = fnvlist_alloc();
4182eda14cbcSMatt Macy 
4183eda14cbcSMatt Macy 	for (int i = 0; i < numrsnaps; i++) {
4184eda14cbcSMatt Macy 		fnvlist_add_boolean(rsnapnv, rsnaps[i]);
4185eda14cbcSMatt Macy 	}
4186eda14cbcSMatt Macy 
4187eda14cbcSMatt Macy 	int err = lzc_redact(snap, bookname, rsnapnv);
4188eda14cbcSMatt Macy 	fnvlist_free(rsnapnv);
4189eda14cbcSMatt Macy 
4190eda14cbcSMatt Macy 	switch (err) {
4191eda14cbcSMatt Macy 	case 0:
4192eda14cbcSMatt Macy 		break;
41932a58b312SMartin Matuska 	case ENOENT: {
41942a58b312SMartin Matuska 		zfs_handle_t *zhp = zfs_open(g_zfs, snap, ZFS_TYPE_SNAPSHOT);
41952a58b312SMartin Matuska 		if (zhp == NULL) {
41962a58b312SMartin Matuska 			(void) fprintf(stderr, gettext("provided snapshot %s "
41972a58b312SMartin Matuska 			    "does not exist\n"), snap);
41982a58b312SMartin Matuska 		} else {
41992a58b312SMartin Matuska 			zfs_close(zhp);
42002a58b312SMartin Matuska 		}
42012a58b312SMartin Matuska 		for (int i = 0; i < numrsnaps; i++) {
42022a58b312SMartin Matuska 			zhp = zfs_open(g_zfs, rsnaps[i], ZFS_TYPE_SNAPSHOT);
42032a58b312SMartin Matuska 			if (zhp == NULL) {
42042a58b312SMartin Matuska 				(void) fprintf(stderr, gettext("provided "
42052a58b312SMartin Matuska 				    "snapshot %s does not exist\n"), rsnaps[i]);
42062a58b312SMartin Matuska 			} else {
42072a58b312SMartin Matuska 				zfs_close(zhp);
42082a58b312SMartin Matuska 			}
42092a58b312SMartin Matuska 		}
4210eda14cbcSMatt Macy 		break;
42112a58b312SMartin Matuska 	}
4212eda14cbcSMatt Macy 	case EEXIST:
4213eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("specified redaction bookmark "
4214eda14cbcSMatt Macy 		    "(%s) provided already exists\n"), bookname);
4215eda14cbcSMatt Macy 		break;
4216eda14cbcSMatt Macy 	case ENAMETOOLONG:
4217eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("provided bookmark name cannot "
4218eda14cbcSMatt Macy 		    "be used, final name would be too long\n"));
4219eda14cbcSMatt Macy 		break;
4220eda14cbcSMatt Macy 	case E2BIG:
4221eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("too many redaction snapshots "
4222eda14cbcSMatt Macy 		    "specified\n"));
4223eda14cbcSMatt Macy 		break;
4224eda14cbcSMatt Macy 	case EINVAL:
4225eda14cbcSMatt Macy 		if (strchr(bookname, '#') != NULL)
4226eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext(
4227eda14cbcSMatt Macy 			    "redaction bookmark name must not contain '#'\n"));
4228eda14cbcSMatt Macy 		else
4229eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext(
4230eda14cbcSMatt Macy 			    "redaction snapshot must be descendent of "
4231eda14cbcSMatt Macy 			    "snapshot being redacted\n"));
4232eda14cbcSMatt Macy 		break;
4233eda14cbcSMatt Macy 	case EALREADY:
4234eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("attempted to redact redacted "
4235eda14cbcSMatt Macy 		    "dataset or with respect to redacted dataset\n"));
4236eda14cbcSMatt Macy 		break;
4237eda14cbcSMatt Macy 	case ENOTSUP:
4238eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("redaction bookmarks feature "
4239eda14cbcSMatt Macy 		    "not enabled\n"));
4240eda14cbcSMatt Macy 		break;
4241eda14cbcSMatt Macy 	case EXDEV:
4242eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("potentially invalid redaction "
4243eda14cbcSMatt Macy 		    "snapshot; full dataset names required\n"));
4244eda14cbcSMatt Macy 		break;
42452ad756a6SMartin Matuska 	case ESRCH:
42462ad756a6SMartin Matuska 		(void) fprintf(stderr, gettext("attempted to resume redaction "
42472ad756a6SMartin Matuska 		    " with a mismatched redaction list\n"));
42482ad756a6SMartin Matuska 		break;
4249eda14cbcSMatt Macy 	default:
4250eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("internal error: %s\n"),
4251eda14cbcSMatt Macy 		    strerror(errno));
4252eda14cbcSMatt Macy 	}
4253eda14cbcSMatt Macy 
4254eda14cbcSMatt Macy 	return (err);
4255eda14cbcSMatt Macy }
4256eda14cbcSMatt Macy 
4257eda14cbcSMatt Macy /*
4258eda14cbcSMatt Macy  * zfs rollback [-rRf] <snapshot>
4259eda14cbcSMatt Macy  *
4260eda14cbcSMatt Macy  *	-r	Delete any intervening snapshots before doing rollback
4261eda14cbcSMatt Macy  *	-R	Delete any snapshots and their clones
4262eda14cbcSMatt Macy  *	-f	ignored for backwards compatibility
4263eda14cbcSMatt Macy  *
4264eda14cbcSMatt Macy  * Given a filesystem, rollback to a specific snapshot, discarding any changes
4265eda14cbcSMatt Macy  * since then and making it the active dataset.  If more recent snapshots exist,
4266eda14cbcSMatt Macy  * the command will complain unless the '-r' flag is given.
4267eda14cbcSMatt Macy  */
4268eda14cbcSMatt Macy typedef struct rollback_cbdata {
4269eda14cbcSMatt Macy 	uint64_t	cb_create;
4270eda14cbcSMatt Macy 	uint8_t		cb_younger_ds_printed;
4271eda14cbcSMatt Macy 	boolean_t	cb_first;
4272eda14cbcSMatt Macy 	int		cb_doclones;
4273eda14cbcSMatt Macy 	char		*cb_target;
4274eda14cbcSMatt Macy 	int		cb_error;
4275eda14cbcSMatt Macy 	boolean_t	cb_recurse;
4276eda14cbcSMatt Macy } rollback_cbdata_t;
4277eda14cbcSMatt Macy 
4278eda14cbcSMatt Macy static int
4279eda14cbcSMatt Macy rollback_check_dependent(zfs_handle_t *zhp, void *data)
4280eda14cbcSMatt Macy {
4281eda14cbcSMatt Macy 	rollback_cbdata_t *cbp = data;
4282eda14cbcSMatt Macy 
4283eda14cbcSMatt Macy 	if (cbp->cb_first && cbp->cb_recurse) {
4284eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("cannot rollback to "
4285eda14cbcSMatt Macy 		    "'%s': clones of previous snapshots exist\n"),
4286eda14cbcSMatt Macy 		    cbp->cb_target);
4287eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("use '-R' to "
4288eda14cbcSMatt Macy 		    "force deletion of the following clones and "
4289eda14cbcSMatt Macy 		    "dependents:\n"));
4290eda14cbcSMatt Macy 		cbp->cb_first = 0;
4291eda14cbcSMatt Macy 		cbp->cb_error = 1;
4292eda14cbcSMatt Macy 	}
4293eda14cbcSMatt Macy 
4294eda14cbcSMatt Macy 	(void) fprintf(stderr, "%s\n", zfs_get_name(zhp));
4295eda14cbcSMatt Macy 
4296eda14cbcSMatt Macy 	zfs_close(zhp);
4297eda14cbcSMatt Macy 	return (0);
4298eda14cbcSMatt Macy }
4299eda14cbcSMatt Macy 
4300eda14cbcSMatt Macy 
4301eda14cbcSMatt Macy /*
4302eda14cbcSMatt Macy  * Report some snapshots/bookmarks more recent than the one specified.
4303eda14cbcSMatt Macy  * Used when '-r' is not specified. We reuse this same callback for the
4304eda14cbcSMatt Macy  * snapshot dependents - if 'cb_dependent' is set, then this is a
4305eda14cbcSMatt Macy  * dependent and we should report it without checking the transaction group.
4306eda14cbcSMatt Macy  */
4307eda14cbcSMatt Macy static int
4308eda14cbcSMatt Macy rollback_check(zfs_handle_t *zhp, void *data)
4309eda14cbcSMatt Macy {
4310eda14cbcSMatt Macy 	rollback_cbdata_t *cbp = data;
4311eda14cbcSMatt Macy 	/*
4312eda14cbcSMatt Macy 	 * Max number of younger snapshots and/or bookmarks to display before
4313eda14cbcSMatt Macy 	 * we stop the iteration.
4314eda14cbcSMatt Macy 	 */
4315eda14cbcSMatt Macy 	const uint8_t max_younger = 32;
4316eda14cbcSMatt Macy 
4317eda14cbcSMatt Macy 	if (cbp->cb_doclones) {
4318eda14cbcSMatt Macy 		zfs_close(zhp);
4319eda14cbcSMatt Macy 		return (0);
4320eda14cbcSMatt Macy 	}
4321eda14cbcSMatt Macy 
4322eda14cbcSMatt Macy 	if (zfs_prop_get_int(zhp, ZFS_PROP_CREATETXG) > cbp->cb_create) {
4323eda14cbcSMatt Macy 		if (cbp->cb_first && !cbp->cb_recurse) {
4324eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("cannot "
4325eda14cbcSMatt Macy 			    "rollback to '%s': more recent snapshots "
4326eda14cbcSMatt Macy 			    "or bookmarks exist\n"),
4327eda14cbcSMatt Macy 			    cbp->cb_target);
4328eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("use '-r' to "
4329eda14cbcSMatt Macy 			    "force deletion of the following "
4330eda14cbcSMatt Macy 			    "snapshots and bookmarks:\n"));
4331eda14cbcSMatt Macy 			cbp->cb_first = 0;
4332eda14cbcSMatt Macy 			cbp->cb_error = 1;
4333eda14cbcSMatt Macy 		}
4334eda14cbcSMatt Macy 
4335eda14cbcSMatt Macy 		if (cbp->cb_recurse) {
4336d411c1d6SMartin Matuska 			if (zfs_iter_dependents_v2(zhp, 0, B_TRUE,
4337eda14cbcSMatt Macy 			    rollback_check_dependent, cbp) != 0) {
4338eda14cbcSMatt Macy 				zfs_close(zhp);
4339eda14cbcSMatt Macy 				return (-1);
4340eda14cbcSMatt Macy 			}
4341eda14cbcSMatt Macy 		} else {
4342eda14cbcSMatt Macy 			(void) fprintf(stderr, "%s\n",
4343eda14cbcSMatt Macy 			    zfs_get_name(zhp));
4344eda14cbcSMatt Macy 			cbp->cb_younger_ds_printed++;
4345eda14cbcSMatt Macy 		}
4346eda14cbcSMatt Macy 	}
4347eda14cbcSMatt Macy 	zfs_close(zhp);
4348eda14cbcSMatt Macy 
4349eda14cbcSMatt Macy 	if (cbp->cb_younger_ds_printed == max_younger) {
4350eda14cbcSMatt Macy 		/*
4351eda14cbcSMatt Macy 		 * This non-recursive rollback is going to fail due to the
4352eda14cbcSMatt Macy 		 * presence of snapshots and/or bookmarks that are younger than
4353eda14cbcSMatt Macy 		 * the rollback target.
4354eda14cbcSMatt Macy 		 * We printed some of the offending objects, now we stop
4355eda14cbcSMatt Macy 		 * zfs_iter_snapshot/bookmark iteration so we can fail fast and
4356eda14cbcSMatt Macy 		 * avoid iterating over the rest of the younger objects
4357eda14cbcSMatt Macy 		 */
4358eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("Output limited to %d "
4359eda14cbcSMatt Macy 		    "snapshots/bookmarks\n"), max_younger);
4360eda14cbcSMatt Macy 		return (-1);
4361eda14cbcSMatt Macy 	}
4362eda14cbcSMatt Macy 	return (0);
4363eda14cbcSMatt Macy }
4364eda14cbcSMatt Macy 
4365eda14cbcSMatt Macy static int
4366eda14cbcSMatt Macy zfs_do_rollback(int argc, char **argv)
4367eda14cbcSMatt Macy {
4368eda14cbcSMatt Macy 	int ret = 0;
4369eda14cbcSMatt Macy 	int c;
4370eda14cbcSMatt Macy 	boolean_t force = B_FALSE;
4371eda14cbcSMatt Macy 	rollback_cbdata_t cb = { 0 };
4372eda14cbcSMatt Macy 	zfs_handle_t *zhp, *snap;
4373eda14cbcSMatt Macy 	char parentname[ZFS_MAX_DATASET_NAME_LEN];
4374eda14cbcSMatt Macy 	char *delim;
4375eda14cbcSMatt Macy 	uint64_t min_txg = 0;
4376eda14cbcSMatt Macy 
4377eda14cbcSMatt Macy 	/* check options */
4378eda14cbcSMatt Macy 	while ((c = getopt(argc, argv, "rRf")) != -1) {
4379eda14cbcSMatt Macy 		switch (c) {
4380eda14cbcSMatt Macy 		case 'r':
4381eda14cbcSMatt Macy 			cb.cb_recurse = 1;
4382eda14cbcSMatt Macy 			break;
4383eda14cbcSMatt Macy 		case 'R':
4384eda14cbcSMatt Macy 			cb.cb_recurse = 1;
4385eda14cbcSMatt Macy 			cb.cb_doclones = 1;
4386eda14cbcSMatt Macy 			break;
4387eda14cbcSMatt Macy 		case 'f':
4388eda14cbcSMatt Macy 			force = B_TRUE;
4389eda14cbcSMatt Macy 			break;
4390eda14cbcSMatt Macy 		case '?':
4391eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
4392eda14cbcSMatt Macy 			    optopt);
4393eda14cbcSMatt Macy 			usage(B_FALSE);
4394eda14cbcSMatt Macy 		}
4395eda14cbcSMatt Macy 	}
4396eda14cbcSMatt Macy 
4397eda14cbcSMatt Macy 	argc -= optind;
4398eda14cbcSMatt Macy 	argv += optind;
4399eda14cbcSMatt Macy 
4400eda14cbcSMatt Macy 	/* check number of arguments */
4401eda14cbcSMatt Macy 	if (argc < 1) {
4402eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("missing dataset argument\n"));
4403eda14cbcSMatt Macy 		usage(B_FALSE);
4404eda14cbcSMatt Macy 	}
4405eda14cbcSMatt Macy 	if (argc > 1) {
4406eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("too many arguments\n"));
4407eda14cbcSMatt Macy 		usage(B_FALSE);
4408eda14cbcSMatt Macy 	}
4409eda14cbcSMatt Macy 
4410eda14cbcSMatt Macy 	/* open the snapshot */
4411eda14cbcSMatt Macy 	if ((snap = zfs_open(g_zfs, argv[0], ZFS_TYPE_SNAPSHOT)) == NULL)
4412eda14cbcSMatt Macy 		return (1);
4413eda14cbcSMatt Macy 
4414eda14cbcSMatt Macy 	/* open the parent dataset */
4415eda14cbcSMatt Macy 	(void) strlcpy(parentname, argv[0], sizeof (parentname));
4416eda14cbcSMatt Macy 	verify((delim = strrchr(parentname, '@')) != NULL);
4417eda14cbcSMatt Macy 	*delim = '\0';
4418eda14cbcSMatt Macy 	if ((zhp = zfs_open(g_zfs, parentname, ZFS_TYPE_DATASET)) == NULL) {
4419eda14cbcSMatt Macy 		zfs_close(snap);
4420eda14cbcSMatt Macy 		return (1);
4421eda14cbcSMatt Macy 	}
4422eda14cbcSMatt Macy 
4423eda14cbcSMatt Macy 	/*
4424eda14cbcSMatt Macy 	 * Check for more recent snapshots and/or clones based on the presence
4425eda14cbcSMatt Macy 	 * of '-r' and '-R'.
4426eda14cbcSMatt Macy 	 */
4427eda14cbcSMatt Macy 	cb.cb_target = argv[0];
4428eda14cbcSMatt Macy 	cb.cb_create = zfs_prop_get_int(snap, ZFS_PROP_CREATETXG);
4429eda14cbcSMatt Macy 	cb.cb_first = B_TRUE;
4430eda14cbcSMatt Macy 	cb.cb_error = 0;
4431eda14cbcSMatt Macy 
4432eda14cbcSMatt Macy 	if (cb.cb_create > 0)
4433eda14cbcSMatt Macy 		min_txg = cb.cb_create;
4434eda14cbcSMatt Macy 
4435d411c1d6SMartin Matuska 	if ((ret = zfs_iter_snapshots_v2(zhp, 0, rollback_check, &cb,
4436eda14cbcSMatt Macy 	    min_txg, 0)) != 0)
4437eda14cbcSMatt Macy 		goto out;
4438d411c1d6SMartin Matuska 	if ((ret = zfs_iter_bookmarks_v2(zhp, 0, rollback_check, &cb)) != 0)
4439eda14cbcSMatt Macy 		goto out;
4440eda14cbcSMatt Macy 
4441eda14cbcSMatt Macy 	if ((ret = cb.cb_error) != 0)
4442eda14cbcSMatt Macy 		goto out;
4443eda14cbcSMatt Macy 
4444eda14cbcSMatt Macy 	/*
4445eda14cbcSMatt Macy 	 * Rollback parent to the given snapshot.
4446eda14cbcSMatt Macy 	 */
4447eda14cbcSMatt Macy 	ret = zfs_rollback(zhp, snap, force);
4448eda14cbcSMatt Macy 
4449eda14cbcSMatt Macy out:
4450eda14cbcSMatt Macy 	zfs_close(snap);
4451eda14cbcSMatt Macy 	zfs_close(zhp);
4452eda14cbcSMatt Macy 
4453eda14cbcSMatt Macy 	if (ret == 0)
4454eda14cbcSMatt Macy 		return (0);
4455eda14cbcSMatt Macy 	else
4456eda14cbcSMatt Macy 		return (1);
4457eda14cbcSMatt Macy }
4458eda14cbcSMatt Macy 
4459eda14cbcSMatt Macy /*
4460eda14cbcSMatt Macy  * zfs set property=value ... { fs | snap | vol } ...
4461eda14cbcSMatt Macy  *
4462eda14cbcSMatt Macy  * Sets the given properties for all datasets specified on the command line.
4463eda14cbcSMatt Macy  */
4464eda14cbcSMatt Macy 
4465eda14cbcSMatt Macy static int
4466eda14cbcSMatt Macy set_callback(zfs_handle_t *zhp, void *data)
4467eda14cbcSMatt Macy {
4468f7f4bd06SMartin Matuska 	zprop_set_cbdata_t *cb = data;
4469f7f4bd06SMartin Matuska 	int ret = zfs_prop_set_list_flags(zhp, cb->cb_proplist, cb->cb_flags);
4470eda14cbcSMatt Macy 
4471cbfe9975SMartin Matuska 	if (ret != 0 || libzfs_errno(g_zfs) != EZFS_SUCCESS) {
4472eda14cbcSMatt Macy 		switch (libzfs_errno(g_zfs)) {
4473eda14cbcSMatt Macy 		case EZFS_MOUNTFAILED:
4474eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("property may be set "
4475eda14cbcSMatt Macy 			    "but unable to remount filesystem\n"));
4476eda14cbcSMatt Macy 			break;
4477eda14cbcSMatt Macy 		case EZFS_SHARENFSFAILED:
4478eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("property may be set "
4479eda14cbcSMatt Macy 			    "but unable to reshare filesystem\n"));
4480eda14cbcSMatt Macy 			break;
4481eda14cbcSMatt Macy 		}
4482eda14cbcSMatt Macy 	}
4483cbfe9975SMartin Matuska 	return (ret);
4484eda14cbcSMatt Macy }
4485eda14cbcSMatt Macy 
4486eda14cbcSMatt Macy static int
4487eda14cbcSMatt Macy zfs_do_set(int argc, char **argv)
4488eda14cbcSMatt Macy {
4489f7f4bd06SMartin Matuska 	zprop_set_cbdata_t cb = { 0 };
4490eda14cbcSMatt Macy 	int ds_start = -1; /* argv idx of first dataset arg */
4491eda14cbcSMatt Macy 	int ret = 0;
4492f7f4bd06SMartin Matuska 	int i, c;
4493eda14cbcSMatt Macy 
4494f7f4bd06SMartin Matuska 	/* check options */
4495f7f4bd06SMartin Matuska 	while ((c = getopt(argc, argv, "u")) != -1) {
4496f7f4bd06SMartin Matuska 		switch (c) {
4497f7f4bd06SMartin Matuska 		case 'u':
4498f7f4bd06SMartin Matuska 			cb.cb_flags |= ZFS_SET_NOMOUNT;
4499f7f4bd06SMartin Matuska 			break;
4500f7f4bd06SMartin Matuska 		case '?':
4501f7f4bd06SMartin Matuska 		default:
4502eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
4503f7f4bd06SMartin Matuska 			    optopt);
4504eda14cbcSMatt Macy 			usage(B_FALSE);
4505eda14cbcSMatt Macy 		}
4506f7f4bd06SMartin Matuska 	}
4507f7f4bd06SMartin Matuska 
4508f7f4bd06SMartin Matuska 	argc -= optind;
4509f7f4bd06SMartin Matuska 	argv += optind;
4510eda14cbcSMatt Macy 
4511eda14cbcSMatt Macy 	/* check number of arguments */
4512f7f4bd06SMartin Matuska 	if (argc < 1) {
4513eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("missing arguments\n"));
4514eda14cbcSMatt Macy 		usage(B_FALSE);
4515eda14cbcSMatt Macy 	}
4516f7f4bd06SMartin Matuska 	if (argc < 2) {
4517f7f4bd06SMartin Matuska 		if (strchr(argv[0], '=') == NULL) {
4518eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("missing property=value "
4519eda14cbcSMatt Macy 			    "argument(s)\n"));
4520eda14cbcSMatt Macy 		} else {
4521eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("missing dataset "
4522eda14cbcSMatt Macy 			    "name(s)\n"));
4523eda14cbcSMatt Macy 		}
4524eda14cbcSMatt Macy 		usage(B_FALSE);
4525eda14cbcSMatt Macy 	}
4526eda14cbcSMatt Macy 
4527eda14cbcSMatt Macy 	/* validate argument order:  prop=val args followed by dataset args */
4528f7f4bd06SMartin Matuska 	for (i = 0; i < argc; i++) {
4529eda14cbcSMatt Macy 		if (strchr(argv[i], '=') != NULL) {
4530eda14cbcSMatt Macy 			if (ds_start > 0) {
4531eda14cbcSMatt Macy 				/* out-of-order prop=val argument */
4532eda14cbcSMatt Macy 				(void) fprintf(stderr, gettext("invalid "
4533eda14cbcSMatt Macy 				    "argument order\n"));
4534eda14cbcSMatt Macy 				usage(B_FALSE);
4535eda14cbcSMatt Macy 			}
4536eda14cbcSMatt Macy 		} else if (ds_start < 0) {
4537eda14cbcSMatt Macy 			ds_start = i;
4538eda14cbcSMatt Macy 		}
4539eda14cbcSMatt Macy 	}
4540eda14cbcSMatt Macy 	if (ds_start < 0) {
4541eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("missing dataset name(s)\n"));
4542eda14cbcSMatt Macy 		usage(B_FALSE);
4543eda14cbcSMatt Macy 	}
4544eda14cbcSMatt Macy 
4545eda14cbcSMatt Macy 	/* Populate a list of property settings */
4546f7f4bd06SMartin Matuska 	if (nvlist_alloc(&cb.cb_proplist, NV_UNIQUE_NAME, 0) != 0)
4547eda14cbcSMatt Macy 		nomem();
4548f7f4bd06SMartin Matuska 	for (i = 0; i < ds_start; i++) {
4549f7f4bd06SMartin Matuska 		if (!parseprop(cb.cb_proplist, argv[i])) {
4550eda14cbcSMatt Macy 			ret = -1;
4551eda14cbcSMatt Macy 			goto error;
4552eda14cbcSMatt Macy 		}
4553eda14cbcSMatt Macy 	}
4554eda14cbcSMatt Macy 
4555eda14cbcSMatt Macy 	ret = zfs_for_each(argc - ds_start, argv + ds_start, 0,
4556f7f4bd06SMartin Matuska 	    ZFS_TYPE_DATASET, NULL, NULL, 0, set_callback, &cb);
4557eda14cbcSMatt Macy 
4558eda14cbcSMatt Macy error:
4559f7f4bd06SMartin Matuska 	nvlist_free(cb.cb_proplist);
4560eda14cbcSMatt Macy 	return (ret);
4561eda14cbcSMatt Macy }
4562eda14cbcSMatt Macy 
4563eda14cbcSMatt Macy typedef struct snap_cbdata {
4564eda14cbcSMatt Macy 	nvlist_t *sd_nvl;
4565eda14cbcSMatt Macy 	boolean_t sd_recursive;
4566eda14cbcSMatt Macy 	const char *sd_snapname;
4567eda14cbcSMatt Macy } snap_cbdata_t;
4568eda14cbcSMatt Macy 
4569eda14cbcSMatt Macy static int
4570eda14cbcSMatt Macy zfs_snapshot_cb(zfs_handle_t *zhp, void *arg)
4571eda14cbcSMatt Macy {
4572eda14cbcSMatt Macy 	snap_cbdata_t *sd = arg;
4573eda14cbcSMatt Macy 	char *name;
4574eda14cbcSMatt Macy 	int rv = 0;
4575eda14cbcSMatt Macy 	int error;
4576eda14cbcSMatt Macy 
4577eda14cbcSMatt Macy 	if (sd->sd_recursive &&
4578eda14cbcSMatt Macy 	    zfs_prop_get_int(zhp, ZFS_PROP_INCONSISTENT) != 0) {
4579eda14cbcSMatt Macy 		zfs_close(zhp);
4580eda14cbcSMatt Macy 		return (0);
4581eda14cbcSMatt Macy 	}
4582eda14cbcSMatt Macy 
4583eda14cbcSMatt Macy 	error = asprintf(&name, "%s@%s", zfs_get_name(zhp), sd->sd_snapname);
4584eda14cbcSMatt Macy 	if (error == -1)
4585eda14cbcSMatt Macy 		nomem();
4586eda14cbcSMatt Macy 	fnvlist_add_boolean(sd->sd_nvl, name);
4587eda14cbcSMatt Macy 	free(name);
4588eda14cbcSMatt Macy 
4589eda14cbcSMatt Macy 	if (sd->sd_recursive)
4590d411c1d6SMartin Matuska 		rv = zfs_iter_filesystems_v2(zhp, 0, zfs_snapshot_cb, sd);
4591eda14cbcSMatt Macy 	zfs_close(zhp);
4592eda14cbcSMatt Macy 	return (rv);
4593eda14cbcSMatt Macy }
4594eda14cbcSMatt Macy 
4595eda14cbcSMatt Macy /*
4596eda14cbcSMatt Macy  * zfs snapshot [-r] [-o prop=value] ... <fs@snap>
4597eda14cbcSMatt Macy  *
4598eda14cbcSMatt Macy  * Creates a snapshot with the given name.  While functionally equivalent to
4599eda14cbcSMatt Macy  * 'zfs create', it is a separate command to differentiate intent.
4600eda14cbcSMatt Macy  */
4601eda14cbcSMatt Macy static int
4602eda14cbcSMatt Macy zfs_do_snapshot(int argc, char **argv)
4603eda14cbcSMatt Macy {
4604eda14cbcSMatt Macy 	int ret = 0;
4605eda14cbcSMatt Macy 	int c;
4606eda14cbcSMatt Macy 	nvlist_t *props;
4607eda14cbcSMatt Macy 	snap_cbdata_t sd = { 0 };
4608eda14cbcSMatt Macy 	boolean_t multiple_snaps = B_FALSE;
4609eda14cbcSMatt Macy 
4610eda14cbcSMatt Macy 	if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0)
4611eda14cbcSMatt Macy 		nomem();
4612eda14cbcSMatt Macy 	if (nvlist_alloc(&sd.sd_nvl, NV_UNIQUE_NAME, 0) != 0)
4613eda14cbcSMatt Macy 		nomem();
4614eda14cbcSMatt Macy 
4615eda14cbcSMatt Macy 	/* check options */
4616eda14cbcSMatt Macy 	while ((c = getopt(argc, argv, "ro:")) != -1) {
4617eda14cbcSMatt Macy 		switch (c) {
4618eda14cbcSMatt Macy 		case 'o':
4619eda14cbcSMatt Macy 			if (!parseprop(props, optarg)) {
4620eda14cbcSMatt Macy 				nvlist_free(sd.sd_nvl);
4621eda14cbcSMatt Macy 				nvlist_free(props);
4622eda14cbcSMatt Macy 				return (1);
4623eda14cbcSMatt Macy 			}
4624eda14cbcSMatt Macy 			break;
4625eda14cbcSMatt Macy 		case 'r':
4626eda14cbcSMatt Macy 			sd.sd_recursive = B_TRUE;
4627eda14cbcSMatt Macy 			multiple_snaps = B_TRUE;
4628eda14cbcSMatt Macy 			break;
4629eda14cbcSMatt Macy 		case '?':
4630eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
4631eda14cbcSMatt Macy 			    optopt);
4632eda14cbcSMatt Macy 			goto usage;
4633eda14cbcSMatt Macy 		}
4634eda14cbcSMatt Macy 	}
4635eda14cbcSMatt Macy 
4636eda14cbcSMatt Macy 	argc -= optind;
4637eda14cbcSMatt Macy 	argv += optind;
4638eda14cbcSMatt Macy 
4639eda14cbcSMatt Macy 	/* check number of arguments */
4640eda14cbcSMatt Macy 	if (argc < 1) {
4641eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("missing snapshot argument\n"));
4642eda14cbcSMatt Macy 		goto usage;
4643eda14cbcSMatt Macy 	}
4644eda14cbcSMatt Macy 
4645eda14cbcSMatt Macy 	if (argc > 1)
4646eda14cbcSMatt Macy 		multiple_snaps = B_TRUE;
4647eda14cbcSMatt Macy 	for (; argc > 0; argc--, argv++) {
4648eda14cbcSMatt Macy 		char *atp;
4649eda14cbcSMatt Macy 		zfs_handle_t *zhp;
4650eda14cbcSMatt Macy 
4651eda14cbcSMatt Macy 		atp = strchr(argv[0], '@');
4652eda14cbcSMatt Macy 		if (atp == NULL)
4653eda14cbcSMatt Macy 			goto usage;
4654eda14cbcSMatt Macy 		*atp = '\0';
4655eda14cbcSMatt Macy 		sd.sd_snapname = atp + 1;
4656eda14cbcSMatt Macy 		zhp = zfs_open(g_zfs, argv[0],
4657eda14cbcSMatt Macy 		    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
4658eda14cbcSMatt Macy 		if (zhp == NULL)
4659eda14cbcSMatt Macy 			goto usage;
4660eda14cbcSMatt Macy 		if (zfs_snapshot_cb(zhp, &sd) != 0)
4661eda14cbcSMatt Macy 			goto usage;
4662eda14cbcSMatt Macy 	}
4663eda14cbcSMatt Macy 
4664eda14cbcSMatt Macy 	ret = zfs_snapshot_nvl(g_zfs, sd.sd_nvl, props);
4665eda14cbcSMatt Macy 	nvlist_free(sd.sd_nvl);
4666eda14cbcSMatt Macy 	nvlist_free(props);
4667eda14cbcSMatt Macy 	if (ret != 0 && multiple_snaps)
4668eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("no snapshots were created\n"));
4669eda14cbcSMatt Macy 	return (ret != 0);
4670eda14cbcSMatt Macy 
4671eda14cbcSMatt Macy usage:
4672eda14cbcSMatt Macy 	nvlist_free(sd.sd_nvl);
4673eda14cbcSMatt Macy 	nvlist_free(props);
4674eda14cbcSMatt Macy 	usage(B_FALSE);
4675eda14cbcSMatt Macy 	return (-1);
4676eda14cbcSMatt Macy }
4677eda14cbcSMatt Macy 
4678716fd348SMartin Matuska /*
4679716fd348SMartin Matuska  * Array of prefixes to exclude –
4680716fd348SMartin Matuska  * a linear search, even if executed for each dataset,
4681716fd348SMartin Matuska  * is plenty good enough.
4682716fd348SMartin Matuska  */
4683da5137abSMartin Matuska typedef struct zfs_send_exclude_arg {
4684da5137abSMartin Matuska 	size_t count;
4685716fd348SMartin Matuska 	const char **list;
4686da5137abSMartin Matuska } zfs_send_exclude_arg_t;
4687da5137abSMartin Matuska 
4688da5137abSMartin Matuska static boolean_t
4689da5137abSMartin Matuska zfs_do_send_exclude(zfs_handle_t *zhp, void *context)
4690da5137abSMartin Matuska {
4691716fd348SMartin Matuska 	zfs_send_exclude_arg_t *excludes = context;
4692da5137abSMartin Matuska 	const char *name = zfs_get_name(zhp);
4693da5137abSMartin Matuska 
4694716fd348SMartin Matuska 	for (size_t i = 0; i < excludes->count; ++i) {
4695716fd348SMartin Matuska 		size_t len = strlen(excludes->list[i]);
4696716fd348SMartin Matuska 		if (strncmp(name, excludes->list[i], len) == 0 &&
4697716fd348SMartin Matuska 		    memchr("/@", name[len], sizeof ("/@")))
4698da5137abSMartin Matuska 			return (B_FALSE);
4699da5137abSMartin Matuska 	}
4700da5137abSMartin Matuska 
4701da5137abSMartin Matuska 	return (B_TRUE);
4702da5137abSMartin Matuska }
4703eda14cbcSMatt Macy 
4704eda14cbcSMatt Macy /*
4705eda14cbcSMatt Macy  * Send a backup stream to stdout.
4706eda14cbcSMatt Macy  */
4707eda14cbcSMatt Macy static int
4708eda14cbcSMatt Macy zfs_do_send(int argc, char **argv)
4709eda14cbcSMatt Macy {
4710eda14cbcSMatt Macy 	char *fromname = NULL;
4711eda14cbcSMatt Macy 	char *toname = NULL;
4712eda14cbcSMatt Macy 	char *resume_token = NULL;
4713eda14cbcSMatt Macy 	char *cp;
4714eda14cbcSMatt Macy 	zfs_handle_t *zhp;
4715eda14cbcSMatt Macy 	sendflags_t flags = { 0 };
4716eda14cbcSMatt Macy 	int c, err;
4717eda14cbcSMatt Macy 	nvlist_t *dbgnv = NULL;
4718eda14cbcSMatt Macy 	char *redactbook = NULL;
4719716fd348SMartin Matuska 	zfs_send_exclude_arg_t excludes = { 0 };
4720eda14cbcSMatt Macy 
4721eda14cbcSMatt Macy 	struct option long_options[] = {
4722eda14cbcSMatt Macy 		{"replicate",	no_argument,		NULL, 'R'},
472316038816SMartin Matuska 		{"skip-missing",	no_argument,	NULL, 's'},
4724eda14cbcSMatt Macy 		{"redact",	required_argument,	NULL, 'd'},
4725eda14cbcSMatt Macy 		{"props",	no_argument,		NULL, 'p'},
4726eda14cbcSMatt Macy 		{"parsable",	no_argument,		NULL, 'P'},
4727eda14cbcSMatt Macy 		{"dedup",	no_argument,		NULL, 'D'},
472815f0b8c3SMartin Matuska 		{"proctitle",	no_argument,		NULL, 'V'},
4729eda14cbcSMatt Macy 		{"verbose",	no_argument,		NULL, 'v'},
4730eda14cbcSMatt Macy 		{"dryrun",	no_argument,		NULL, 'n'},
4731eda14cbcSMatt Macy 		{"large-block",	no_argument,		NULL, 'L'},
4732eda14cbcSMatt Macy 		{"embed",	no_argument,		NULL, 'e'},
4733eda14cbcSMatt Macy 		{"resume",	required_argument,	NULL, 't'},
4734eda14cbcSMatt Macy 		{"compressed",	no_argument,		NULL, 'c'},
4735eda14cbcSMatt Macy 		{"raw",		no_argument,		NULL, 'w'},
4736eda14cbcSMatt Macy 		{"backup",	no_argument,		NULL, 'b'},
4737eda14cbcSMatt Macy 		{"holds",	no_argument,		NULL, 'h'},
4738eda14cbcSMatt Macy 		{"saved",	no_argument,		NULL, 'S'},
4739da5137abSMartin Matuska 		{"exclude",	required_argument,	NULL, 'X'},
4740eda14cbcSMatt Macy 		{0, 0, 0, 0}
4741eda14cbcSMatt Macy 	};
4742eda14cbcSMatt Macy 
4743eda14cbcSMatt Macy 	/* check options */
474415f0b8c3SMartin Matuska 	while ((c = getopt_long(argc, argv, ":i:I:RsDpVvnPLeht:cwbd:SX:",
4745eda14cbcSMatt Macy 	    long_options, NULL)) != -1) {
4746eda14cbcSMatt Macy 		switch (c) {
4747da5137abSMartin Matuska 		case 'X':
4748716fd348SMartin Matuska 			for (char *ds; (ds = strsep(&optarg, ",")) != NULL; ) {
4749716fd348SMartin Matuska 				if (!zfs_name_valid(ds, ZFS_TYPE_DATASET) ||
4750716fd348SMartin Matuska 				    strchr(ds, '/') == NULL) {
4751716fd348SMartin Matuska 					(void) fprintf(stderr, gettext("-X %s: "
4752716fd348SMartin Matuska 					    "not a valid non-root dataset name"
4753716fd348SMartin Matuska 					    ".\n"), ds);
4754716fd348SMartin Matuska 					usage(B_FALSE);
4755716fd348SMartin Matuska 				}
4756716fd348SMartin Matuska 				excludes.list = safe_realloc(excludes.list,
4757716fd348SMartin Matuska 				    sizeof (char *) * (excludes.count + 1));
4758716fd348SMartin Matuska 				excludes.list[excludes.count++] = ds;
4759716fd348SMartin Matuska 			}
4760da5137abSMartin Matuska 			break;
4761eda14cbcSMatt Macy 		case 'i':
4762eda14cbcSMatt Macy 			if (fromname)
4763eda14cbcSMatt Macy 				usage(B_FALSE);
4764eda14cbcSMatt Macy 			fromname = optarg;
4765eda14cbcSMatt Macy 			break;
4766eda14cbcSMatt Macy 		case 'I':
4767eda14cbcSMatt Macy 			if (fromname)
4768eda14cbcSMatt Macy 				usage(B_FALSE);
4769eda14cbcSMatt Macy 			fromname = optarg;
4770eda14cbcSMatt Macy 			flags.doall = B_TRUE;
4771eda14cbcSMatt Macy 			break;
4772eda14cbcSMatt Macy 		case 'R':
4773eda14cbcSMatt Macy 			flags.replicate = B_TRUE;
4774eda14cbcSMatt Macy 			break;
477516038816SMartin Matuska 		case 's':
477616038816SMartin Matuska 			flags.skipmissing = B_TRUE;
477716038816SMartin Matuska 			break;
4778eda14cbcSMatt Macy 		case 'd':
4779eda14cbcSMatt Macy 			redactbook = optarg;
4780eda14cbcSMatt Macy 			break;
4781eda14cbcSMatt Macy 		case 'p':
4782eda14cbcSMatt Macy 			flags.props = B_TRUE;
4783eda14cbcSMatt Macy 			break;
4784eda14cbcSMatt Macy 		case 'b':
4785eda14cbcSMatt Macy 			flags.backup = B_TRUE;
4786eda14cbcSMatt Macy 			break;
4787eda14cbcSMatt Macy 		case 'h':
4788eda14cbcSMatt Macy 			flags.holds = B_TRUE;
4789eda14cbcSMatt Macy 			break;
4790eda14cbcSMatt Macy 		case 'P':
4791eda14cbcSMatt Macy 			flags.parsable = B_TRUE;
4792eda14cbcSMatt Macy 			break;
479315f0b8c3SMartin Matuska 		case 'V':
479415f0b8c3SMartin Matuska 			flags.progressastitle = B_TRUE;
479515f0b8c3SMartin Matuska 			break;
4796eda14cbcSMatt Macy 		case 'v':
4797eda14cbcSMatt Macy 			flags.verbosity++;
4798eda14cbcSMatt Macy 			flags.progress = B_TRUE;
4799eda14cbcSMatt Macy 			break;
4800eda14cbcSMatt Macy 		case 'D':
4801eda14cbcSMatt Macy 			(void) fprintf(stderr,
4802eda14cbcSMatt Macy 			    gettext("WARNING: deduplicated send is no "
4803eda14cbcSMatt Macy 			    "longer supported.  A regular,\n"
4804eda14cbcSMatt Macy 			    "non-deduplicated stream will be generated.\n\n"));
4805eda14cbcSMatt Macy 			break;
4806eda14cbcSMatt Macy 		case 'n':
4807eda14cbcSMatt Macy 			flags.dryrun = B_TRUE;
4808eda14cbcSMatt Macy 			break;
4809eda14cbcSMatt Macy 		case 'L':
4810eda14cbcSMatt Macy 			flags.largeblock = B_TRUE;
4811eda14cbcSMatt Macy 			break;
4812eda14cbcSMatt Macy 		case 'e':
4813eda14cbcSMatt Macy 			flags.embed_data = B_TRUE;
4814eda14cbcSMatt Macy 			break;
4815eda14cbcSMatt Macy 		case 't':
4816eda14cbcSMatt Macy 			resume_token = optarg;
4817eda14cbcSMatt Macy 			break;
4818eda14cbcSMatt Macy 		case 'c':
4819eda14cbcSMatt Macy 			flags.compress = B_TRUE;
4820eda14cbcSMatt Macy 			break;
4821eda14cbcSMatt Macy 		case 'w':
4822eda14cbcSMatt Macy 			flags.raw = B_TRUE;
4823eda14cbcSMatt Macy 			flags.compress = B_TRUE;
4824eda14cbcSMatt Macy 			flags.embed_data = B_TRUE;
4825eda14cbcSMatt Macy 			flags.largeblock = B_TRUE;
4826eda14cbcSMatt Macy 			break;
4827eda14cbcSMatt Macy 		case 'S':
4828eda14cbcSMatt Macy 			flags.saved = B_TRUE;
4829eda14cbcSMatt Macy 			break;
4830eda14cbcSMatt Macy 		case ':':
4831eda14cbcSMatt Macy 			/*
4832eda14cbcSMatt Macy 			 * If a parameter was not passed, optopt contains the
4833eda14cbcSMatt Macy 			 * value that would normally lead us into the
4834eda14cbcSMatt Macy 			 * appropriate case statement.  If it's > 256, then this
4835eda14cbcSMatt Macy 			 * must be a longopt and we should look at argv to get
4836eda14cbcSMatt Macy 			 * the string.  Otherwise it's just the character, so we
4837eda14cbcSMatt Macy 			 * should use it directly.
4838eda14cbcSMatt Macy 			 */
4839eda14cbcSMatt Macy 			if (optopt <= UINT8_MAX) {
4840eda14cbcSMatt Macy 				(void) fprintf(stderr,
4841eda14cbcSMatt Macy 				    gettext("missing argument for '%c' "
4842eda14cbcSMatt Macy 				    "option\n"), optopt);
4843eda14cbcSMatt Macy 			} else {
4844eda14cbcSMatt Macy 				(void) fprintf(stderr,
4845eda14cbcSMatt Macy 				    gettext("missing argument for '%s' "
4846eda14cbcSMatt Macy 				    "option\n"), argv[optind - 1]);
4847eda14cbcSMatt Macy 			}
4848dbd5678dSMartin Matuska 			free(excludes.list);
4849eda14cbcSMatt Macy 			usage(B_FALSE);
4850eda14cbcSMatt Macy 			break;
4851eda14cbcSMatt Macy 		case '?':
4852eda14cbcSMatt Macy 		default:
4853eda14cbcSMatt Macy 			/*
4854eda14cbcSMatt Macy 			 * If an invalid flag was passed, optopt contains the
4855eda14cbcSMatt Macy 			 * character if it was a short flag, or 0 if it was a
4856eda14cbcSMatt Macy 			 * longopt.
4857eda14cbcSMatt Macy 			 */
4858eda14cbcSMatt Macy 			if (optopt != 0) {
4859eda14cbcSMatt Macy 				(void) fprintf(stderr,
4860eda14cbcSMatt Macy 				    gettext("invalid option '%c'\n"), optopt);
4861eda14cbcSMatt Macy 			} else {
4862eda14cbcSMatt Macy 				(void) fprintf(stderr,
4863eda14cbcSMatt Macy 				    gettext("invalid option '%s'\n"),
4864eda14cbcSMatt Macy 				    argv[optind - 1]);
4865eda14cbcSMatt Macy 
4866eda14cbcSMatt Macy 			}
4867dbd5678dSMartin Matuska 			free(excludes.list);
4868eda14cbcSMatt Macy 			usage(B_FALSE);
4869eda14cbcSMatt Macy 		}
4870eda14cbcSMatt Macy 	}
4871eda14cbcSMatt Macy 
4872c9539b89SMartin Matuska 	if ((flags.parsable || flags.progressastitle) && flags.verbosity == 0)
4873eda14cbcSMatt Macy 		flags.verbosity = 1;
4874eda14cbcSMatt Macy 
4875716fd348SMartin Matuska 	if (excludes.count > 0 && !flags.replicate) {
4876dbd5678dSMartin Matuska 		free(excludes.list);
4877da5137abSMartin Matuska 		(void) fprintf(stderr, gettext("Cannot specify "
4878da5137abSMartin Matuska 		    "dataset exclusion (-X) on a non-recursive "
4879da5137abSMartin Matuska 		    "send.\n"));
4880da5137abSMartin Matuska 		return (1);
4881da5137abSMartin Matuska 	}
4882da5137abSMartin Matuska 
4883eda14cbcSMatt Macy 	argc -= optind;
4884eda14cbcSMatt Macy 	argv += optind;
4885eda14cbcSMatt Macy 
4886eda14cbcSMatt Macy 	if (resume_token != NULL) {
4887eda14cbcSMatt Macy 		if (fromname != NULL || flags.replicate || flags.props ||
4888eda14cbcSMatt Macy 		    flags.backup || flags.holds ||
4889eda14cbcSMatt Macy 		    flags.saved || redactbook != NULL) {
4890dbd5678dSMartin Matuska 			free(excludes.list);
4891eda14cbcSMatt Macy 			(void) fprintf(stderr,
4892eda14cbcSMatt Macy 			    gettext("invalid flags combined with -t\n"));
4893eda14cbcSMatt Macy 			usage(B_FALSE);
4894eda14cbcSMatt Macy 		}
4895eda14cbcSMatt Macy 		if (argc > 0) {
4896dbd5678dSMartin Matuska 			free(excludes.list);
4897eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("too many arguments\n"));
4898eda14cbcSMatt Macy 			usage(B_FALSE);
4899eda14cbcSMatt Macy 		}
4900eda14cbcSMatt Macy 	} else {
4901eda14cbcSMatt Macy 		if (argc < 1) {
4902dbd5678dSMartin Matuska 			free(excludes.list);
4903eda14cbcSMatt Macy 			(void) fprintf(stderr,
4904eda14cbcSMatt Macy 			    gettext("missing snapshot argument\n"));
4905eda14cbcSMatt Macy 			usage(B_FALSE);
4906eda14cbcSMatt Macy 		}
4907eda14cbcSMatt Macy 		if (argc > 1) {
4908dbd5678dSMartin Matuska 			free(excludes.list);
4909eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("too many arguments\n"));
4910eda14cbcSMatt Macy 			usage(B_FALSE);
4911eda14cbcSMatt Macy 		}
4912eda14cbcSMatt Macy 	}
4913eda14cbcSMatt Macy 
4914eda14cbcSMatt Macy 	if (flags.saved) {
4915eda14cbcSMatt Macy 		if (fromname != NULL || flags.replicate || flags.props ||
4916eda14cbcSMatt Macy 		    flags.doall || flags.backup ||
4917eda14cbcSMatt Macy 		    flags.holds || flags.largeblock || flags.embed_data ||
4918eda14cbcSMatt Macy 		    flags.compress || flags.raw || redactbook != NULL) {
4919dbd5678dSMartin Matuska 			free(excludes.list);
4920dbd5678dSMartin Matuska 
4921eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("incompatible flags "
4922eda14cbcSMatt Macy 			    "combined with saved send flag\n"));
4923eda14cbcSMatt Macy 			usage(B_FALSE);
4924eda14cbcSMatt Macy 		}
4925eda14cbcSMatt Macy 		if (strchr(argv[0], '@') != NULL) {
4926dbd5678dSMartin Matuska 			free(excludes.list);
4927dbd5678dSMartin Matuska 
4928eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("saved send must "
4929eda14cbcSMatt Macy 			    "specify the dataset with partially-received "
4930eda14cbcSMatt Macy 			    "state\n"));
4931eda14cbcSMatt Macy 			usage(B_FALSE);
4932eda14cbcSMatt Macy 		}
4933eda14cbcSMatt Macy 	}
4934eda14cbcSMatt Macy 
4935eda14cbcSMatt Macy 	if (flags.raw && redactbook != NULL) {
4936dbd5678dSMartin Matuska 		free(excludes.list);
4937eda14cbcSMatt Macy 		(void) fprintf(stderr,
4938eda14cbcSMatt Macy 		    gettext("Error: raw sends may not be redacted.\n"));
4939eda14cbcSMatt Macy 		return (1);
4940eda14cbcSMatt Macy 	}
4941eda14cbcSMatt Macy 
4942eda14cbcSMatt Macy 	if (!flags.dryrun && isatty(STDOUT_FILENO)) {
4943dbd5678dSMartin Matuska 		free(excludes.list);
4944eda14cbcSMatt Macy 		(void) fprintf(stderr,
4945eda14cbcSMatt Macy 		    gettext("Error: Stream can not be written to a terminal.\n"
4946eda14cbcSMatt Macy 		    "You must redirect standard output.\n"));
4947eda14cbcSMatt Macy 		return (1);
4948eda14cbcSMatt Macy 	}
4949eda14cbcSMatt Macy 
4950eda14cbcSMatt Macy 	if (flags.saved) {
4951eda14cbcSMatt Macy 		zhp = zfs_open(g_zfs, argv[0], ZFS_TYPE_DATASET);
4952dbd5678dSMartin Matuska 		if (zhp == NULL) {
4953dbd5678dSMartin Matuska 			free(excludes.list);
4954eda14cbcSMatt Macy 			return (1);
4955dbd5678dSMartin Matuska 		}
4956eda14cbcSMatt Macy 
4957eda14cbcSMatt Macy 		err = zfs_send_saved(zhp, &flags, STDOUT_FILENO,
4958eda14cbcSMatt Macy 		    resume_token);
4959dbd5678dSMartin Matuska 		free(excludes.list);
4960eda14cbcSMatt Macy 		zfs_close(zhp);
4961eda14cbcSMatt Macy 		return (err != 0);
4962eda14cbcSMatt Macy 	} else if (resume_token != NULL) {
4963dbd5678dSMartin Matuska 		free(excludes.list);
4964c03c5b1cSMartin Matuska 		return (zfs_send_resume(g_zfs, &flags, STDOUT_FILENO,
4965c03c5b1cSMartin Matuska 		    resume_token));
4966eda14cbcSMatt Macy 	}
4967eda14cbcSMatt Macy 
496816038816SMartin Matuska 	if (flags.skipmissing && !flags.replicate) {
4969dbd5678dSMartin Matuska 		free(excludes.list);
497016038816SMartin Matuska 		(void) fprintf(stderr,
497116038816SMartin Matuska 		    gettext("skip-missing flag can only be used in "
497216038816SMartin Matuska 		    "conjunction with replicate\n"));
497316038816SMartin Matuska 		usage(B_FALSE);
497416038816SMartin Matuska 	}
497516038816SMartin Matuska 
4976eda14cbcSMatt Macy 	/*
4977eda14cbcSMatt Macy 	 * For everything except -R and -I, use the new, cleaner code path.
4978eda14cbcSMatt Macy 	 */
4979eda14cbcSMatt Macy 	if (!(flags.replicate || flags.doall)) {
4980eda14cbcSMatt Macy 		char frombuf[ZFS_MAX_DATASET_NAME_LEN];
4981eda14cbcSMatt Macy 
4982eda14cbcSMatt Macy 		if (fromname != NULL && (strchr(fromname, '#') == NULL &&
4983eda14cbcSMatt Macy 		    strchr(fromname, '@') == NULL)) {
4984eda14cbcSMatt Macy 			/*
4985eda14cbcSMatt Macy 			 * Neither bookmark or snapshot was specified.  Print a
4986eda14cbcSMatt Macy 			 * warning, and assume snapshot.
4987eda14cbcSMatt Macy 			 */
4988eda14cbcSMatt Macy 			(void) fprintf(stderr, "Warning: incremental source "
4989eda14cbcSMatt Macy 			    "didn't specify type, assuming snapshot. Use '@' "
4990eda14cbcSMatt Macy 			    "or '#' prefix to avoid ambiguity.\n");
4991eda14cbcSMatt Macy 			(void) snprintf(frombuf, sizeof (frombuf), "@%s",
4992eda14cbcSMatt Macy 			    fromname);
4993eda14cbcSMatt Macy 			fromname = frombuf;
4994eda14cbcSMatt Macy 		}
4995eda14cbcSMatt Macy 		if (fromname != NULL &&
4996eda14cbcSMatt Macy 		    (fromname[0] == '#' || fromname[0] == '@')) {
4997eda14cbcSMatt Macy 			/*
4998eda14cbcSMatt Macy 			 * Incremental source name begins with # or @.
4999eda14cbcSMatt Macy 			 * Default to same fs as target.
5000eda14cbcSMatt Macy 			 */
5001eda14cbcSMatt Macy 			char tmpbuf[ZFS_MAX_DATASET_NAME_LEN];
5002eda14cbcSMatt Macy 			(void) strlcpy(tmpbuf, fromname, sizeof (tmpbuf));
5003eda14cbcSMatt Macy 			(void) strlcpy(frombuf, argv[0], sizeof (frombuf));
5004eda14cbcSMatt Macy 			cp = strchr(frombuf, '@');
5005eda14cbcSMatt Macy 			if (cp != NULL)
5006eda14cbcSMatt Macy 				*cp = '\0';
5007eda14cbcSMatt Macy 			(void) strlcat(frombuf, tmpbuf, sizeof (frombuf));
5008eda14cbcSMatt Macy 			fromname = frombuf;
5009eda14cbcSMatt Macy 		}
5010eda14cbcSMatt Macy 
5011eda14cbcSMatt Macy 		zhp = zfs_open(g_zfs, argv[0], ZFS_TYPE_DATASET);
5012dbd5678dSMartin Matuska 		if (zhp == NULL) {
5013dbd5678dSMartin Matuska 			free(excludes.list);
5014eda14cbcSMatt Macy 			return (1);
5015dbd5678dSMartin Matuska 		}
5016eda14cbcSMatt Macy 		err = zfs_send_one(zhp, fromname, STDOUT_FILENO, &flags,
5017eda14cbcSMatt Macy 		    redactbook);
5018dbd5678dSMartin Matuska 
5019dbd5678dSMartin Matuska 		free(excludes.list);
5020eda14cbcSMatt Macy 		zfs_close(zhp);
5021eda14cbcSMatt Macy 		return (err != 0);
5022eda14cbcSMatt Macy 	}
5023eda14cbcSMatt Macy 
5024eda14cbcSMatt Macy 	if (fromname != NULL && strchr(fromname, '#')) {
5025eda14cbcSMatt Macy 		(void) fprintf(stderr,
5026eda14cbcSMatt Macy 		    gettext("Error: multiple snapshots cannot be "
5027eda14cbcSMatt Macy 		    "sent from a bookmark.\n"));
5028dbd5678dSMartin Matuska 		free(excludes.list);
5029eda14cbcSMatt Macy 		return (1);
5030eda14cbcSMatt Macy 	}
5031eda14cbcSMatt Macy 
5032eda14cbcSMatt Macy 	if (redactbook != NULL) {
5033eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("Error: multiple snapshots "
5034eda14cbcSMatt Macy 		    "cannot be sent redacted.\n"));
5035dbd5678dSMartin Matuska 		free(excludes.list);
5036eda14cbcSMatt Macy 		return (1);
5037eda14cbcSMatt Macy 	}
5038eda14cbcSMatt Macy 
5039eda14cbcSMatt Macy 	if ((cp = strchr(argv[0], '@')) == NULL) {
5040eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("Error: "
5041eda14cbcSMatt Macy 		    "Unsupported flag with filesystem or bookmark.\n"));
5042dbd5678dSMartin Matuska 		free(excludes.list);
5043eda14cbcSMatt Macy 		return (1);
5044eda14cbcSMatt Macy 	}
5045eda14cbcSMatt Macy 	*cp = '\0';
5046eda14cbcSMatt Macy 	toname = cp + 1;
5047eda14cbcSMatt Macy 	zhp = zfs_open(g_zfs, argv[0], ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
5048dbd5678dSMartin Matuska 	if (zhp == NULL) {
5049dbd5678dSMartin Matuska 		free(excludes.list);
5050eda14cbcSMatt Macy 		return (1);
5051dbd5678dSMartin Matuska 	}
5052eda14cbcSMatt Macy 
5053eda14cbcSMatt Macy 	/*
5054eda14cbcSMatt Macy 	 * If they specified the full path to the snapshot, chop off
5055eda14cbcSMatt Macy 	 * everything except the short name of the snapshot, but special
5056eda14cbcSMatt Macy 	 * case if they specify the origin.
5057eda14cbcSMatt Macy 	 */
5058eda14cbcSMatt Macy 	if (fromname && (cp = strchr(fromname, '@')) != NULL) {
5059eda14cbcSMatt Macy 		char origin[ZFS_MAX_DATASET_NAME_LEN];
5060eda14cbcSMatt Macy 		zprop_source_t src;
5061eda14cbcSMatt Macy 
5062eda14cbcSMatt Macy 		(void) zfs_prop_get(zhp, ZFS_PROP_ORIGIN,
5063eda14cbcSMatt Macy 		    origin, sizeof (origin), &src, NULL, 0, B_FALSE);
5064eda14cbcSMatt Macy 
5065eda14cbcSMatt Macy 		if (strcmp(origin, fromname) == 0) {
5066eda14cbcSMatt Macy 			fromname = NULL;
5067eda14cbcSMatt Macy 			flags.fromorigin = B_TRUE;
5068eda14cbcSMatt Macy 		} else {
5069eda14cbcSMatt Macy 			*cp = '\0';
5070eda14cbcSMatt Macy 			if (cp != fromname && strcmp(argv[0], fromname)) {
5071dbd5678dSMartin Matuska 				zfs_close(zhp);
5072dbd5678dSMartin Matuska 				free(excludes.list);
5073eda14cbcSMatt Macy 				(void) fprintf(stderr,
5074eda14cbcSMatt Macy 				    gettext("incremental source must be "
5075eda14cbcSMatt Macy 				    "in same filesystem\n"));
5076eda14cbcSMatt Macy 				usage(B_FALSE);
5077eda14cbcSMatt Macy 			}
5078eda14cbcSMatt Macy 			fromname = cp + 1;
5079eda14cbcSMatt Macy 			if (strchr(fromname, '@') || strchr(fromname, '/')) {
5080dbd5678dSMartin Matuska 				zfs_close(zhp);
5081dbd5678dSMartin Matuska 				free(excludes.list);
5082eda14cbcSMatt Macy 				(void) fprintf(stderr,
5083eda14cbcSMatt Macy 				    gettext("invalid incremental source\n"));
5084eda14cbcSMatt Macy 				usage(B_FALSE);
5085eda14cbcSMatt Macy 			}
5086eda14cbcSMatt Macy 		}
5087eda14cbcSMatt Macy 	}
5088eda14cbcSMatt Macy 
5089eda14cbcSMatt Macy 	if (flags.replicate && fromname == NULL)
5090eda14cbcSMatt Macy 		flags.doall = B_TRUE;
5091eda14cbcSMatt Macy 
5092da5137abSMartin Matuska 	err = zfs_send(zhp, fromname, toname, &flags, STDOUT_FILENO,
5093716fd348SMartin Matuska 	    excludes.count > 0 ? zfs_do_send_exclude : NULL,
5094716fd348SMartin Matuska 	    &excludes, flags.verbosity >= 3 ? &dbgnv : NULL);
5095eda14cbcSMatt Macy 
5096eda14cbcSMatt Macy 	if (flags.verbosity >= 3 && dbgnv != NULL) {
5097eda14cbcSMatt Macy 		/*
5098eda14cbcSMatt Macy 		 * dump_nvlist prints to stdout, but that's been
5099eda14cbcSMatt Macy 		 * redirected to a file.  Make it print to stderr
5100eda14cbcSMatt Macy 		 * instead.
5101eda14cbcSMatt Macy 		 */
5102eda14cbcSMatt Macy 		(void) dup2(STDERR_FILENO, STDOUT_FILENO);
5103eda14cbcSMatt Macy 		dump_nvlist(dbgnv, 0);
5104eda14cbcSMatt Macy 		nvlist_free(dbgnv);
5105eda14cbcSMatt Macy 	}
5106eda14cbcSMatt Macy 
5107716fd348SMartin Matuska 	zfs_close(zhp);
5108716fd348SMartin Matuska 	free(excludes.list);
5109eda14cbcSMatt Macy 	return (err != 0);
5110eda14cbcSMatt Macy }
5111eda14cbcSMatt Macy 
5112eda14cbcSMatt Macy /*
5113eda14cbcSMatt Macy  * Restore a backup stream from stdin.
5114eda14cbcSMatt Macy  */
5115eda14cbcSMatt Macy static int
5116eda14cbcSMatt Macy zfs_do_receive(int argc, char **argv)
5117eda14cbcSMatt Macy {
5118eda14cbcSMatt Macy 	int c, err = 0;
5119eda14cbcSMatt Macy 	recvflags_t flags = { 0 };
5120eda14cbcSMatt Macy 	boolean_t abort_resumable = B_FALSE;
5121eda14cbcSMatt Macy 	nvlist_t *props;
5122eda14cbcSMatt Macy 
5123eda14cbcSMatt Macy 	if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0)
5124eda14cbcSMatt Macy 		nomem();
5125eda14cbcSMatt Macy 
5126eda14cbcSMatt Macy 	/* check options */
5127271171e0SMartin Matuska 	while ((c = getopt(argc, argv, ":o:x:dehMnuvFsAc")) != -1) {
5128eda14cbcSMatt Macy 		switch (c) {
5129eda14cbcSMatt Macy 		case 'o':
5130eda14cbcSMatt Macy 			if (!parseprop(props, optarg)) {
5131eda14cbcSMatt Macy 				nvlist_free(props);
5132eda14cbcSMatt Macy 				usage(B_FALSE);
5133eda14cbcSMatt Macy 			}
5134eda14cbcSMatt Macy 			break;
5135eda14cbcSMatt Macy 		case 'x':
5136eda14cbcSMatt Macy 			if (!parsepropname(props, optarg)) {
5137eda14cbcSMatt Macy 				nvlist_free(props);
5138eda14cbcSMatt Macy 				usage(B_FALSE);
5139eda14cbcSMatt Macy 			}
5140eda14cbcSMatt Macy 			break;
5141eda14cbcSMatt Macy 		case 'd':
5142eda14cbcSMatt Macy 			if (flags.istail) {
5143eda14cbcSMatt Macy 				(void) fprintf(stderr, gettext("invalid option "
5144eda14cbcSMatt Macy 				    "combination: -d and -e are mutually "
5145eda14cbcSMatt Macy 				    "exclusive\n"));
5146eda14cbcSMatt Macy 				usage(B_FALSE);
5147eda14cbcSMatt Macy 			}
5148eda14cbcSMatt Macy 			flags.isprefix = B_TRUE;
5149eda14cbcSMatt Macy 			break;
5150eda14cbcSMatt Macy 		case 'e':
5151eda14cbcSMatt Macy 			if (flags.isprefix) {
5152eda14cbcSMatt Macy 				(void) fprintf(stderr, gettext("invalid option "
5153eda14cbcSMatt Macy 				    "combination: -d and -e are mutually "
5154eda14cbcSMatt Macy 				    "exclusive\n"));
5155eda14cbcSMatt Macy 				usage(B_FALSE);
5156eda14cbcSMatt Macy 			}
5157eda14cbcSMatt Macy 			flags.istail = B_TRUE;
5158eda14cbcSMatt Macy 			break;
5159eda14cbcSMatt Macy 		case 'h':
5160eda14cbcSMatt Macy 			flags.skipholds = B_TRUE;
5161eda14cbcSMatt Macy 			break;
5162eda14cbcSMatt Macy 		case 'M':
5163eda14cbcSMatt Macy 			flags.forceunmount = B_TRUE;
5164eda14cbcSMatt Macy 			break;
5165eda14cbcSMatt Macy 		case 'n':
5166eda14cbcSMatt Macy 			flags.dryrun = B_TRUE;
5167eda14cbcSMatt Macy 			break;
5168eda14cbcSMatt Macy 		case 'u':
5169eda14cbcSMatt Macy 			flags.nomount = B_TRUE;
5170eda14cbcSMatt Macy 			break;
5171eda14cbcSMatt Macy 		case 'v':
5172eda14cbcSMatt Macy 			flags.verbose = B_TRUE;
5173eda14cbcSMatt Macy 			break;
5174eda14cbcSMatt Macy 		case 's':
5175eda14cbcSMatt Macy 			flags.resumable = B_TRUE;
5176eda14cbcSMatt Macy 			break;
5177eda14cbcSMatt Macy 		case 'F':
5178eda14cbcSMatt Macy 			flags.force = B_TRUE;
5179eda14cbcSMatt Macy 			break;
5180eda14cbcSMatt Macy 		case 'A':
5181eda14cbcSMatt Macy 			abort_resumable = B_TRUE;
5182eda14cbcSMatt Macy 			break;
5183271171e0SMartin Matuska 		case 'c':
5184271171e0SMartin Matuska 			flags.heal = B_TRUE;
5185271171e0SMartin Matuska 			break;
5186eda14cbcSMatt Macy 		case ':':
5187eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("missing argument for "
5188eda14cbcSMatt Macy 			    "'%c' option\n"), optopt);
5189eda14cbcSMatt Macy 			usage(B_FALSE);
5190eda14cbcSMatt Macy 			break;
5191eda14cbcSMatt Macy 		case '?':
5192eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
5193eda14cbcSMatt Macy 			    optopt);
5194eda14cbcSMatt Macy 			usage(B_FALSE);
5195eda14cbcSMatt Macy 		}
5196eda14cbcSMatt Macy 	}
5197eda14cbcSMatt Macy 
5198eda14cbcSMatt Macy 	argc -= optind;
5199eda14cbcSMatt Macy 	argv += optind;
5200eda14cbcSMatt Macy 
5201eda14cbcSMatt Macy 	/* zfs recv -e (use "tail" name) implies -d (remove dataset "head") */
5202eda14cbcSMatt Macy 	if (flags.istail)
5203eda14cbcSMatt Macy 		flags.isprefix = B_TRUE;
5204eda14cbcSMatt Macy 
5205eda14cbcSMatt Macy 	/* check number of arguments */
5206eda14cbcSMatt Macy 	if (argc < 1) {
5207eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("missing snapshot argument\n"));
5208eda14cbcSMatt Macy 		usage(B_FALSE);
5209eda14cbcSMatt Macy 	}
5210eda14cbcSMatt Macy 	if (argc > 1) {
5211eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("too many arguments\n"));
5212eda14cbcSMatt Macy 		usage(B_FALSE);
5213eda14cbcSMatt Macy 	}
5214eda14cbcSMatt Macy 
5215eda14cbcSMatt Macy 	if (abort_resumable) {
5216eda14cbcSMatt Macy 		if (flags.isprefix || flags.istail || flags.dryrun ||
5217eda14cbcSMatt Macy 		    flags.resumable || flags.nomount) {
5218eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("invalid option\n"));
5219eda14cbcSMatt Macy 			usage(B_FALSE);
5220eda14cbcSMatt Macy 		}
5221eda14cbcSMatt Macy 
5222eda14cbcSMatt Macy 		char namebuf[ZFS_MAX_DATASET_NAME_LEN];
5223eda14cbcSMatt Macy 		(void) snprintf(namebuf, sizeof (namebuf),
5224eda14cbcSMatt Macy 		    "%s/%%recv", argv[0]);
5225eda14cbcSMatt Macy 
5226eda14cbcSMatt Macy 		if (zfs_dataset_exists(g_zfs, namebuf,
5227eda14cbcSMatt Macy 		    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME)) {
5228eda14cbcSMatt Macy 			zfs_handle_t *zhp = zfs_open(g_zfs,
5229eda14cbcSMatt Macy 			    namebuf, ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
5230eda14cbcSMatt Macy 			if (zhp == NULL) {
5231eda14cbcSMatt Macy 				nvlist_free(props);
5232eda14cbcSMatt Macy 				return (1);
5233eda14cbcSMatt Macy 			}
5234eda14cbcSMatt Macy 			err = zfs_destroy(zhp, B_FALSE);
5235eda14cbcSMatt Macy 			zfs_close(zhp);
5236eda14cbcSMatt Macy 		} else {
5237eda14cbcSMatt Macy 			zfs_handle_t *zhp = zfs_open(g_zfs,
5238eda14cbcSMatt Macy 			    argv[0], ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
5239eda14cbcSMatt Macy 			if (zhp == NULL)
5240eda14cbcSMatt Macy 				usage(B_FALSE);
5241eda14cbcSMatt Macy 			if (!zfs_prop_get_int(zhp, ZFS_PROP_INCONSISTENT) ||
5242eda14cbcSMatt Macy 			    zfs_prop_get(zhp, ZFS_PROP_RECEIVE_RESUME_TOKEN,
5243eda14cbcSMatt Macy 			    NULL, 0, NULL, NULL, 0, B_TRUE) == -1) {
5244eda14cbcSMatt Macy 				(void) fprintf(stderr,
5245eda14cbcSMatt Macy 				    gettext("'%s' does not have any "
5246eda14cbcSMatt Macy 				    "resumable receive state to abort\n"),
5247eda14cbcSMatt Macy 				    argv[0]);
5248eda14cbcSMatt Macy 				nvlist_free(props);
5249eda14cbcSMatt Macy 				zfs_close(zhp);
5250eda14cbcSMatt Macy 				return (1);
5251eda14cbcSMatt Macy 			}
5252eda14cbcSMatt Macy 			err = zfs_destroy(zhp, B_FALSE);
5253eda14cbcSMatt Macy 			zfs_close(zhp);
5254eda14cbcSMatt Macy 		}
5255eda14cbcSMatt Macy 		nvlist_free(props);
5256eda14cbcSMatt Macy 		return (err != 0);
5257eda14cbcSMatt Macy 	}
5258eda14cbcSMatt Macy 
5259eda14cbcSMatt Macy 	if (isatty(STDIN_FILENO)) {
5260eda14cbcSMatt Macy 		(void) fprintf(stderr,
5261eda14cbcSMatt Macy 		    gettext("Error: Backup stream can not be read "
5262eda14cbcSMatt Macy 		    "from a terminal.\n"
5263eda14cbcSMatt Macy 		    "You must redirect standard input.\n"));
5264eda14cbcSMatt Macy 		nvlist_free(props);
5265eda14cbcSMatt Macy 		return (1);
5266eda14cbcSMatt Macy 	}
5267eda14cbcSMatt Macy 	err = zfs_receive(g_zfs, argv[0], props, &flags, STDIN_FILENO, NULL);
5268eda14cbcSMatt Macy 	nvlist_free(props);
5269eda14cbcSMatt Macy 
5270eda14cbcSMatt Macy 	return (err != 0);
5271eda14cbcSMatt Macy }
5272eda14cbcSMatt Macy 
5273eda14cbcSMatt Macy /*
5274eda14cbcSMatt Macy  * allow/unallow stuff
5275eda14cbcSMatt Macy  */
5276eda14cbcSMatt Macy /* copied from zfs/sys/dsl_deleg.h */
5277eda14cbcSMatt Macy #define	ZFS_DELEG_PERM_CREATE		"create"
5278eda14cbcSMatt Macy #define	ZFS_DELEG_PERM_DESTROY		"destroy"
5279eda14cbcSMatt Macy #define	ZFS_DELEG_PERM_SNAPSHOT		"snapshot"
5280eda14cbcSMatt Macy #define	ZFS_DELEG_PERM_ROLLBACK		"rollback"
5281eda14cbcSMatt Macy #define	ZFS_DELEG_PERM_CLONE		"clone"
5282eda14cbcSMatt Macy #define	ZFS_DELEG_PERM_PROMOTE		"promote"
5283eda14cbcSMatt Macy #define	ZFS_DELEG_PERM_RENAME		"rename"
5284eda14cbcSMatt Macy #define	ZFS_DELEG_PERM_MOUNT		"mount"
5285eda14cbcSMatt Macy #define	ZFS_DELEG_PERM_SHARE		"share"
5286eda14cbcSMatt Macy #define	ZFS_DELEG_PERM_SEND		"send"
5287eda14cbcSMatt Macy #define	ZFS_DELEG_PERM_RECEIVE		"receive"
5288eda14cbcSMatt Macy #define	ZFS_DELEG_PERM_ALLOW		"allow"
5289eda14cbcSMatt Macy #define	ZFS_DELEG_PERM_USERPROP		"userprop"
5290eda14cbcSMatt Macy #define	ZFS_DELEG_PERM_VSCAN		"vscan" /* ??? */
5291eda14cbcSMatt Macy #define	ZFS_DELEG_PERM_USERQUOTA	"userquota"
5292eda14cbcSMatt Macy #define	ZFS_DELEG_PERM_GROUPQUOTA	"groupquota"
5293eda14cbcSMatt Macy #define	ZFS_DELEG_PERM_USERUSED		"userused"
5294eda14cbcSMatt Macy #define	ZFS_DELEG_PERM_GROUPUSED	"groupused"
5295eda14cbcSMatt Macy #define	ZFS_DELEG_PERM_USEROBJQUOTA	"userobjquota"
5296eda14cbcSMatt Macy #define	ZFS_DELEG_PERM_GROUPOBJQUOTA	"groupobjquota"
5297eda14cbcSMatt Macy #define	ZFS_DELEG_PERM_USEROBJUSED	"userobjused"
5298eda14cbcSMatt Macy #define	ZFS_DELEG_PERM_GROUPOBJUSED	"groupobjused"
5299eda14cbcSMatt Macy 
5300eda14cbcSMatt Macy #define	ZFS_DELEG_PERM_HOLD		"hold"
5301eda14cbcSMatt Macy #define	ZFS_DELEG_PERM_RELEASE		"release"
5302eda14cbcSMatt Macy #define	ZFS_DELEG_PERM_DIFF		"diff"
5303eda14cbcSMatt Macy #define	ZFS_DELEG_PERM_BOOKMARK		"bookmark"
5304eda14cbcSMatt Macy #define	ZFS_DELEG_PERM_LOAD_KEY		"load-key"
5305eda14cbcSMatt Macy #define	ZFS_DELEG_PERM_CHANGE_KEY	"change-key"
5306eda14cbcSMatt Macy 
5307eda14cbcSMatt Macy #define	ZFS_DELEG_PERM_PROJECTUSED	"projectused"
5308eda14cbcSMatt Macy #define	ZFS_DELEG_PERM_PROJECTQUOTA	"projectquota"
5309eda14cbcSMatt Macy #define	ZFS_DELEG_PERM_PROJECTOBJUSED	"projectobjused"
5310eda14cbcSMatt Macy #define	ZFS_DELEG_PERM_PROJECTOBJQUOTA	"projectobjquota"
5311eda14cbcSMatt Macy 
5312eda14cbcSMatt Macy #define	ZFS_NUM_DELEG_NOTES ZFS_DELEG_NOTE_NONE
5313eda14cbcSMatt Macy 
5314eda14cbcSMatt Macy static zfs_deleg_perm_tab_t zfs_deleg_perm_tbl[] = {
5315eda14cbcSMatt Macy 	{ ZFS_DELEG_PERM_ALLOW, ZFS_DELEG_NOTE_ALLOW },
5316eda14cbcSMatt Macy 	{ ZFS_DELEG_PERM_CLONE, ZFS_DELEG_NOTE_CLONE },
5317eda14cbcSMatt Macy 	{ ZFS_DELEG_PERM_CREATE, ZFS_DELEG_NOTE_CREATE },
5318eda14cbcSMatt Macy 	{ ZFS_DELEG_PERM_DESTROY, ZFS_DELEG_NOTE_DESTROY },
5319eda14cbcSMatt Macy 	{ ZFS_DELEG_PERM_DIFF, ZFS_DELEG_NOTE_DIFF},
5320eda14cbcSMatt Macy 	{ ZFS_DELEG_PERM_HOLD, ZFS_DELEG_NOTE_HOLD },
5321eda14cbcSMatt Macy 	{ ZFS_DELEG_PERM_MOUNT, ZFS_DELEG_NOTE_MOUNT },
5322eda14cbcSMatt Macy 	{ ZFS_DELEG_PERM_PROMOTE, ZFS_DELEG_NOTE_PROMOTE },
5323eda14cbcSMatt Macy 	{ ZFS_DELEG_PERM_RECEIVE, ZFS_DELEG_NOTE_RECEIVE },
5324eda14cbcSMatt Macy 	{ ZFS_DELEG_PERM_RELEASE, ZFS_DELEG_NOTE_RELEASE },
5325eda14cbcSMatt Macy 	{ ZFS_DELEG_PERM_RENAME, ZFS_DELEG_NOTE_RENAME },
5326eda14cbcSMatt Macy 	{ ZFS_DELEG_PERM_ROLLBACK, ZFS_DELEG_NOTE_ROLLBACK },
5327eda14cbcSMatt Macy 	{ ZFS_DELEG_PERM_SEND, ZFS_DELEG_NOTE_SEND },
5328eda14cbcSMatt Macy 	{ ZFS_DELEG_PERM_SHARE, ZFS_DELEG_NOTE_SHARE },
5329eda14cbcSMatt Macy 	{ ZFS_DELEG_PERM_SNAPSHOT, ZFS_DELEG_NOTE_SNAPSHOT },
5330eda14cbcSMatt Macy 	{ ZFS_DELEG_PERM_BOOKMARK, ZFS_DELEG_NOTE_BOOKMARK },
5331eda14cbcSMatt Macy 	{ ZFS_DELEG_PERM_LOAD_KEY, ZFS_DELEG_NOTE_LOAD_KEY },
5332eda14cbcSMatt Macy 	{ ZFS_DELEG_PERM_CHANGE_KEY, ZFS_DELEG_NOTE_CHANGE_KEY },
5333eda14cbcSMatt Macy 
5334eda14cbcSMatt Macy 	{ ZFS_DELEG_PERM_GROUPQUOTA, ZFS_DELEG_NOTE_GROUPQUOTA },
5335eda14cbcSMatt Macy 	{ ZFS_DELEG_PERM_GROUPUSED, ZFS_DELEG_NOTE_GROUPUSED },
5336eda14cbcSMatt Macy 	{ ZFS_DELEG_PERM_USERPROP, ZFS_DELEG_NOTE_USERPROP },
5337eda14cbcSMatt Macy 	{ ZFS_DELEG_PERM_USERQUOTA, ZFS_DELEG_NOTE_USERQUOTA },
5338eda14cbcSMatt Macy 	{ ZFS_DELEG_PERM_USERUSED, ZFS_DELEG_NOTE_USERUSED },
5339eda14cbcSMatt Macy 	{ ZFS_DELEG_PERM_USEROBJQUOTA, ZFS_DELEG_NOTE_USEROBJQUOTA },
5340eda14cbcSMatt Macy 	{ ZFS_DELEG_PERM_USEROBJUSED, ZFS_DELEG_NOTE_USEROBJUSED },
5341eda14cbcSMatt Macy 	{ ZFS_DELEG_PERM_GROUPOBJQUOTA, ZFS_DELEG_NOTE_GROUPOBJQUOTA },
5342eda14cbcSMatt Macy 	{ ZFS_DELEG_PERM_GROUPOBJUSED, ZFS_DELEG_NOTE_GROUPOBJUSED },
5343eda14cbcSMatt Macy 	{ ZFS_DELEG_PERM_PROJECTUSED, ZFS_DELEG_NOTE_PROJECTUSED },
5344eda14cbcSMatt Macy 	{ ZFS_DELEG_PERM_PROJECTQUOTA, ZFS_DELEG_NOTE_PROJECTQUOTA },
5345eda14cbcSMatt Macy 	{ ZFS_DELEG_PERM_PROJECTOBJUSED, ZFS_DELEG_NOTE_PROJECTOBJUSED },
5346eda14cbcSMatt Macy 	{ ZFS_DELEG_PERM_PROJECTOBJQUOTA, ZFS_DELEG_NOTE_PROJECTOBJQUOTA },
5347eda14cbcSMatt Macy 	{ NULL, ZFS_DELEG_NOTE_NONE }
5348eda14cbcSMatt Macy };
5349eda14cbcSMatt Macy 
5350eda14cbcSMatt Macy /* permission structure */
5351eda14cbcSMatt Macy typedef struct deleg_perm {
5352eda14cbcSMatt Macy 	zfs_deleg_who_type_t	dp_who_type;
5353eda14cbcSMatt Macy 	const char		*dp_name;
5354eda14cbcSMatt Macy 	boolean_t		dp_local;
5355eda14cbcSMatt Macy 	boolean_t		dp_descend;
5356eda14cbcSMatt Macy } deleg_perm_t;
5357eda14cbcSMatt Macy 
5358eda14cbcSMatt Macy /* */
5359eda14cbcSMatt Macy typedef struct deleg_perm_node {
5360eda14cbcSMatt Macy 	deleg_perm_t		dpn_perm;
5361eda14cbcSMatt Macy 
5362eda14cbcSMatt Macy 	uu_avl_node_t		dpn_avl_node;
5363eda14cbcSMatt Macy } deleg_perm_node_t;
5364eda14cbcSMatt Macy 
5365eda14cbcSMatt Macy typedef struct fs_perm fs_perm_t;
5366eda14cbcSMatt Macy 
5367eda14cbcSMatt Macy /* permissions set */
5368eda14cbcSMatt Macy typedef struct who_perm {
5369eda14cbcSMatt Macy 	zfs_deleg_who_type_t	who_type;
5370eda14cbcSMatt Macy 	const char		*who_name;		/* id */
5371eda14cbcSMatt Macy 	char			who_ug_name[256];	/* user/group name */
5372eda14cbcSMatt Macy 	fs_perm_t		*who_fsperm;		/* uplink */
5373eda14cbcSMatt Macy 
5374eda14cbcSMatt Macy 	uu_avl_t		*who_deleg_perm_avl;	/* permissions */
5375eda14cbcSMatt Macy } who_perm_t;
5376eda14cbcSMatt Macy 
5377eda14cbcSMatt Macy /* */
5378eda14cbcSMatt Macy typedef struct who_perm_node {
5379eda14cbcSMatt Macy 	who_perm_t	who_perm;
5380eda14cbcSMatt Macy 	uu_avl_node_t	who_avl_node;
5381eda14cbcSMatt Macy } who_perm_node_t;
5382eda14cbcSMatt Macy 
5383eda14cbcSMatt Macy typedef struct fs_perm_set fs_perm_set_t;
5384eda14cbcSMatt Macy /* fs permissions */
5385eda14cbcSMatt Macy struct fs_perm {
5386eda14cbcSMatt Macy 	const char		*fsp_name;
5387eda14cbcSMatt Macy 
5388eda14cbcSMatt Macy 	uu_avl_t		*fsp_sc_avl;	/* sets,create */
5389eda14cbcSMatt Macy 	uu_avl_t		*fsp_uge_avl;	/* user,group,everyone */
5390eda14cbcSMatt Macy 
5391eda14cbcSMatt Macy 	fs_perm_set_t		*fsp_set;	/* uplink */
5392eda14cbcSMatt Macy };
5393eda14cbcSMatt Macy 
5394eda14cbcSMatt Macy /* */
5395eda14cbcSMatt Macy typedef struct fs_perm_node {
5396eda14cbcSMatt Macy 	fs_perm_t	fspn_fsperm;
5397eda14cbcSMatt Macy 	uu_avl_t	*fspn_avl;
5398eda14cbcSMatt Macy 
5399eda14cbcSMatt Macy 	uu_list_node_t	fspn_list_node;
5400eda14cbcSMatt Macy } fs_perm_node_t;
5401eda14cbcSMatt Macy 
5402eda14cbcSMatt Macy /* top level structure */
5403eda14cbcSMatt Macy struct fs_perm_set {
5404eda14cbcSMatt Macy 	uu_list_pool_t	*fsps_list_pool;
5405eda14cbcSMatt Macy 	uu_list_t	*fsps_list; /* list of fs_perms */
5406eda14cbcSMatt Macy 
5407eda14cbcSMatt Macy 	uu_avl_pool_t	*fsps_named_set_avl_pool;
5408eda14cbcSMatt Macy 	uu_avl_pool_t	*fsps_who_perm_avl_pool;
5409eda14cbcSMatt Macy 	uu_avl_pool_t	*fsps_deleg_perm_avl_pool;
5410eda14cbcSMatt Macy };
5411eda14cbcSMatt Macy 
5412eda14cbcSMatt Macy static inline const char *
5413eda14cbcSMatt Macy deleg_perm_type(zfs_deleg_note_t note)
5414eda14cbcSMatt Macy {
5415eda14cbcSMatt Macy 	/* subcommands */
5416eda14cbcSMatt Macy 	switch (note) {
5417eda14cbcSMatt Macy 		/* SUBCOMMANDS */
5418eda14cbcSMatt Macy 		/* OTHER */
5419eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_GROUPQUOTA:
5420eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_GROUPUSED:
5421eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_USERPROP:
5422eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_USERQUOTA:
5423eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_USERUSED:
5424eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_USEROBJQUOTA:
5425eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_USEROBJUSED:
5426eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_GROUPOBJQUOTA:
5427eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_GROUPOBJUSED:
5428eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_PROJECTUSED:
5429eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_PROJECTQUOTA:
5430eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_PROJECTOBJUSED:
5431eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_PROJECTOBJQUOTA:
5432eda14cbcSMatt Macy 		/* other */
5433eda14cbcSMatt Macy 		return (gettext("other"));
5434eda14cbcSMatt Macy 	default:
5435eda14cbcSMatt Macy 		return (gettext("subcommand"));
5436eda14cbcSMatt Macy 	}
5437eda14cbcSMatt Macy }
5438eda14cbcSMatt Macy 
5439eda14cbcSMatt Macy static int
5440eda14cbcSMatt Macy who_type2weight(zfs_deleg_who_type_t who_type)
5441eda14cbcSMatt Macy {
5442eda14cbcSMatt Macy 	int res;
5443eda14cbcSMatt Macy 	switch (who_type) {
5444eda14cbcSMatt Macy 		case ZFS_DELEG_NAMED_SET_SETS:
5445eda14cbcSMatt Macy 		case ZFS_DELEG_NAMED_SET:
5446eda14cbcSMatt Macy 			res = 0;
5447eda14cbcSMatt Macy 			break;
5448eda14cbcSMatt Macy 		case ZFS_DELEG_CREATE_SETS:
5449eda14cbcSMatt Macy 		case ZFS_DELEG_CREATE:
5450eda14cbcSMatt Macy 			res = 1;
5451eda14cbcSMatt Macy 			break;
5452eda14cbcSMatt Macy 		case ZFS_DELEG_USER_SETS:
5453eda14cbcSMatt Macy 		case ZFS_DELEG_USER:
5454eda14cbcSMatt Macy 			res = 2;
5455eda14cbcSMatt Macy 			break;
5456eda14cbcSMatt Macy 		case ZFS_DELEG_GROUP_SETS:
5457eda14cbcSMatt Macy 		case ZFS_DELEG_GROUP:
5458eda14cbcSMatt Macy 			res = 3;
5459eda14cbcSMatt Macy 			break;
5460eda14cbcSMatt Macy 		case ZFS_DELEG_EVERYONE_SETS:
5461eda14cbcSMatt Macy 		case ZFS_DELEG_EVERYONE:
5462eda14cbcSMatt Macy 			res = 4;
5463eda14cbcSMatt Macy 			break;
5464eda14cbcSMatt Macy 		default:
5465eda14cbcSMatt Macy 			res = -1;
5466eda14cbcSMatt Macy 	}
5467eda14cbcSMatt Macy 
5468eda14cbcSMatt Macy 	return (res);
5469eda14cbcSMatt Macy }
5470eda14cbcSMatt Macy 
5471eda14cbcSMatt Macy static int
5472eda14cbcSMatt Macy who_perm_compare(const void *larg, const void *rarg, void *unused)
5473eda14cbcSMatt Macy {
5474681ce946SMartin Matuska 	(void) unused;
5475eda14cbcSMatt Macy 	const who_perm_node_t *l = larg;
5476eda14cbcSMatt Macy 	const who_perm_node_t *r = rarg;
5477eda14cbcSMatt Macy 	zfs_deleg_who_type_t ltype = l->who_perm.who_type;
5478eda14cbcSMatt Macy 	zfs_deleg_who_type_t rtype = r->who_perm.who_type;
5479eda14cbcSMatt Macy 	int lweight = who_type2weight(ltype);
5480eda14cbcSMatt Macy 	int rweight = who_type2weight(rtype);
5481eda14cbcSMatt Macy 	int res = lweight - rweight;
5482eda14cbcSMatt Macy 	if (res == 0)
5483eda14cbcSMatt Macy 		res = strncmp(l->who_perm.who_name, r->who_perm.who_name,
5484eda14cbcSMatt Macy 		    ZFS_MAX_DELEG_NAME-1);
5485eda14cbcSMatt Macy 
5486eda14cbcSMatt Macy 	if (res == 0)
5487eda14cbcSMatt Macy 		return (0);
5488eda14cbcSMatt Macy 	if (res > 0)
5489eda14cbcSMatt Macy 		return (1);
5490eda14cbcSMatt Macy 	else
5491eda14cbcSMatt Macy 		return (-1);
5492eda14cbcSMatt Macy }
5493eda14cbcSMatt Macy 
5494eda14cbcSMatt Macy static int
5495eda14cbcSMatt Macy deleg_perm_compare(const void *larg, const void *rarg, void *unused)
5496eda14cbcSMatt Macy {
5497681ce946SMartin Matuska 	(void) unused;
5498eda14cbcSMatt Macy 	const deleg_perm_node_t *l = larg;
5499eda14cbcSMatt Macy 	const deleg_perm_node_t *r = rarg;
5500eda14cbcSMatt Macy 	int res =  strncmp(l->dpn_perm.dp_name, r->dpn_perm.dp_name,
5501eda14cbcSMatt Macy 	    ZFS_MAX_DELEG_NAME-1);
5502eda14cbcSMatt Macy 
5503eda14cbcSMatt Macy 	if (res == 0)
5504eda14cbcSMatt Macy 		return (0);
5505eda14cbcSMatt Macy 
5506eda14cbcSMatt Macy 	if (res > 0)
5507eda14cbcSMatt Macy 		return (1);
5508eda14cbcSMatt Macy 	else
5509eda14cbcSMatt Macy 		return (-1);
5510eda14cbcSMatt Macy }
5511eda14cbcSMatt Macy 
5512eda14cbcSMatt Macy static inline void
5513eda14cbcSMatt Macy fs_perm_set_init(fs_perm_set_t *fspset)
5514eda14cbcSMatt Macy {
5515da5137abSMartin Matuska 	memset(fspset, 0, sizeof (fs_perm_set_t));
5516eda14cbcSMatt Macy 
5517eda14cbcSMatt Macy 	if ((fspset->fsps_list_pool = uu_list_pool_create("fsps_list_pool",
5518eda14cbcSMatt Macy 	    sizeof (fs_perm_node_t), offsetof(fs_perm_node_t, fspn_list_node),
5519eda14cbcSMatt Macy 	    NULL, UU_DEFAULT)) == NULL)
5520eda14cbcSMatt Macy 		nomem();
5521eda14cbcSMatt Macy 	if ((fspset->fsps_list = uu_list_create(fspset->fsps_list_pool, NULL,
5522eda14cbcSMatt Macy 	    UU_DEFAULT)) == NULL)
5523eda14cbcSMatt Macy 		nomem();
5524eda14cbcSMatt Macy 
5525eda14cbcSMatt Macy 	if ((fspset->fsps_named_set_avl_pool = uu_avl_pool_create(
5526eda14cbcSMatt Macy 	    "named_set_avl_pool", sizeof (who_perm_node_t), offsetof(
5527eda14cbcSMatt Macy 	    who_perm_node_t, who_avl_node), who_perm_compare,
5528eda14cbcSMatt Macy 	    UU_DEFAULT)) == NULL)
5529eda14cbcSMatt Macy 		nomem();
5530eda14cbcSMatt Macy 
5531eda14cbcSMatt Macy 	if ((fspset->fsps_who_perm_avl_pool = uu_avl_pool_create(
5532eda14cbcSMatt Macy 	    "who_perm_avl_pool", sizeof (who_perm_node_t), offsetof(
5533eda14cbcSMatt Macy 	    who_perm_node_t, who_avl_node), who_perm_compare,
5534eda14cbcSMatt Macy 	    UU_DEFAULT)) == NULL)
5535eda14cbcSMatt Macy 		nomem();
5536eda14cbcSMatt Macy 
5537eda14cbcSMatt Macy 	if ((fspset->fsps_deleg_perm_avl_pool = uu_avl_pool_create(
5538eda14cbcSMatt Macy 	    "deleg_perm_avl_pool", sizeof (deleg_perm_node_t), offsetof(
5539eda14cbcSMatt Macy 	    deleg_perm_node_t, dpn_avl_node), deleg_perm_compare, UU_DEFAULT))
5540eda14cbcSMatt Macy 	    == NULL)
5541eda14cbcSMatt Macy 		nomem();
5542eda14cbcSMatt Macy }
5543eda14cbcSMatt Macy 
5544eda14cbcSMatt Macy static inline void fs_perm_fini(fs_perm_t *);
5545eda14cbcSMatt Macy static inline void who_perm_fini(who_perm_t *);
5546eda14cbcSMatt Macy 
5547eda14cbcSMatt Macy static inline void
5548eda14cbcSMatt Macy fs_perm_set_fini(fs_perm_set_t *fspset)
5549eda14cbcSMatt Macy {
5550eda14cbcSMatt Macy 	fs_perm_node_t *node = uu_list_first(fspset->fsps_list);
5551eda14cbcSMatt Macy 
5552eda14cbcSMatt Macy 	while (node != NULL) {
5553eda14cbcSMatt Macy 		fs_perm_node_t *next_node =
5554eda14cbcSMatt Macy 		    uu_list_next(fspset->fsps_list, node);
5555eda14cbcSMatt Macy 		fs_perm_t *fsperm = &node->fspn_fsperm;
5556eda14cbcSMatt Macy 		fs_perm_fini(fsperm);
5557eda14cbcSMatt Macy 		uu_list_remove(fspset->fsps_list, node);
5558eda14cbcSMatt Macy 		free(node);
5559eda14cbcSMatt Macy 		node = next_node;
5560eda14cbcSMatt Macy 	}
5561eda14cbcSMatt Macy 
5562eda14cbcSMatt Macy 	uu_avl_pool_destroy(fspset->fsps_named_set_avl_pool);
5563eda14cbcSMatt Macy 	uu_avl_pool_destroy(fspset->fsps_who_perm_avl_pool);
5564eda14cbcSMatt Macy 	uu_avl_pool_destroy(fspset->fsps_deleg_perm_avl_pool);
5565eda14cbcSMatt Macy }
5566eda14cbcSMatt Macy 
5567eda14cbcSMatt Macy static inline void
5568eda14cbcSMatt Macy deleg_perm_init(deleg_perm_t *deleg_perm, zfs_deleg_who_type_t type,
5569eda14cbcSMatt Macy     const char *name)
5570eda14cbcSMatt Macy {
5571eda14cbcSMatt Macy 	deleg_perm->dp_who_type = type;
5572eda14cbcSMatt Macy 	deleg_perm->dp_name = name;
5573eda14cbcSMatt Macy }
5574eda14cbcSMatt Macy 
5575eda14cbcSMatt Macy static inline void
5576eda14cbcSMatt Macy who_perm_init(who_perm_t *who_perm, fs_perm_t *fsperm,
5577eda14cbcSMatt Macy     zfs_deleg_who_type_t type, const char *name)
5578eda14cbcSMatt Macy {
5579eda14cbcSMatt Macy 	uu_avl_pool_t	*pool;
5580eda14cbcSMatt Macy 	pool = fsperm->fsp_set->fsps_deleg_perm_avl_pool;
5581eda14cbcSMatt Macy 
5582da5137abSMartin Matuska 	memset(who_perm, 0, sizeof (who_perm_t));
5583eda14cbcSMatt Macy 
5584eda14cbcSMatt Macy 	if ((who_perm->who_deleg_perm_avl = uu_avl_create(pool, NULL,
5585eda14cbcSMatt Macy 	    UU_DEFAULT)) == NULL)
5586eda14cbcSMatt Macy 		nomem();
5587eda14cbcSMatt Macy 
5588eda14cbcSMatt Macy 	who_perm->who_type = type;
5589eda14cbcSMatt Macy 	who_perm->who_name = name;
5590eda14cbcSMatt Macy 	who_perm->who_fsperm = fsperm;
5591eda14cbcSMatt Macy }
5592eda14cbcSMatt Macy 
5593eda14cbcSMatt Macy static inline void
5594eda14cbcSMatt Macy who_perm_fini(who_perm_t *who_perm)
5595eda14cbcSMatt Macy {
5596eda14cbcSMatt Macy 	deleg_perm_node_t *node = uu_avl_first(who_perm->who_deleg_perm_avl);
5597eda14cbcSMatt Macy 
5598eda14cbcSMatt Macy 	while (node != NULL) {
5599eda14cbcSMatt Macy 		deleg_perm_node_t *next_node =
5600eda14cbcSMatt Macy 		    uu_avl_next(who_perm->who_deleg_perm_avl, node);
5601eda14cbcSMatt Macy 
5602eda14cbcSMatt Macy 		uu_avl_remove(who_perm->who_deleg_perm_avl, node);
5603eda14cbcSMatt Macy 		free(node);
5604eda14cbcSMatt Macy 		node = next_node;
5605eda14cbcSMatt Macy 	}
5606eda14cbcSMatt Macy 
5607eda14cbcSMatt Macy 	uu_avl_destroy(who_perm->who_deleg_perm_avl);
5608eda14cbcSMatt Macy }
5609eda14cbcSMatt Macy 
5610eda14cbcSMatt Macy static inline void
5611eda14cbcSMatt Macy fs_perm_init(fs_perm_t *fsperm, fs_perm_set_t *fspset, const char *fsname)
5612eda14cbcSMatt Macy {
5613eda14cbcSMatt Macy 	uu_avl_pool_t	*nset_pool = fspset->fsps_named_set_avl_pool;
5614eda14cbcSMatt Macy 	uu_avl_pool_t	*who_pool = fspset->fsps_who_perm_avl_pool;
5615eda14cbcSMatt Macy 
5616da5137abSMartin Matuska 	memset(fsperm, 0, sizeof (fs_perm_t));
5617eda14cbcSMatt Macy 
5618eda14cbcSMatt Macy 	if ((fsperm->fsp_sc_avl = uu_avl_create(nset_pool, NULL, UU_DEFAULT))
5619eda14cbcSMatt Macy 	    == NULL)
5620eda14cbcSMatt Macy 		nomem();
5621eda14cbcSMatt Macy 
5622eda14cbcSMatt Macy 	if ((fsperm->fsp_uge_avl = uu_avl_create(who_pool, NULL, UU_DEFAULT))
5623eda14cbcSMatt Macy 	    == NULL)
5624eda14cbcSMatt Macy 		nomem();
5625eda14cbcSMatt Macy 
5626eda14cbcSMatt Macy 	fsperm->fsp_set = fspset;
5627eda14cbcSMatt Macy 	fsperm->fsp_name = fsname;
5628eda14cbcSMatt Macy }
5629eda14cbcSMatt Macy 
5630eda14cbcSMatt Macy static inline void
5631eda14cbcSMatt Macy fs_perm_fini(fs_perm_t *fsperm)
5632eda14cbcSMatt Macy {
5633eda14cbcSMatt Macy 	who_perm_node_t *node = uu_avl_first(fsperm->fsp_sc_avl);
5634eda14cbcSMatt Macy 	while (node != NULL) {
5635eda14cbcSMatt Macy 		who_perm_node_t *next_node = uu_avl_next(fsperm->fsp_sc_avl,
5636eda14cbcSMatt Macy 		    node);
5637eda14cbcSMatt Macy 		who_perm_t *who_perm = &node->who_perm;
5638eda14cbcSMatt Macy 		who_perm_fini(who_perm);
5639eda14cbcSMatt Macy 		uu_avl_remove(fsperm->fsp_sc_avl, node);
5640eda14cbcSMatt Macy 		free(node);
5641eda14cbcSMatt Macy 		node = next_node;
5642eda14cbcSMatt Macy 	}
5643eda14cbcSMatt Macy 
5644eda14cbcSMatt Macy 	node = uu_avl_first(fsperm->fsp_uge_avl);
5645eda14cbcSMatt Macy 	while (node != NULL) {
5646eda14cbcSMatt Macy 		who_perm_node_t *next_node = uu_avl_next(fsperm->fsp_uge_avl,
5647eda14cbcSMatt Macy 		    node);
5648eda14cbcSMatt Macy 		who_perm_t *who_perm = &node->who_perm;
5649eda14cbcSMatt Macy 		who_perm_fini(who_perm);
5650eda14cbcSMatt Macy 		uu_avl_remove(fsperm->fsp_uge_avl, node);
5651eda14cbcSMatt Macy 		free(node);
5652eda14cbcSMatt Macy 		node = next_node;
5653eda14cbcSMatt Macy 	}
5654eda14cbcSMatt Macy 
5655eda14cbcSMatt Macy 	uu_avl_destroy(fsperm->fsp_sc_avl);
5656eda14cbcSMatt Macy 	uu_avl_destroy(fsperm->fsp_uge_avl);
5657eda14cbcSMatt Macy }
5658eda14cbcSMatt Macy 
5659eda14cbcSMatt Macy static void
5660eda14cbcSMatt Macy set_deleg_perm_node(uu_avl_t *avl, deleg_perm_node_t *node,
5661eda14cbcSMatt Macy     zfs_deleg_who_type_t who_type, const char *name, char locality)
5662eda14cbcSMatt Macy {
5663eda14cbcSMatt Macy 	uu_avl_index_t idx = 0;
5664eda14cbcSMatt Macy 
5665eda14cbcSMatt Macy 	deleg_perm_node_t *found_node = NULL;
5666eda14cbcSMatt Macy 	deleg_perm_t	*deleg_perm = &node->dpn_perm;
5667eda14cbcSMatt Macy 
5668eda14cbcSMatt Macy 	deleg_perm_init(deleg_perm, who_type, name);
5669eda14cbcSMatt Macy 
5670eda14cbcSMatt Macy 	if ((found_node = uu_avl_find(avl, node, NULL, &idx))
5671eda14cbcSMatt Macy 	    == NULL)
5672eda14cbcSMatt Macy 		uu_avl_insert(avl, node, idx);
5673eda14cbcSMatt Macy 	else {
5674eda14cbcSMatt Macy 		node = found_node;
5675eda14cbcSMatt Macy 		deleg_perm = &node->dpn_perm;
5676eda14cbcSMatt Macy 	}
5677eda14cbcSMatt Macy 
5678eda14cbcSMatt Macy 
5679eda14cbcSMatt Macy 	switch (locality) {
5680eda14cbcSMatt Macy 	case ZFS_DELEG_LOCAL:
5681eda14cbcSMatt Macy 		deleg_perm->dp_local = B_TRUE;
5682eda14cbcSMatt Macy 		break;
5683eda14cbcSMatt Macy 	case ZFS_DELEG_DESCENDENT:
5684eda14cbcSMatt Macy 		deleg_perm->dp_descend = B_TRUE;
5685eda14cbcSMatt Macy 		break;
5686eda14cbcSMatt Macy 	case ZFS_DELEG_NA:
5687eda14cbcSMatt Macy 		break;
5688eda14cbcSMatt Macy 	default:
5689eda14cbcSMatt Macy 		assert(B_FALSE); /* invalid locality */
5690eda14cbcSMatt Macy 	}
5691eda14cbcSMatt Macy }
5692eda14cbcSMatt Macy 
5693eda14cbcSMatt Macy static inline int
5694eda14cbcSMatt Macy parse_who_perm(who_perm_t *who_perm, nvlist_t *nvl, char locality)
5695eda14cbcSMatt Macy {
5696eda14cbcSMatt Macy 	nvpair_t *nvp = NULL;
5697eda14cbcSMatt Macy 	fs_perm_set_t *fspset = who_perm->who_fsperm->fsp_set;
5698eda14cbcSMatt Macy 	uu_avl_t *avl = who_perm->who_deleg_perm_avl;
5699eda14cbcSMatt Macy 	zfs_deleg_who_type_t who_type = who_perm->who_type;
5700eda14cbcSMatt Macy 
5701eda14cbcSMatt Macy 	while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
5702eda14cbcSMatt Macy 		const char *name = nvpair_name(nvp);
5703eda14cbcSMatt Macy 		data_type_t type = nvpair_type(nvp);
5704eda14cbcSMatt Macy 		uu_avl_pool_t *avl_pool = fspset->fsps_deleg_perm_avl_pool;
5705eda14cbcSMatt Macy 		deleg_perm_node_t *node =
5706eda14cbcSMatt Macy 		    safe_malloc(sizeof (deleg_perm_node_t));
5707eda14cbcSMatt Macy 
5708eda14cbcSMatt Macy 		VERIFY(type == DATA_TYPE_BOOLEAN);
5709eda14cbcSMatt Macy 
5710eda14cbcSMatt Macy 		uu_avl_node_init(node, &node->dpn_avl_node, avl_pool);
5711eda14cbcSMatt Macy 		set_deleg_perm_node(avl, node, who_type, name, locality);
5712eda14cbcSMatt Macy 	}
5713eda14cbcSMatt Macy 
5714eda14cbcSMatt Macy 	return (0);
5715eda14cbcSMatt Macy }
5716eda14cbcSMatt Macy 
5717eda14cbcSMatt Macy static inline int
5718eda14cbcSMatt Macy parse_fs_perm(fs_perm_t *fsperm, nvlist_t *nvl)
5719eda14cbcSMatt Macy {
5720eda14cbcSMatt Macy 	nvpair_t *nvp = NULL;
5721eda14cbcSMatt Macy 	fs_perm_set_t *fspset = fsperm->fsp_set;
5722eda14cbcSMatt Macy 
5723eda14cbcSMatt Macy 	while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
5724eda14cbcSMatt Macy 		nvlist_t *nvl2 = NULL;
5725eda14cbcSMatt Macy 		const char *name = nvpair_name(nvp);
5726eda14cbcSMatt Macy 		uu_avl_t *avl = NULL;
5727eda14cbcSMatt Macy 		uu_avl_pool_t *avl_pool = NULL;
5728eda14cbcSMatt Macy 		zfs_deleg_who_type_t perm_type = name[0];
5729eda14cbcSMatt Macy 		char perm_locality = name[1];
5730eda14cbcSMatt Macy 		const char *perm_name = name + 3;
5731eda14cbcSMatt Macy 		who_perm_t *who_perm = NULL;
5732eda14cbcSMatt Macy 
5733eda14cbcSMatt Macy 		assert('$' == name[2]);
5734eda14cbcSMatt Macy 
5735eda14cbcSMatt Macy 		if (nvpair_value_nvlist(nvp, &nvl2) != 0)
5736eda14cbcSMatt Macy 			return (-1);
5737eda14cbcSMatt Macy 
5738eda14cbcSMatt Macy 		switch (perm_type) {
5739eda14cbcSMatt Macy 		case ZFS_DELEG_CREATE:
5740eda14cbcSMatt Macy 		case ZFS_DELEG_CREATE_SETS:
5741eda14cbcSMatt Macy 		case ZFS_DELEG_NAMED_SET:
5742eda14cbcSMatt Macy 		case ZFS_DELEG_NAMED_SET_SETS:
5743eda14cbcSMatt Macy 			avl_pool = fspset->fsps_named_set_avl_pool;
5744eda14cbcSMatt Macy 			avl = fsperm->fsp_sc_avl;
5745eda14cbcSMatt Macy 			break;
5746eda14cbcSMatt Macy 		case ZFS_DELEG_USER:
5747eda14cbcSMatt Macy 		case ZFS_DELEG_USER_SETS:
5748eda14cbcSMatt Macy 		case ZFS_DELEG_GROUP:
5749eda14cbcSMatt Macy 		case ZFS_DELEG_GROUP_SETS:
5750eda14cbcSMatt Macy 		case ZFS_DELEG_EVERYONE:
5751eda14cbcSMatt Macy 		case ZFS_DELEG_EVERYONE_SETS:
5752eda14cbcSMatt Macy 			avl_pool = fspset->fsps_who_perm_avl_pool;
5753eda14cbcSMatt Macy 			avl = fsperm->fsp_uge_avl;
5754eda14cbcSMatt Macy 			break;
5755eda14cbcSMatt Macy 
5756eda14cbcSMatt Macy 		default:
5757eda14cbcSMatt Macy 			assert(!"unhandled zfs_deleg_who_type_t");
5758eda14cbcSMatt Macy 		}
5759eda14cbcSMatt Macy 
5760eda14cbcSMatt Macy 		who_perm_node_t *found_node = NULL;
5761eda14cbcSMatt Macy 		who_perm_node_t *node = safe_malloc(
5762eda14cbcSMatt Macy 		    sizeof (who_perm_node_t));
5763eda14cbcSMatt Macy 		who_perm = &node->who_perm;
5764eda14cbcSMatt Macy 		uu_avl_index_t idx = 0;
5765eda14cbcSMatt Macy 
5766eda14cbcSMatt Macy 		uu_avl_node_init(node, &node->who_avl_node, avl_pool);
5767eda14cbcSMatt Macy 		who_perm_init(who_perm, fsperm, perm_type, perm_name);
5768eda14cbcSMatt Macy 
5769eda14cbcSMatt Macy 		if ((found_node = uu_avl_find(avl, node, NULL, &idx))
5770eda14cbcSMatt Macy 		    == NULL) {
5771eda14cbcSMatt Macy 			if (avl == fsperm->fsp_uge_avl) {
5772eda14cbcSMatt Macy 				uid_t rid = 0;
5773eda14cbcSMatt Macy 				struct passwd *p = NULL;
5774eda14cbcSMatt Macy 				struct group *g = NULL;
5775eda14cbcSMatt Macy 				const char *nice_name = NULL;
5776eda14cbcSMatt Macy 
5777eda14cbcSMatt Macy 				switch (perm_type) {
5778eda14cbcSMatt Macy 				case ZFS_DELEG_USER_SETS:
5779eda14cbcSMatt Macy 				case ZFS_DELEG_USER:
5780eda14cbcSMatt Macy 					rid = atoi(perm_name);
5781eda14cbcSMatt Macy 					p = getpwuid(rid);
5782eda14cbcSMatt Macy 					if (p)
5783eda14cbcSMatt Macy 						nice_name = p->pw_name;
5784eda14cbcSMatt Macy 					break;
5785eda14cbcSMatt Macy 				case ZFS_DELEG_GROUP_SETS:
5786eda14cbcSMatt Macy 				case ZFS_DELEG_GROUP:
5787eda14cbcSMatt Macy 					rid = atoi(perm_name);
5788eda14cbcSMatt Macy 					g = getgrgid(rid);
5789eda14cbcSMatt Macy 					if (g)
5790eda14cbcSMatt Macy 						nice_name = g->gr_name;
5791eda14cbcSMatt Macy 					break;
5792eda14cbcSMatt Macy 
5793eda14cbcSMatt Macy 				default:
5794eda14cbcSMatt Macy 					break;
5795eda14cbcSMatt Macy 				}
5796eda14cbcSMatt Macy 
5797eda14cbcSMatt Macy 				if (nice_name != NULL) {
5798eda14cbcSMatt Macy 					(void) strlcpy(
5799eda14cbcSMatt Macy 					    node->who_perm.who_ug_name,
5800eda14cbcSMatt Macy 					    nice_name, 256);
5801eda14cbcSMatt Macy 				} else {
5802eda14cbcSMatt Macy 					/* User or group unknown */
5803eda14cbcSMatt Macy 					(void) snprintf(
5804eda14cbcSMatt Macy 					    node->who_perm.who_ug_name,
5805eda14cbcSMatt Macy 					    sizeof (node->who_perm.who_ug_name),
5806eda14cbcSMatt Macy 					    "(unknown: %d)", rid);
5807eda14cbcSMatt Macy 				}
5808eda14cbcSMatt Macy 			}
5809eda14cbcSMatt Macy 
5810eda14cbcSMatt Macy 			uu_avl_insert(avl, node, idx);
5811eda14cbcSMatt Macy 		} else {
5812eda14cbcSMatt Macy 			node = found_node;
5813eda14cbcSMatt Macy 			who_perm = &node->who_perm;
5814eda14cbcSMatt Macy 		}
5815eda14cbcSMatt Macy 
5816eda14cbcSMatt Macy 		assert(who_perm != NULL);
5817eda14cbcSMatt Macy 		(void) parse_who_perm(who_perm, nvl2, perm_locality);
5818eda14cbcSMatt Macy 	}
5819eda14cbcSMatt Macy 
5820eda14cbcSMatt Macy 	return (0);
5821eda14cbcSMatt Macy }
5822eda14cbcSMatt Macy 
5823eda14cbcSMatt Macy static inline int
5824eda14cbcSMatt Macy parse_fs_perm_set(fs_perm_set_t *fspset, nvlist_t *nvl)
5825eda14cbcSMatt Macy {
5826eda14cbcSMatt Macy 	nvpair_t *nvp = NULL;
5827eda14cbcSMatt Macy 	uu_avl_index_t idx = 0;
5828eda14cbcSMatt Macy 
5829eda14cbcSMatt Macy 	while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
5830eda14cbcSMatt Macy 		nvlist_t *nvl2 = NULL;
5831eda14cbcSMatt Macy 		const char *fsname = nvpair_name(nvp);
5832eda14cbcSMatt Macy 		data_type_t type = nvpair_type(nvp);
5833eda14cbcSMatt Macy 		fs_perm_t *fsperm = NULL;
5834eda14cbcSMatt Macy 		fs_perm_node_t *node = safe_malloc(sizeof (fs_perm_node_t));
5835eda14cbcSMatt Macy 
5836eda14cbcSMatt Macy 		fsperm = &node->fspn_fsperm;
5837eda14cbcSMatt Macy 
5838eda14cbcSMatt Macy 		VERIFY(DATA_TYPE_NVLIST == type);
5839eda14cbcSMatt Macy 
5840eda14cbcSMatt Macy 		uu_list_node_init(node, &node->fspn_list_node,
5841eda14cbcSMatt Macy 		    fspset->fsps_list_pool);
5842eda14cbcSMatt Macy 
5843eda14cbcSMatt Macy 		idx = uu_list_numnodes(fspset->fsps_list);
5844eda14cbcSMatt Macy 		fs_perm_init(fsperm, fspset, fsname);
5845eda14cbcSMatt Macy 
5846eda14cbcSMatt Macy 		if (nvpair_value_nvlist(nvp, &nvl2) != 0)
5847eda14cbcSMatt Macy 			return (-1);
5848eda14cbcSMatt Macy 
5849eda14cbcSMatt Macy 		(void) parse_fs_perm(fsperm, nvl2);
5850eda14cbcSMatt Macy 
5851eda14cbcSMatt Macy 		uu_list_insert(fspset->fsps_list, node, idx);
5852eda14cbcSMatt Macy 	}
5853eda14cbcSMatt Macy 
5854eda14cbcSMatt Macy 	return (0);
5855eda14cbcSMatt Macy }
5856eda14cbcSMatt Macy 
5857eda14cbcSMatt Macy static inline const char *
5858eda14cbcSMatt Macy deleg_perm_comment(zfs_deleg_note_t note)
5859eda14cbcSMatt Macy {
5860eda14cbcSMatt Macy 	const char *str = "";
5861eda14cbcSMatt Macy 
5862eda14cbcSMatt Macy 	/* subcommands */
5863eda14cbcSMatt Macy 	switch (note) {
5864eda14cbcSMatt Macy 		/* SUBCOMMANDS */
5865eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_ALLOW:
5866eda14cbcSMatt Macy 		str = gettext("Must also have the permission that is being"
5867eda14cbcSMatt Macy 		    "\n\t\t\t\tallowed");
5868eda14cbcSMatt Macy 		break;
5869eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_CLONE:
5870eda14cbcSMatt Macy 		str = gettext("Must also have the 'create' ability and 'mount'"
5871eda14cbcSMatt Macy 		    "\n\t\t\t\tability in the origin file system");
5872eda14cbcSMatt Macy 		break;
5873eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_CREATE:
5874eda14cbcSMatt Macy 		str = gettext("Must also have the 'mount' ability");
5875eda14cbcSMatt Macy 		break;
5876eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_DESTROY:
5877eda14cbcSMatt Macy 		str = gettext("Must also have the 'mount' ability");
5878eda14cbcSMatt Macy 		break;
5879eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_DIFF:
5880eda14cbcSMatt Macy 		str = gettext("Allows lookup of paths within a dataset;"
5881eda14cbcSMatt Macy 		    "\n\t\t\t\tgiven an object number. Ordinary users need this"
5882eda14cbcSMatt Macy 		    "\n\t\t\t\tin order to use zfs diff");
5883eda14cbcSMatt Macy 		break;
5884eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_HOLD:
5885eda14cbcSMatt Macy 		str = gettext("Allows adding a user hold to a snapshot");
5886eda14cbcSMatt Macy 		break;
5887eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_MOUNT:
5888eda14cbcSMatt Macy 		str = gettext("Allows mount/umount of ZFS datasets");
5889eda14cbcSMatt Macy 		break;
5890eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_PROMOTE:
5891eda14cbcSMatt Macy 		str = gettext("Must also have the 'mount'\n\t\t\t\tand"
5892eda14cbcSMatt Macy 		    " 'promote' ability in the origin file system");
5893eda14cbcSMatt Macy 		break;
5894eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_RECEIVE:
5895eda14cbcSMatt Macy 		str = gettext("Must also have the 'mount' and 'create'"
5896eda14cbcSMatt Macy 		    " ability");
5897eda14cbcSMatt Macy 		break;
5898eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_RELEASE:
5899eda14cbcSMatt Macy 		str = gettext("Allows releasing a user hold which\n\t\t\t\t"
5900eda14cbcSMatt Macy 		    "might destroy the snapshot");
5901eda14cbcSMatt Macy 		break;
5902eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_RENAME:
5903eda14cbcSMatt Macy 		str = gettext("Must also have the 'mount' and 'create'"
5904eda14cbcSMatt Macy 		    "\n\t\t\t\tability in the new parent");
5905eda14cbcSMatt Macy 		break;
5906eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_ROLLBACK:
5907eda14cbcSMatt Macy 		str = gettext("");
5908eda14cbcSMatt Macy 		break;
5909eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_SEND:
5910eda14cbcSMatt Macy 		str = gettext("");
5911eda14cbcSMatt Macy 		break;
5912eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_SHARE:
5913eda14cbcSMatt Macy 		str = gettext("Allows sharing file systems over NFS or SMB"
5914eda14cbcSMatt Macy 		    "\n\t\t\t\tprotocols");
5915eda14cbcSMatt Macy 		break;
5916eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_SNAPSHOT:
5917eda14cbcSMatt Macy 		str = gettext("");
5918eda14cbcSMatt Macy 		break;
5919eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_LOAD_KEY:
5920eda14cbcSMatt Macy 		str = gettext("Allows loading or unloading an encryption key");
5921eda14cbcSMatt Macy 		break;
5922eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_CHANGE_KEY:
5923eda14cbcSMatt Macy 		str = gettext("Allows changing or adding an encryption key");
5924eda14cbcSMatt Macy 		break;
5925eda14cbcSMatt Macy /*
5926eda14cbcSMatt Macy  *	case ZFS_DELEG_NOTE_VSCAN:
5927eda14cbcSMatt Macy  *		str = gettext("");
5928eda14cbcSMatt Macy  *		break;
5929eda14cbcSMatt Macy  */
5930eda14cbcSMatt Macy 		/* OTHER */
5931eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_GROUPQUOTA:
5932eda14cbcSMatt Macy 		str = gettext("Allows accessing any groupquota@... property");
5933eda14cbcSMatt Macy 		break;
5934eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_GROUPUSED:
5935eda14cbcSMatt Macy 		str = gettext("Allows reading any groupused@... property");
5936eda14cbcSMatt Macy 		break;
5937eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_USERPROP:
5938eda14cbcSMatt Macy 		str = gettext("Allows changing any user property");
5939eda14cbcSMatt Macy 		break;
5940eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_USERQUOTA:
5941eda14cbcSMatt Macy 		str = gettext("Allows accessing any userquota@... property");
5942eda14cbcSMatt Macy 		break;
5943eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_USERUSED:
5944eda14cbcSMatt Macy 		str = gettext("Allows reading any userused@... property");
5945eda14cbcSMatt Macy 		break;
5946eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_USEROBJQUOTA:
5947eda14cbcSMatt Macy 		str = gettext("Allows accessing any userobjquota@... property");
5948eda14cbcSMatt Macy 		break;
5949eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_GROUPOBJQUOTA:
5950eda14cbcSMatt Macy 		str = gettext("Allows accessing any \n\t\t\t\t"
5951eda14cbcSMatt Macy 		    "groupobjquota@... property");
5952eda14cbcSMatt Macy 		break;
5953eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_GROUPOBJUSED:
5954eda14cbcSMatt Macy 		str = gettext("Allows reading any groupobjused@... property");
5955eda14cbcSMatt Macy 		break;
5956eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_USEROBJUSED:
5957eda14cbcSMatt Macy 		str = gettext("Allows reading any userobjused@... property");
5958eda14cbcSMatt Macy 		break;
5959eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_PROJECTQUOTA:
5960eda14cbcSMatt Macy 		str = gettext("Allows accessing any projectquota@... property");
5961eda14cbcSMatt Macy 		break;
5962eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_PROJECTOBJQUOTA:
5963eda14cbcSMatt Macy 		str = gettext("Allows accessing any \n\t\t\t\t"
5964eda14cbcSMatt Macy 		    "projectobjquota@... property");
5965eda14cbcSMatt Macy 		break;
5966eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_PROJECTUSED:
5967eda14cbcSMatt Macy 		str = gettext("Allows reading any projectused@... property");
5968eda14cbcSMatt Macy 		break;
5969eda14cbcSMatt Macy 	case ZFS_DELEG_NOTE_PROJECTOBJUSED:
5970eda14cbcSMatt Macy 		str = gettext("Allows accessing any \n\t\t\t\t"
5971eda14cbcSMatt Macy 		    "projectobjused@... property");
5972eda14cbcSMatt Macy 		break;
5973eda14cbcSMatt Macy 		/* other */
5974eda14cbcSMatt Macy 	default:
5975eda14cbcSMatt Macy 		str = "";
5976eda14cbcSMatt Macy 	}
5977eda14cbcSMatt Macy 
5978eda14cbcSMatt Macy 	return (str);
5979eda14cbcSMatt Macy }
5980eda14cbcSMatt Macy 
5981eda14cbcSMatt Macy struct allow_opts {
5982eda14cbcSMatt Macy 	boolean_t local;
5983eda14cbcSMatt Macy 	boolean_t descend;
5984eda14cbcSMatt Macy 	boolean_t user;
5985eda14cbcSMatt Macy 	boolean_t group;
5986eda14cbcSMatt Macy 	boolean_t everyone;
5987eda14cbcSMatt Macy 	boolean_t create;
5988eda14cbcSMatt Macy 	boolean_t set;
5989eda14cbcSMatt Macy 	boolean_t recursive; /* unallow only */
5990eda14cbcSMatt Macy 	boolean_t prt_usage;
5991eda14cbcSMatt Macy 
5992eda14cbcSMatt Macy 	boolean_t prt_perms;
5993eda14cbcSMatt Macy 	char *who;
5994eda14cbcSMatt Macy 	char *perms;
5995eda14cbcSMatt Macy 	const char *dataset;
5996eda14cbcSMatt Macy };
5997eda14cbcSMatt Macy 
5998eda14cbcSMatt Macy static inline int
5999eda14cbcSMatt Macy prop_cmp(const void *a, const void *b)
6000eda14cbcSMatt Macy {
6001eda14cbcSMatt Macy 	const char *str1 = *(const char **)a;
6002eda14cbcSMatt Macy 	const char *str2 = *(const char **)b;
6003eda14cbcSMatt Macy 	return (strcmp(str1, str2));
6004eda14cbcSMatt Macy }
6005eda14cbcSMatt Macy 
6006eda14cbcSMatt Macy static void
6007eda14cbcSMatt Macy allow_usage(boolean_t un, boolean_t requested, const char *msg)
6008eda14cbcSMatt Macy {
6009eda14cbcSMatt Macy 	const char *opt_desc[] = {
6010eda14cbcSMatt Macy 		"-h", gettext("show this help message and exit"),
6011eda14cbcSMatt Macy 		"-l", gettext("set permission locally"),
6012eda14cbcSMatt Macy 		"-d", gettext("set permission for descents"),
6013eda14cbcSMatt Macy 		"-u", gettext("set permission for user"),
6014eda14cbcSMatt Macy 		"-g", gettext("set permission for group"),
6015eda14cbcSMatt Macy 		"-e", gettext("set permission for everyone"),
6016eda14cbcSMatt Macy 		"-c", gettext("set create time permission"),
6017eda14cbcSMatt Macy 		"-s", gettext("define permission set"),
6018eda14cbcSMatt Macy 		/* unallow only */
6019eda14cbcSMatt Macy 		"-r", gettext("remove permissions recursively"),
6020eda14cbcSMatt Macy 	};
6021eda14cbcSMatt Macy 	size_t unallow_size = sizeof (opt_desc) / sizeof (char *);
6022eda14cbcSMatt Macy 	size_t allow_size = unallow_size - 2;
6023eda14cbcSMatt Macy 	const char *props[ZFS_NUM_PROPS];
6024eda14cbcSMatt Macy 	int i;
6025eda14cbcSMatt Macy 	size_t count = 0;
6026eda14cbcSMatt Macy 	FILE *fp = requested ? stdout : stderr;
6027eda14cbcSMatt Macy 	zprop_desc_t *pdtbl = zfs_prop_get_table();
6028eda14cbcSMatt Macy 	const char *fmt = gettext("%-16s %-14s\t%s\n");
6029eda14cbcSMatt Macy 
6030eda14cbcSMatt Macy 	(void) fprintf(fp, gettext("Usage: %s\n"), get_usage(un ? HELP_UNALLOW :
6031eda14cbcSMatt Macy 	    HELP_ALLOW));
6032eda14cbcSMatt Macy 	(void) fprintf(fp, gettext("Options:\n"));
6033eda14cbcSMatt Macy 	for (i = 0; i < (un ? unallow_size : allow_size); i += 2) {
6034eda14cbcSMatt Macy 		const char *opt = opt_desc[i];
6035eda14cbcSMatt Macy 		const char *optdsc = opt_desc[i + 1];
6036eda14cbcSMatt Macy 		(void) fprintf(fp, gettext("  %-10s  %s\n"), opt, optdsc);
6037eda14cbcSMatt Macy 	}
6038eda14cbcSMatt Macy 
6039eda14cbcSMatt Macy 	(void) fprintf(fp, gettext("\nThe following permissions are "
6040eda14cbcSMatt Macy 	    "supported:\n\n"));
6041eda14cbcSMatt Macy 	(void) fprintf(fp, fmt, gettext("NAME"), gettext("TYPE"),
6042eda14cbcSMatt Macy 	    gettext("NOTES"));
6043eda14cbcSMatt Macy 	for (i = 0; i < ZFS_NUM_DELEG_NOTES; i++) {
6044eda14cbcSMatt Macy 		const char *perm_name = zfs_deleg_perm_tbl[i].z_perm;
6045eda14cbcSMatt Macy 		zfs_deleg_note_t perm_note = zfs_deleg_perm_tbl[i].z_note;
6046eda14cbcSMatt Macy 		const char *perm_type = deleg_perm_type(perm_note);
6047eda14cbcSMatt Macy 		const char *perm_comment = deleg_perm_comment(perm_note);
6048eda14cbcSMatt Macy 		(void) fprintf(fp, fmt, perm_name, perm_type, perm_comment);
6049eda14cbcSMatt Macy 	}
6050eda14cbcSMatt Macy 
6051eda14cbcSMatt Macy 	for (i = 0; i < ZFS_NUM_PROPS; i++) {
6052eda14cbcSMatt Macy 		zprop_desc_t *pd = &pdtbl[i];
6053eda14cbcSMatt Macy 		if (pd->pd_visible != B_TRUE)
6054eda14cbcSMatt Macy 			continue;
6055eda14cbcSMatt Macy 
6056eda14cbcSMatt Macy 		if (pd->pd_attr == PROP_READONLY)
6057eda14cbcSMatt Macy 			continue;
6058eda14cbcSMatt Macy 
6059eda14cbcSMatt Macy 		props[count++] = pd->pd_name;
6060eda14cbcSMatt Macy 	}
6061eda14cbcSMatt Macy 	props[count] = NULL;
6062eda14cbcSMatt Macy 
6063eda14cbcSMatt Macy 	qsort(props, count, sizeof (char *), prop_cmp);
6064eda14cbcSMatt Macy 
6065eda14cbcSMatt Macy 	for (i = 0; i < count; i++)
6066eda14cbcSMatt Macy 		(void) fprintf(fp, fmt, props[i], gettext("property"), "");
6067eda14cbcSMatt Macy 
6068eda14cbcSMatt Macy 	if (msg != NULL)
6069eda14cbcSMatt Macy 		(void) fprintf(fp, gettext("\nzfs: error: %s"), msg);
6070eda14cbcSMatt Macy 
6071eda14cbcSMatt Macy 	exit(requested ? 0 : 2);
6072eda14cbcSMatt Macy }
6073eda14cbcSMatt Macy 
6074eda14cbcSMatt Macy static inline const char *
6075eda14cbcSMatt Macy munge_args(int argc, char **argv, boolean_t un, size_t expected_argc,
6076eda14cbcSMatt Macy     char **permsp)
6077eda14cbcSMatt Macy {
6078eda14cbcSMatt Macy 	if (un && argc == expected_argc - 1)
6079eda14cbcSMatt Macy 		*permsp = NULL;
6080eda14cbcSMatt Macy 	else if (argc == expected_argc)
6081eda14cbcSMatt Macy 		*permsp = argv[argc - 2];
6082eda14cbcSMatt Macy 	else
6083eda14cbcSMatt Macy 		allow_usage(un, B_FALSE,
6084eda14cbcSMatt Macy 		    gettext("wrong number of parameters\n"));
6085eda14cbcSMatt Macy 
6086eda14cbcSMatt Macy 	return (argv[argc - 1]);
6087eda14cbcSMatt Macy }
6088eda14cbcSMatt Macy 
6089eda14cbcSMatt Macy static void
6090eda14cbcSMatt Macy parse_allow_args(int argc, char **argv, boolean_t un, struct allow_opts *opts)
6091eda14cbcSMatt Macy {
6092eda14cbcSMatt Macy 	int uge_sum = opts->user + opts->group + opts->everyone;
6093eda14cbcSMatt Macy 	int csuge_sum = opts->create + opts->set + uge_sum;
6094eda14cbcSMatt Macy 	int ldcsuge_sum = csuge_sum + opts->local + opts->descend;
6095eda14cbcSMatt Macy 	int all_sum = un ? ldcsuge_sum + opts->recursive : ldcsuge_sum;
6096eda14cbcSMatt Macy 
6097eda14cbcSMatt Macy 	if (uge_sum > 1)
6098eda14cbcSMatt Macy 		allow_usage(un, B_FALSE,
6099eda14cbcSMatt Macy 		    gettext("-u, -g, and -e are mutually exclusive\n"));
6100eda14cbcSMatt Macy 
6101eda14cbcSMatt Macy 	if (opts->prt_usage) {
6102eda14cbcSMatt Macy 		if (argc == 0 && all_sum == 0)
6103eda14cbcSMatt Macy 			allow_usage(un, B_TRUE, NULL);
6104eda14cbcSMatt Macy 		else
6105eda14cbcSMatt Macy 			usage(B_FALSE);
6106eda14cbcSMatt Macy 	}
6107eda14cbcSMatt Macy 
6108eda14cbcSMatt Macy 	if (opts->set) {
6109eda14cbcSMatt Macy 		if (csuge_sum > 1)
6110eda14cbcSMatt Macy 			allow_usage(un, B_FALSE,
6111eda14cbcSMatt Macy 			    gettext("invalid options combined with -s\n"));
6112eda14cbcSMatt Macy 
6113eda14cbcSMatt Macy 		opts->dataset = munge_args(argc, argv, un, 3, &opts->perms);
6114eda14cbcSMatt Macy 		if (argv[0][0] != '@')
6115eda14cbcSMatt Macy 			allow_usage(un, B_FALSE,
6116eda14cbcSMatt Macy 			    gettext("invalid set name: missing '@' prefix\n"));
6117eda14cbcSMatt Macy 		opts->who = argv[0];
6118eda14cbcSMatt Macy 	} else if (opts->create) {
6119eda14cbcSMatt Macy 		if (ldcsuge_sum > 1)
6120eda14cbcSMatt Macy 			allow_usage(un, B_FALSE,
6121eda14cbcSMatt Macy 			    gettext("invalid options combined with -c\n"));
6122eda14cbcSMatt Macy 		opts->dataset = munge_args(argc, argv, un, 2, &opts->perms);
6123eda14cbcSMatt Macy 	} else if (opts->everyone) {
6124eda14cbcSMatt Macy 		if (csuge_sum > 1)
6125eda14cbcSMatt Macy 			allow_usage(un, B_FALSE,
6126eda14cbcSMatt Macy 			    gettext("invalid options combined with -e\n"));
6127eda14cbcSMatt Macy 		opts->dataset = munge_args(argc, argv, un, 2, &opts->perms);
6128eda14cbcSMatt Macy 	} else if (uge_sum == 0 && argc > 0 && strcmp(argv[0], "everyone")
6129eda14cbcSMatt Macy 	    == 0) {
6130eda14cbcSMatt Macy 		opts->everyone = B_TRUE;
6131eda14cbcSMatt Macy 		argc--;
6132eda14cbcSMatt Macy 		argv++;
6133eda14cbcSMatt Macy 		opts->dataset = munge_args(argc, argv, un, 2, &opts->perms);
6134eda14cbcSMatt Macy 	} else if (argc == 1 && !un) {
6135eda14cbcSMatt Macy 		opts->prt_perms = B_TRUE;
6136eda14cbcSMatt Macy 		opts->dataset = argv[argc-1];
6137eda14cbcSMatt Macy 	} else {
6138eda14cbcSMatt Macy 		opts->dataset = munge_args(argc, argv, un, 3, &opts->perms);
6139eda14cbcSMatt Macy 		opts->who = argv[0];
6140eda14cbcSMatt Macy 	}
6141eda14cbcSMatt Macy 
6142eda14cbcSMatt Macy 	if (!opts->local && !opts->descend) {
6143eda14cbcSMatt Macy 		opts->local = B_TRUE;
6144eda14cbcSMatt Macy 		opts->descend = B_TRUE;
6145eda14cbcSMatt Macy 	}
6146eda14cbcSMatt Macy }
6147eda14cbcSMatt Macy 
6148eda14cbcSMatt Macy static void
6149eda14cbcSMatt Macy store_allow_perm(zfs_deleg_who_type_t type, boolean_t local, boolean_t descend,
6150eda14cbcSMatt Macy     const char *who, char *perms, nvlist_t *top_nvl)
6151eda14cbcSMatt Macy {
6152eda14cbcSMatt Macy 	int i;
6153eda14cbcSMatt Macy 	char ld[2] = { '\0', '\0' };
6154eda14cbcSMatt Macy 	char who_buf[MAXNAMELEN + 32];
6155eda14cbcSMatt Macy 	char base_type = '\0';
6156eda14cbcSMatt Macy 	char set_type = '\0';
6157eda14cbcSMatt Macy 	nvlist_t *base_nvl = NULL;
6158eda14cbcSMatt Macy 	nvlist_t *set_nvl = NULL;
6159eda14cbcSMatt Macy 	nvlist_t *nvl;
6160eda14cbcSMatt Macy 
6161eda14cbcSMatt Macy 	if (nvlist_alloc(&base_nvl, NV_UNIQUE_NAME, 0) != 0)
6162eda14cbcSMatt Macy 		nomem();
6163eda14cbcSMatt Macy 	if (nvlist_alloc(&set_nvl, NV_UNIQUE_NAME, 0) !=  0)
6164eda14cbcSMatt Macy 		nomem();
6165eda14cbcSMatt Macy 
6166eda14cbcSMatt Macy 	switch (type) {
6167eda14cbcSMatt Macy 	case ZFS_DELEG_NAMED_SET_SETS:
6168eda14cbcSMatt Macy 	case ZFS_DELEG_NAMED_SET:
6169eda14cbcSMatt Macy 		set_type = ZFS_DELEG_NAMED_SET_SETS;
6170eda14cbcSMatt Macy 		base_type = ZFS_DELEG_NAMED_SET;
6171eda14cbcSMatt Macy 		ld[0] = ZFS_DELEG_NA;
6172eda14cbcSMatt Macy 		break;
6173eda14cbcSMatt Macy 	case ZFS_DELEG_CREATE_SETS:
6174eda14cbcSMatt Macy 	case ZFS_DELEG_CREATE:
6175eda14cbcSMatt Macy 		set_type = ZFS_DELEG_CREATE_SETS;
6176eda14cbcSMatt Macy 		base_type = ZFS_DELEG_CREATE;
6177eda14cbcSMatt Macy 		ld[0] = ZFS_DELEG_NA;
6178eda14cbcSMatt Macy 		break;
6179eda14cbcSMatt Macy 	case ZFS_DELEG_USER_SETS:
6180eda14cbcSMatt Macy 	case ZFS_DELEG_USER:
6181eda14cbcSMatt Macy 		set_type = ZFS_DELEG_USER_SETS;
6182eda14cbcSMatt Macy 		base_type = ZFS_DELEG_USER;
6183eda14cbcSMatt Macy 		if (local)
6184eda14cbcSMatt Macy 			ld[0] = ZFS_DELEG_LOCAL;
6185eda14cbcSMatt Macy 		if (descend)
6186eda14cbcSMatt Macy 			ld[1] = ZFS_DELEG_DESCENDENT;
6187eda14cbcSMatt Macy 		break;
6188eda14cbcSMatt Macy 	case ZFS_DELEG_GROUP_SETS:
6189eda14cbcSMatt Macy 	case ZFS_DELEG_GROUP:
6190eda14cbcSMatt Macy 		set_type = ZFS_DELEG_GROUP_SETS;
6191eda14cbcSMatt Macy 		base_type = ZFS_DELEG_GROUP;
6192eda14cbcSMatt Macy 		if (local)
6193eda14cbcSMatt Macy 			ld[0] = ZFS_DELEG_LOCAL;
6194eda14cbcSMatt Macy 		if (descend)
6195eda14cbcSMatt Macy 			ld[1] = ZFS_DELEG_DESCENDENT;
6196eda14cbcSMatt Macy 		break;
6197eda14cbcSMatt Macy 	case ZFS_DELEG_EVERYONE_SETS:
6198eda14cbcSMatt Macy 	case ZFS_DELEG_EVERYONE:
6199eda14cbcSMatt Macy 		set_type = ZFS_DELEG_EVERYONE_SETS;
6200eda14cbcSMatt Macy 		base_type = ZFS_DELEG_EVERYONE;
6201eda14cbcSMatt Macy 		if (local)
6202eda14cbcSMatt Macy 			ld[0] = ZFS_DELEG_LOCAL;
6203eda14cbcSMatt Macy 		if (descend)
6204eda14cbcSMatt Macy 			ld[1] = ZFS_DELEG_DESCENDENT;
6205eda14cbcSMatt Macy 		break;
6206eda14cbcSMatt Macy 
6207eda14cbcSMatt Macy 	default:
6208eda14cbcSMatt Macy 		assert(set_type != '\0' && base_type != '\0');
6209eda14cbcSMatt Macy 	}
6210eda14cbcSMatt Macy 
6211eda14cbcSMatt Macy 	if (perms != NULL) {
6212eda14cbcSMatt Macy 		char *curr = perms;
6213eda14cbcSMatt Macy 		char *end = curr + strlen(perms);
6214eda14cbcSMatt Macy 
6215eda14cbcSMatt Macy 		while (curr < end) {
6216eda14cbcSMatt Macy 			char *delim = strchr(curr, ',');
6217eda14cbcSMatt Macy 			if (delim == NULL)
6218eda14cbcSMatt Macy 				delim = end;
6219eda14cbcSMatt Macy 			else
6220eda14cbcSMatt Macy 				*delim = '\0';
6221eda14cbcSMatt Macy 
6222eda14cbcSMatt Macy 			if (curr[0] == '@')
6223eda14cbcSMatt Macy 				nvl = set_nvl;
6224eda14cbcSMatt Macy 			else
6225eda14cbcSMatt Macy 				nvl = base_nvl;
6226eda14cbcSMatt Macy 
6227eda14cbcSMatt Macy 			(void) nvlist_add_boolean(nvl, curr);
6228eda14cbcSMatt Macy 			if (delim != end)
6229eda14cbcSMatt Macy 				*delim = ',';
6230eda14cbcSMatt Macy 			curr = delim + 1;
6231eda14cbcSMatt Macy 		}
6232eda14cbcSMatt Macy 
6233eda14cbcSMatt Macy 		for (i = 0; i < 2; i++) {
6234eda14cbcSMatt Macy 			char locality = ld[i];
6235eda14cbcSMatt Macy 			if (locality == 0)
6236eda14cbcSMatt Macy 				continue;
6237eda14cbcSMatt Macy 
6238eda14cbcSMatt Macy 			if (!nvlist_empty(base_nvl)) {
6239eda14cbcSMatt Macy 				if (who != NULL)
6240eda14cbcSMatt Macy 					(void) snprintf(who_buf,
6241eda14cbcSMatt Macy 					    sizeof (who_buf), "%c%c$%s",
6242eda14cbcSMatt Macy 					    base_type, locality, who);
6243eda14cbcSMatt Macy 				else
6244eda14cbcSMatt Macy 					(void) snprintf(who_buf,
6245eda14cbcSMatt Macy 					    sizeof (who_buf), "%c%c$",
6246eda14cbcSMatt Macy 					    base_type, locality);
6247eda14cbcSMatt Macy 
6248eda14cbcSMatt Macy 				(void) nvlist_add_nvlist(top_nvl, who_buf,
6249eda14cbcSMatt Macy 				    base_nvl);
6250eda14cbcSMatt Macy 			}
6251eda14cbcSMatt Macy 
6252eda14cbcSMatt Macy 
6253eda14cbcSMatt Macy 			if (!nvlist_empty(set_nvl)) {
6254eda14cbcSMatt Macy 				if (who != NULL)
6255eda14cbcSMatt Macy 					(void) snprintf(who_buf,
6256eda14cbcSMatt Macy 					    sizeof (who_buf), "%c%c$%s",
6257eda14cbcSMatt Macy 					    set_type, locality, who);
6258eda14cbcSMatt Macy 				else
6259eda14cbcSMatt Macy 					(void) snprintf(who_buf,
6260eda14cbcSMatt Macy 					    sizeof (who_buf), "%c%c$",
6261eda14cbcSMatt Macy 					    set_type, locality);
6262eda14cbcSMatt Macy 
6263eda14cbcSMatt Macy 				(void) nvlist_add_nvlist(top_nvl, who_buf,
6264eda14cbcSMatt Macy 				    set_nvl);
6265eda14cbcSMatt Macy 			}
6266eda14cbcSMatt Macy 		}
6267eda14cbcSMatt Macy 	} else {
6268eda14cbcSMatt Macy 		for (i = 0; i < 2; i++) {
6269eda14cbcSMatt Macy 			char locality = ld[i];
6270eda14cbcSMatt Macy 			if (locality == 0)
6271eda14cbcSMatt Macy 				continue;
6272eda14cbcSMatt Macy 
6273eda14cbcSMatt Macy 			if (who != NULL)
6274eda14cbcSMatt Macy 				(void) snprintf(who_buf, sizeof (who_buf),
6275eda14cbcSMatt Macy 				    "%c%c$%s", base_type, locality, who);
6276eda14cbcSMatt Macy 			else
6277eda14cbcSMatt Macy 				(void) snprintf(who_buf, sizeof (who_buf),
6278eda14cbcSMatt Macy 				    "%c%c$", base_type, locality);
6279eda14cbcSMatt Macy 			(void) nvlist_add_boolean(top_nvl, who_buf);
6280eda14cbcSMatt Macy 
6281eda14cbcSMatt Macy 			if (who != NULL)
6282eda14cbcSMatt Macy 				(void) snprintf(who_buf, sizeof (who_buf),
6283eda14cbcSMatt Macy 				    "%c%c$%s", set_type, locality, who);
6284eda14cbcSMatt Macy 			else
6285eda14cbcSMatt Macy 				(void) snprintf(who_buf, sizeof (who_buf),
6286eda14cbcSMatt Macy 				    "%c%c$", set_type, locality);
6287eda14cbcSMatt Macy 			(void) nvlist_add_boolean(top_nvl, who_buf);
6288eda14cbcSMatt Macy 		}
6289eda14cbcSMatt Macy 	}
6290eda14cbcSMatt Macy }
6291eda14cbcSMatt Macy 
6292eda14cbcSMatt Macy static int
6293eda14cbcSMatt Macy construct_fsacl_list(boolean_t un, struct allow_opts *opts, nvlist_t **nvlp)
6294eda14cbcSMatt Macy {
6295eda14cbcSMatt Macy 	if (nvlist_alloc(nvlp, NV_UNIQUE_NAME, 0) != 0)
6296eda14cbcSMatt Macy 		nomem();
6297eda14cbcSMatt Macy 
6298eda14cbcSMatt Macy 	if (opts->set) {
6299eda14cbcSMatt Macy 		store_allow_perm(ZFS_DELEG_NAMED_SET, opts->local,
6300eda14cbcSMatt Macy 		    opts->descend, opts->who, opts->perms, *nvlp);
6301eda14cbcSMatt Macy 	} else if (opts->create) {
6302eda14cbcSMatt Macy 		store_allow_perm(ZFS_DELEG_CREATE, opts->local,
6303eda14cbcSMatt Macy 		    opts->descend, NULL, opts->perms, *nvlp);
6304eda14cbcSMatt Macy 	} else if (opts->everyone) {
6305eda14cbcSMatt Macy 		store_allow_perm(ZFS_DELEG_EVERYONE, opts->local,
6306eda14cbcSMatt Macy 		    opts->descend, NULL, opts->perms, *nvlp);
6307eda14cbcSMatt Macy 	} else {
6308eda14cbcSMatt Macy 		char *curr = opts->who;
6309eda14cbcSMatt Macy 		char *end = curr + strlen(curr);
6310eda14cbcSMatt Macy 
6311eda14cbcSMatt Macy 		while (curr < end) {
6312eda14cbcSMatt Macy 			const char *who;
6313eda14cbcSMatt Macy 			zfs_deleg_who_type_t who_type = ZFS_DELEG_WHO_UNKNOWN;
6314eda14cbcSMatt Macy 			char *endch;
6315eda14cbcSMatt Macy 			char *delim = strchr(curr, ',');
6316eda14cbcSMatt Macy 			char errbuf[256];
6317eda14cbcSMatt Macy 			char id[64];
6318eda14cbcSMatt Macy 			struct passwd *p = NULL;
6319eda14cbcSMatt Macy 			struct group *g = NULL;
6320eda14cbcSMatt Macy 
6321eda14cbcSMatt Macy 			uid_t rid;
6322eda14cbcSMatt Macy 			if (delim == NULL)
6323eda14cbcSMatt Macy 				delim = end;
6324eda14cbcSMatt Macy 			else
6325eda14cbcSMatt Macy 				*delim = '\0';
6326eda14cbcSMatt Macy 
6327eda14cbcSMatt Macy 			rid = (uid_t)strtol(curr, &endch, 0);
6328eda14cbcSMatt Macy 			if (opts->user) {
6329eda14cbcSMatt Macy 				who_type = ZFS_DELEG_USER;
6330eda14cbcSMatt Macy 				if (*endch != '\0')
6331eda14cbcSMatt Macy 					p = getpwnam(curr);
6332eda14cbcSMatt Macy 				else
6333eda14cbcSMatt Macy 					p = getpwuid(rid);
6334eda14cbcSMatt Macy 
6335eda14cbcSMatt Macy 				if (p != NULL)
6336eda14cbcSMatt Macy 					rid = p->pw_uid;
6337eda14cbcSMatt Macy 				else if (*endch != '\0') {
63380a97523dSMartin Matuska 					(void) snprintf(errbuf, sizeof (errbuf),
63390a97523dSMartin Matuska 					    gettext("invalid user %s\n"), curr);
6340eda14cbcSMatt Macy 					allow_usage(un, B_TRUE, errbuf);
6341eda14cbcSMatt Macy 				}
6342eda14cbcSMatt Macy 			} else if (opts->group) {
6343eda14cbcSMatt Macy 				who_type = ZFS_DELEG_GROUP;
6344eda14cbcSMatt Macy 				if (*endch != '\0')
6345eda14cbcSMatt Macy 					g = getgrnam(curr);
6346eda14cbcSMatt Macy 				else
6347eda14cbcSMatt Macy 					g = getgrgid(rid);
6348eda14cbcSMatt Macy 
6349eda14cbcSMatt Macy 				if (g != NULL)
6350eda14cbcSMatt Macy 					rid = g->gr_gid;
6351eda14cbcSMatt Macy 				else if (*endch != '\0') {
63520a97523dSMartin Matuska 					(void) snprintf(errbuf, sizeof (errbuf),
63530a97523dSMartin Matuska 					    gettext("invalid group %s\n"),
63540a97523dSMartin Matuska 					    curr);
6355eda14cbcSMatt Macy 					allow_usage(un, B_TRUE, errbuf);
6356eda14cbcSMatt Macy 				}
6357eda14cbcSMatt Macy 			} else {
6358eda14cbcSMatt Macy 				if (*endch != '\0') {
6359eda14cbcSMatt Macy 					p = getpwnam(curr);
6360eda14cbcSMatt Macy 				} else {
6361eda14cbcSMatt Macy 					p = getpwuid(rid);
6362eda14cbcSMatt Macy 				}
6363eda14cbcSMatt Macy 
6364eda14cbcSMatt Macy 				if (p == NULL) {
6365eda14cbcSMatt Macy 					if (*endch != '\0') {
6366eda14cbcSMatt Macy 						g = getgrnam(curr);
6367eda14cbcSMatt Macy 					} else {
6368eda14cbcSMatt Macy 						g = getgrgid(rid);
6369eda14cbcSMatt Macy 					}
6370eda14cbcSMatt Macy 				}
6371eda14cbcSMatt Macy 
6372eda14cbcSMatt Macy 				if (p != NULL) {
6373eda14cbcSMatt Macy 					who_type = ZFS_DELEG_USER;
6374eda14cbcSMatt Macy 					rid = p->pw_uid;
6375eda14cbcSMatt Macy 				} else if (g != NULL) {
6376eda14cbcSMatt Macy 					who_type = ZFS_DELEG_GROUP;
6377eda14cbcSMatt Macy 					rid = g->gr_gid;
6378eda14cbcSMatt Macy 				} else {
63790a97523dSMartin Matuska 					(void) snprintf(errbuf, sizeof (errbuf),
63800a97523dSMartin Matuska 					    gettext("invalid user/group %s\n"),
63810a97523dSMartin Matuska 					    curr);
6382eda14cbcSMatt Macy 					allow_usage(un, B_TRUE, errbuf);
6383eda14cbcSMatt Macy 				}
6384eda14cbcSMatt Macy 			}
6385eda14cbcSMatt Macy 
6386eda14cbcSMatt Macy 			(void) sprintf(id, "%u", rid);
6387eda14cbcSMatt Macy 			who = id;
6388eda14cbcSMatt Macy 
6389eda14cbcSMatt Macy 			store_allow_perm(who_type, opts->local,
6390eda14cbcSMatt Macy 			    opts->descend, who, opts->perms, *nvlp);
6391eda14cbcSMatt Macy 			curr = delim + 1;
6392eda14cbcSMatt Macy 		}
6393eda14cbcSMatt Macy 	}
6394eda14cbcSMatt Macy 
6395eda14cbcSMatt Macy 	return (0);
6396eda14cbcSMatt Macy }
6397eda14cbcSMatt Macy 
6398eda14cbcSMatt Macy static void
6399eda14cbcSMatt Macy print_set_creat_perms(uu_avl_t *who_avl)
6400eda14cbcSMatt Macy {
6401eda14cbcSMatt Macy 	const char *sc_title[] = {
6402eda14cbcSMatt Macy 		gettext("Permission sets:\n"),
6403eda14cbcSMatt Macy 		gettext("Create time permissions:\n"),
6404eda14cbcSMatt Macy 		NULL
6405eda14cbcSMatt Macy 	};
6406eda14cbcSMatt Macy 	who_perm_node_t *who_node = NULL;
6407eda14cbcSMatt Macy 	int prev_weight = -1;
6408eda14cbcSMatt Macy 
6409eda14cbcSMatt Macy 	for (who_node = uu_avl_first(who_avl); who_node != NULL;
6410eda14cbcSMatt Macy 	    who_node = uu_avl_next(who_avl, who_node)) {
6411eda14cbcSMatt Macy 		uu_avl_t *avl = who_node->who_perm.who_deleg_perm_avl;
6412eda14cbcSMatt Macy 		zfs_deleg_who_type_t who_type = who_node->who_perm.who_type;
6413eda14cbcSMatt Macy 		const char *who_name = who_node->who_perm.who_name;
6414eda14cbcSMatt Macy 		int weight = who_type2weight(who_type);
6415eda14cbcSMatt Macy 		boolean_t first = B_TRUE;
6416eda14cbcSMatt Macy 		deleg_perm_node_t *deleg_node;
6417eda14cbcSMatt Macy 
6418eda14cbcSMatt Macy 		if (prev_weight != weight) {
6419eda14cbcSMatt Macy 			(void) printf("%s", sc_title[weight]);
6420eda14cbcSMatt Macy 			prev_weight = weight;
6421eda14cbcSMatt Macy 		}
6422eda14cbcSMatt Macy 
6423eda14cbcSMatt Macy 		if (who_name == NULL || strnlen(who_name, 1) == 0)
6424eda14cbcSMatt Macy 			(void) printf("\t");
6425eda14cbcSMatt Macy 		else
6426eda14cbcSMatt Macy 			(void) printf("\t%s ", who_name);
6427eda14cbcSMatt Macy 
6428eda14cbcSMatt Macy 		for (deleg_node = uu_avl_first(avl); deleg_node != NULL;
6429eda14cbcSMatt Macy 		    deleg_node = uu_avl_next(avl, deleg_node)) {
6430eda14cbcSMatt Macy 			if (first) {
6431eda14cbcSMatt Macy 				(void) printf("%s",
6432eda14cbcSMatt Macy 				    deleg_node->dpn_perm.dp_name);
6433eda14cbcSMatt Macy 				first = B_FALSE;
6434eda14cbcSMatt Macy 			} else
6435eda14cbcSMatt Macy 				(void) printf(",%s",
6436eda14cbcSMatt Macy 				    deleg_node->dpn_perm.dp_name);
6437eda14cbcSMatt Macy 		}
6438eda14cbcSMatt Macy 
6439eda14cbcSMatt Macy 		(void) printf("\n");
6440eda14cbcSMatt Macy 	}
6441eda14cbcSMatt Macy }
6442eda14cbcSMatt Macy 
6443eda14cbcSMatt Macy static void
6444eda14cbcSMatt Macy print_uge_deleg_perms(uu_avl_t *who_avl, boolean_t local, boolean_t descend,
6445eda14cbcSMatt Macy     const char *title)
6446eda14cbcSMatt Macy {
6447eda14cbcSMatt Macy 	who_perm_node_t *who_node = NULL;
6448eda14cbcSMatt Macy 	boolean_t prt_title = B_TRUE;
6449eda14cbcSMatt Macy 	uu_avl_walk_t *walk;
6450eda14cbcSMatt Macy 
6451eda14cbcSMatt Macy 	if ((walk = uu_avl_walk_start(who_avl, UU_WALK_ROBUST)) == NULL)
6452eda14cbcSMatt Macy 		nomem();
6453eda14cbcSMatt Macy 
6454eda14cbcSMatt Macy 	while ((who_node = uu_avl_walk_next(walk)) != NULL) {
6455eda14cbcSMatt Macy 		const char *who_name = who_node->who_perm.who_name;
6456eda14cbcSMatt Macy 		const char *nice_who_name = who_node->who_perm.who_ug_name;
6457eda14cbcSMatt Macy 		uu_avl_t *avl = who_node->who_perm.who_deleg_perm_avl;
6458eda14cbcSMatt Macy 		zfs_deleg_who_type_t who_type = who_node->who_perm.who_type;
6459eda14cbcSMatt Macy 		char delim = ' ';
6460eda14cbcSMatt Macy 		deleg_perm_node_t *deleg_node;
6461eda14cbcSMatt Macy 		boolean_t prt_who = B_TRUE;
6462eda14cbcSMatt Macy 
6463eda14cbcSMatt Macy 		for (deleg_node = uu_avl_first(avl);
6464eda14cbcSMatt Macy 		    deleg_node != NULL;
6465eda14cbcSMatt Macy 		    deleg_node = uu_avl_next(avl, deleg_node)) {
6466eda14cbcSMatt Macy 			if (local != deleg_node->dpn_perm.dp_local ||
6467eda14cbcSMatt Macy 			    descend != deleg_node->dpn_perm.dp_descend)
6468eda14cbcSMatt Macy 				continue;
6469eda14cbcSMatt Macy 
6470eda14cbcSMatt Macy 			if (prt_who) {
6471eda14cbcSMatt Macy 				const char *who = NULL;
6472eda14cbcSMatt Macy 				if (prt_title) {
6473eda14cbcSMatt Macy 					prt_title = B_FALSE;
6474eda14cbcSMatt Macy 					(void) printf("%s", title);
6475eda14cbcSMatt Macy 				}
6476eda14cbcSMatt Macy 
6477eda14cbcSMatt Macy 				switch (who_type) {
6478eda14cbcSMatt Macy 				case ZFS_DELEG_USER_SETS:
6479eda14cbcSMatt Macy 				case ZFS_DELEG_USER:
6480eda14cbcSMatt Macy 					who = gettext("user");
6481eda14cbcSMatt Macy 					if (nice_who_name)
6482eda14cbcSMatt Macy 						who_name  = nice_who_name;
6483eda14cbcSMatt Macy 					break;
6484eda14cbcSMatt Macy 				case ZFS_DELEG_GROUP_SETS:
6485eda14cbcSMatt Macy 				case ZFS_DELEG_GROUP:
6486eda14cbcSMatt Macy 					who = gettext("group");
6487eda14cbcSMatt Macy 					if (nice_who_name)
6488eda14cbcSMatt Macy 						who_name  = nice_who_name;
6489eda14cbcSMatt Macy 					break;
6490eda14cbcSMatt Macy 				case ZFS_DELEG_EVERYONE_SETS:
6491eda14cbcSMatt Macy 				case ZFS_DELEG_EVERYONE:
6492eda14cbcSMatt Macy 					who = gettext("everyone");
6493eda14cbcSMatt Macy 					who_name = NULL;
6494eda14cbcSMatt Macy 					break;
6495eda14cbcSMatt Macy 
6496eda14cbcSMatt Macy 				default:
6497eda14cbcSMatt Macy 					assert(who != NULL);
6498eda14cbcSMatt Macy 				}
6499eda14cbcSMatt Macy 
6500eda14cbcSMatt Macy 				prt_who = B_FALSE;
6501eda14cbcSMatt Macy 				if (who_name == NULL)
6502eda14cbcSMatt Macy 					(void) printf("\t%s", who);
6503eda14cbcSMatt Macy 				else
6504eda14cbcSMatt Macy 					(void) printf("\t%s %s", who, who_name);
6505eda14cbcSMatt Macy 			}
6506eda14cbcSMatt Macy 
6507eda14cbcSMatt Macy 			(void) printf("%c%s", delim,
6508eda14cbcSMatt Macy 			    deleg_node->dpn_perm.dp_name);
6509eda14cbcSMatt Macy 			delim = ',';
6510eda14cbcSMatt Macy 		}
6511eda14cbcSMatt Macy 
6512eda14cbcSMatt Macy 		if (!prt_who)
6513eda14cbcSMatt Macy 			(void) printf("\n");
6514eda14cbcSMatt Macy 	}
6515eda14cbcSMatt Macy 
6516eda14cbcSMatt Macy 	uu_avl_walk_end(walk);
6517eda14cbcSMatt Macy }
6518eda14cbcSMatt Macy 
6519eda14cbcSMatt Macy static void
6520eda14cbcSMatt Macy print_fs_perms(fs_perm_set_t *fspset)
6521eda14cbcSMatt Macy {
6522eda14cbcSMatt Macy 	fs_perm_node_t *node = NULL;
6523eda14cbcSMatt Macy 	char buf[MAXNAMELEN + 32];
6524eda14cbcSMatt Macy 	const char *dsname = buf;
6525eda14cbcSMatt Macy 
6526eda14cbcSMatt Macy 	for (node = uu_list_first(fspset->fsps_list); node != NULL;
6527eda14cbcSMatt Macy 	    node = uu_list_next(fspset->fsps_list, node)) {
6528eda14cbcSMatt Macy 		uu_avl_t *sc_avl = node->fspn_fsperm.fsp_sc_avl;
6529eda14cbcSMatt Macy 		uu_avl_t *uge_avl = node->fspn_fsperm.fsp_uge_avl;
6530eda14cbcSMatt Macy 		int left = 0;
6531eda14cbcSMatt Macy 
6532eda14cbcSMatt Macy 		(void) snprintf(buf, sizeof (buf),
6533eda14cbcSMatt Macy 		    gettext("---- Permissions on %s "),
6534eda14cbcSMatt Macy 		    node->fspn_fsperm.fsp_name);
6535eda14cbcSMatt Macy 		(void) printf("%s", dsname);
6536eda14cbcSMatt Macy 		left = 70 - strlen(buf);
6537eda14cbcSMatt Macy 		while (left-- > 0)
6538eda14cbcSMatt Macy 			(void) printf("-");
6539eda14cbcSMatt Macy 		(void) printf("\n");
6540eda14cbcSMatt Macy 
6541eda14cbcSMatt Macy 		print_set_creat_perms(sc_avl);
6542eda14cbcSMatt Macy 		print_uge_deleg_perms(uge_avl, B_TRUE, B_FALSE,
6543eda14cbcSMatt Macy 		    gettext("Local permissions:\n"));
6544eda14cbcSMatt Macy 		print_uge_deleg_perms(uge_avl, B_FALSE, B_TRUE,
6545eda14cbcSMatt Macy 		    gettext("Descendent permissions:\n"));
6546eda14cbcSMatt Macy 		print_uge_deleg_perms(uge_avl, B_TRUE, B_TRUE,
6547eda14cbcSMatt Macy 		    gettext("Local+Descendent permissions:\n"));
6548eda14cbcSMatt Macy 	}
6549eda14cbcSMatt Macy }
6550eda14cbcSMatt Macy 
6551eda14cbcSMatt Macy static fs_perm_set_t fs_perm_set = { NULL, NULL, NULL, NULL };
6552eda14cbcSMatt Macy 
6553eda14cbcSMatt Macy struct deleg_perms {
6554eda14cbcSMatt Macy 	boolean_t un;
6555eda14cbcSMatt Macy 	nvlist_t *nvl;
6556eda14cbcSMatt Macy };
6557eda14cbcSMatt Macy 
6558eda14cbcSMatt Macy static int
6559eda14cbcSMatt Macy set_deleg_perms(zfs_handle_t *zhp, void *data)
6560eda14cbcSMatt Macy {
6561eda14cbcSMatt Macy 	struct deleg_perms *perms = (struct deleg_perms *)data;
6562eda14cbcSMatt Macy 	zfs_type_t zfs_type = zfs_get_type(zhp);
6563eda14cbcSMatt Macy 
6564eda14cbcSMatt Macy 	if (zfs_type != ZFS_TYPE_FILESYSTEM && zfs_type != ZFS_TYPE_VOLUME)
6565eda14cbcSMatt Macy 		return (0);
6566eda14cbcSMatt Macy 
6567eda14cbcSMatt Macy 	return (zfs_set_fsacl(zhp, perms->un, perms->nvl));
6568eda14cbcSMatt Macy }
6569eda14cbcSMatt Macy 
6570eda14cbcSMatt Macy static int
6571eda14cbcSMatt Macy zfs_do_allow_unallow_impl(int argc, char **argv, boolean_t un)
6572eda14cbcSMatt Macy {
6573eda14cbcSMatt Macy 	zfs_handle_t *zhp;
6574eda14cbcSMatt Macy 	nvlist_t *perm_nvl = NULL;
6575eda14cbcSMatt Macy 	nvlist_t *update_perm_nvl = NULL;
6576eda14cbcSMatt Macy 	int error = 1;
6577eda14cbcSMatt Macy 	int c;
6578eda14cbcSMatt Macy 	struct allow_opts opts = { 0 };
6579eda14cbcSMatt Macy 
6580eda14cbcSMatt Macy 	const char *optstr = un ? "ldugecsrh" : "ldugecsh";
6581eda14cbcSMatt Macy 
6582eda14cbcSMatt Macy 	/* check opts */
6583eda14cbcSMatt Macy 	while ((c = getopt(argc, argv, optstr)) != -1) {
6584eda14cbcSMatt Macy 		switch (c) {
6585eda14cbcSMatt Macy 		case 'l':
6586eda14cbcSMatt Macy 			opts.local = B_TRUE;
6587eda14cbcSMatt Macy 			break;
6588eda14cbcSMatt Macy 		case 'd':
6589eda14cbcSMatt Macy 			opts.descend = B_TRUE;
6590eda14cbcSMatt Macy 			break;
6591eda14cbcSMatt Macy 		case 'u':
6592eda14cbcSMatt Macy 			opts.user = B_TRUE;
6593eda14cbcSMatt Macy 			break;
6594eda14cbcSMatt Macy 		case 'g':
6595eda14cbcSMatt Macy 			opts.group = B_TRUE;
6596eda14cbcSMatt Macy 			break;
6597eda14cbcSMatt Macy 		case 'e':
6598eda14cbcSMatt Macy 			opts.everyone = B_TRUE;
6599eda14cbcSMatt Macy 			break;
6600eda14cbcSMatt Macy 		case 's':
6601eda14cbcSMatt Macy 			opts.set = B_TRUE;
6602eda14cbcSMatt Macy 			break;
6603eda14cbcSMatt Macy 		case 'c':
6604eda14cbcSMatt Macy 			opts.create = B_TRUE;
6605eda14cbcSMatt Macy 			break;
6606eda14cbcSMatt Macy 		case 'r':
6607eda14cbcSMatt Macy 			opts.recursive = B_TRUE;
6608eda14cbcSMatt Macy 			break;
6609eda14cbcSMatt Macy 		case ':':
6610eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("missing argument for "
6611eda14cbcSMatt Macy 			    "'%c' option\n"), optopt);
6612eda14cbcSMatt Macy 			usage(B_FALSE);
6613eda14cbcSMatt Macy 			break;
6614eda14cbcSMatt Macy 		case 'h':
6615eda14cbcSMatt Macy 			opts.prt_usage = B_TRUE;
6616eda14cbcSMatt Macy 			break;
6617eda14cbcSMatt Macy 		case '?':
6618eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
6619eda14cbcSMatt Macy 			    optopt);
6620eda14cbcSMatt Macy 			usage(B_FALSE);
6621eda14cbcSMatt Macy 		}
6622eda14cbcSMatt Macy 	}
6623eda14cbcSMatt Macy 
6624eda14cbcSMatt Macy 	argc -= optind;
6625eda14cbcSMatt Macy 	argv += optind;
6626eda14cbcSMatt Macy 
6627eda14cbcSMatt Macy 	/* check arguments */
6628eda14cbcSMatt Macy 	parse_allow_args(argc, argv, un, &opts);
6629eda14cbcSMatt Macy 
6630eda14cbcSMatt Macy 	/* try to open the dataset */
6631eda14cbcSMatt Macy 	if ((zhp = zfs_open(g_zfs, opts.dataset, ZFS_TYPE_FILESYSTEM |
6632eda14cbcSMatt Macy 	    ZFS_TYPE_VOLUME)) == NULL) {
6633eda14cbcSMatt Macy 		(void) fprintf(stderr, "Failed to open dataset: %s\n",
6634eda14cbcSMatt Macy 		    opts.dataset);
6635eda14cbcSMatt Macy 		return (-1);
6636eda14cbcSMatt Macy 	}
6637eda14cbcSMatt Macy 
6638eda14cbcSMatt Macy 	if (zfs_get_fsacl(zhp, &perm_nvl) != 0)
6639eda14cbcSMatt Macy 		goto cleanup2;
6640eda14cbcSMatt Macy 
6641eda14cbcSMatt Macy 	fs_perm_set_init(&fs_perm_set);
6642eda14cbcSMatt Macy 	if (parse_fs_perm_set(&fs_perm_set, perm_nvl) != 0) {
6643eda14cbcSMatt Macy 		(void) fprintf(stderr, "Failed to parse fsacl permissions\n");
6644eda14cbcSMatt Macy 		goto cleanup1;
6645eda14cbcSMatt Macy 	}
6646eda14cbcSMatt Macy 
6647eda14cbcSMatt Macy 	if (opts.prt_perms)
6648eda14cbcSMatt Macy 		print_fs_perms(&fs_perm_set);
6649eda14cbcSMatt Macy 	else {
6650eda14cbcSMatt Macy 		(void) construct_fsacl_list(un, &opts, &update_perm_nvl);
6651eda14cbcSMatt Macy 		if (zfs_set_fsacl(zhp, un, update_perm_nvl) != 0)
6652eda14cbcSMatt Macy 			goto cleanup0;
6653eda14cbcSMatt Macy 
6654eda14cbcSMatt Macy 		if (un && opts.recursive) {
6655eda14cbcSMatt Macy 			struct deleg_perms data = { un, update_perm_nvl };
6656d411c1d6SMartin Matuska 			if (zfs_iter_filesystems_v2(zhp, 0, set_deleg_perms,
6657eda14cbcSMatt Macy 			    &data) != 0)
6658eda14cbcSMatt Macy 				goto cleanup0;
6659eda14cbcSMatt Macy 		}
6660eda14cbcSMatt Macy 	}
6661eda14cbcSMatt Macy 
6662eda14cbcSMatt Macy 	error = 0;
6663eda14cbcSMatt Macy 
6664eda14cbcSMatt Macy cleanup0:
6665eda14cbcSMatt Macy 	nvlist_free(perm_nvl);
6666eda14cbcSMatt Macy 	nvlist_free(update_perm_nvl);
6667eda14cbcSMatt Macy cleanup1:
6668eda14cbcSMatt Macy 	fs_perm_set_fini(&fs_perm_set);
6669eda14cbcSMatt Macy cleanup2:
6670eda14cbcSMatt Macy 	zfs_close(zhp);
6671eda14cbcSMatt Macy 
6672eda14cbcSMatt Macy 	return (error);
6673eda14cbcSMatt Macy }
6674eda14cbcSMatt Macy 
6675eda14cbcSMatt Macy static int
6676eda14cbcSMatt Macy zfs_do_allow(int argc, char **argv)
6677eda14cbcSMatt Macy {
6678eda14cbcSMatt Macy 	return (zfs_do_allow_unallow_impl(argc, argv, B_FALSE));
6679eda14cbcSMatt Macy }
6680eda14cbcSMatt Macy 
6681eda14cbcSMatt Macy static int
6682eda14cbcSMatt Macy zfs_do_unallow(int argc, char **argv)
6683eda14cbcSMatt Macy {
6684eda14cbcSMatt Macy 	return (zfs_do_allow_unallow_impl(argc, argv, B_TRUE));
6685eda14cbcSMatt Macy }
6686eda14cbcSMatt Macy 
6687eda14cbcSMatt Macy static int
6688eda14cbcSMatt Macy zfs_do_hold_rele_impl(int argc, char **argv, boolean_t holding)
6689eda14cbcSMatt Macy {
6690eda14cbcSMatt Macy 	int errors = 0;
6691eda14cbcSMatt Macy 	int i;
6692eda14cbcSMatt Macy 	const char *tag;
6693eda14cbcSMatt Macy 	boolean_t recursive = B_FALSE;
6694eda14cbcSMatt Macy 	const char *opts = holding ? "rt" : "r";
6695eda14cbcSMatt Macy 	int c;
6696eda14cbcSMatt Macy 
6697eda14cbcSMatt Macy 	/* check options */
6698eda14cbcSMatt Macy 	while ((c = getopt(argc, argv, opts)) != -1) {
6699eda14cbcSMatt Macy 		switch (c) {
6700eda14cbcSMatt Macy 		case 'r':
6701eda14cbcSMatt Macy 			recursive = B_TRUE;
6702eda14cbcSMatt Macy 			break;
6703eda14cbcSMatt Macy 		case '?':
6704eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
6705eda14cbcSMatt Macy 			    optopt);
6706eda14cbcSMatt Macy 			usage(B_FALSE);
6707eda14cbcSMatt Macy 		}
6708eda14cbcSMatt Macy 	}
6709eda14cbcSMatt Macy 
6710eda14cbcSMatt Macy 	argc -= optind;
6711eda14cbcSMatt Macy 	argv += optind;
6712eda14cbcSMatt Macy 
6713eda14cbcSMatt Macy 	/* check number of arguments */
6714eda14cbcSMatt Macy 	if (argc < 2)
6715eda14cbcSMatt Macy 		usage(B_FALSE);
6716eda14cbcSMatt Macy 
6717eda14cbcSMatt Macy 	tag = argv[0];
6718eda14cbcSMatt Macy 	--argc;
6719eda14cbcSMatt Macy 	++argv;
6720eda14cbcSMatt Macy 
6721eda14cbcSMatt Macy 	if (holding && tag[0] == '.') {
6722eda14cbcSMatt Macy 		/* tags starting with '.' are reserved for libzfs */
6723eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("tag may not start with '.'\n"));
6724eda14cbcSMatt Macy 		usage(B_FALSE);
6725eda14cbcSMatt Macy 	}
6726eda14cbcSMatt Macy 
6727eda14cbcSMatt Macy 	for (i = 0; i < argc; ++i) {
6728eda14cbcSMatt Macy 		zfs_handle_t *zhp;
6729eda14cbcSMatt Macy 		char parent[ZFS_MAX_DATASET_NAME_LEN];
6730eda14cbcSMatt Macy 		const char *delim;
6731eda14cbcSMatt Macy 		char *path = argv[i];
6732eda14cbcSMatt Macy 
6733eda14cbcSMatt Macy 		delim = strchr(path, '@');
6734eda14cbcSMatt Macy 		if (delim == NULL) {
6735eda14cbcSMatt Macy 			(void) fprintf(stderr,
6736eda14cbcSMatt Macy 			    gettext("'%s' is not a snapshot\n"), path);
6737eda14cbcSMatt Macy 			++errors;
6738eda14cbcSMatt Macy 			continue;
6739eda14cbcSMatt Macy 		}
6740be181ee2SMartin Matuska 		(void) strlcpy(parent, path, MIN(sizeof (parent),
6741be181ee2SMartin Matuska 		    delim - path + 1));
6742eda14cbcSMatt Macy 
6743eda14cbcSMatt Macy 		zhp = zfs_open(g_zfs, parent,
6744eda14cbcSMatt Macy 		    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
6745eda14cbcSMatt Macy 		if (zhp == NULL) {
6746eda14cbcSMatt Macy 			++errors;
6747eda14cbcSMatt Macy 			continue;
6748eda14cbcSMatt Macy 		}
6749eda14cbcSMatt Macy 		if (holding) {
6750eda14cbcSMatt Macy 			if (zfs_hold(zhp, delim+1, tag, recursive, -1) != 0)
6751eda14cbcSMatt Macy 				++errors;
6752eda14cbcSMatt Macy 		} else {
6753eda14cbcSMatt Macy 			if (zfs_release(zhp, delim+1, tag, recursive) != 0)
6754eda14cbcSMatt Macy 				++errors;
6755eda14cbcSMatt Macy 		}
6756eda14cbcSMatt Macy 		zfs_close(zhp);
6757eda14cbcSMatt Macy 	}
6758eda14cbcSMatt Macy 
6759eda14cbcSMatt Macy 	return (errors != 0);
6760eda14cbcSMatt Macy }
6761eda14cbcSMatt Macy 
6762eda14cbcSMatt Macy /*
6763eda14cbcSMatt Macy  * zfs hold [-r] [-t] <tag> <snap> ...
6764eda14cbcSMatt Macy  *
6765eda14cbcSMatt Macy  *	-r	Recursively hold
6766eda14cbcSMatt Macy  *
6767eda14cbcSMatt Macy  * Apply a user-hold with the given tag to the list of snapshots.
6768eda14cbcSMatt Macy  */
6769eda14cbcSMatt Macy static int
6770eda14cbcSMatt Macy zfs_do_hold(int argc, char **argv)
6771eda14cbcSMatt Macy {
6772eda14cbcSMatt Macy 	return (zfs_do_hold_rele_impl(argc, argv, B_TRUE));
6773eda14cbcSMatt Macy }
6774eda14cbcSMatt Macy 
6775eda14cbcSMatt Macy /*
6776eda14cbcSMatt Macy  * zfs release [-r] <tag> <snap> ...
6777eda14cbcSMatt Macy  *
6778eda14cbcSMatt Macy  *	-r	Recursively release
6779eda14cbcSMatt Macy  *
6780eda14cbcSMatt Macy  * Release a user-hold with the given tag from the list of snapshots.
6781eda14cbcSMatt Macy  */
6782eda14cbcSMatt Macy static int
6783eda14cbcSMatt Macy zfs_do_release(int argc, char **argv)
6784eda14cbcSMatt Macy {
6785eda14cbcSMatt Macy 	return (zfs_do_hold_rele_impl(argc, argv, B_FALSE));
6786eda14cbcSMatt Macy }
6787eda14cbcSMatt Macy 
6788eda14cbcSMatt Macy typedef struct holds_cbdata {
6789eda14cbcSMatt Macy 	boolean_t	cb_recursive;
6790eda14cbcSMatt Macy 	const char	*cb_snapname;
6791eda14cbcSMatt Macy 	nvlist_t	**cb_nvlp;
6792eda14cbcSMatt Macy 	size_t		cb_max_namelen;
6793eda14cbcSMatt Macy 	size_t		cb_max_taglen;
6794eda14cbcSMatt Macy } holds_cbdata_t;
6795eda14cbcSMatt Macy 
6796eda14cbcSMatt Macy #define	STRFTIME_FMT_STR "%a %b %e %H:%M %Y"
6797eda14cbcSMatt Macy #define	DATETIME_BUF_LEN (32)
6798eda14cbcSMatt Macy /*
6799eda14cbcSMatt Macy  *
6800eda14cbcSMatt Macy  */
6801eda14cbcSMatt Macy static void
6802dbd5678dSMartin Matuska print_holds(boolean_t scripted, int nwidth, int tagwidth, nvlist_t *nvl,
6803dbd5678dSMartin Matuska     boolean_t parsable)
6804eda14cbcSMatt Macy {
6805eda14cbcSMatt Macy 	int i;
6806eda14cbcSMatt Macy 	nvpair_t *nvp = NULL;
6807a0b956f5SMartin Matuska 	const char *const hdr_cols[] = { "NAME", "TAG", "TIMESTAMP" };
6808eda14cbcSMatt Macy 	const char *col;
6809eda14cbcSMatt Macy 
6810eda14cbcSMatt Macy 	if (!scripted) {
6811eda14cbcSMatt Macy 		for (i = 0; i < 3; i++) {
6812eda14cbcSMatt Macy 			col = gettext(hdr_cols[i]);
6813eda14cbcSMatt Macy 			if (i < 2)
6814eda14cbcSMatt Macy 				(void) printf("%-*s  ", i ? tagwidth : nwidth,
6815eda14cbcSMatt Macy 				    col);
6816eda14cbcSMatt Macy 			else
6817eda14cbcSMatt Macy 				(void) printf("%s\n", col);
6818eda14cbcSMatt Macy 		}
6819eda14cbcSMatt Macy 	}
6820eda14cbcSMatt Macy 
6821eda14cbcSMatt Macy 	while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
68222a58b312SMartin Matuska 		const char *zname = nvpair_name(nvp);
6823eda14cbcSMatt Macy 		nvlist_t *nvl2;
6824eda14cbcSMatt Macy 		nvpair_t *nvp2 = NULL;
6825eda14cbcSMatt Macy 		(void) nvpair_value_nvlist(nvp, &nvl2);
6826eda14cbcSMatt Macy 		while ((nvp2 = nvlist_next_nvpair(nvl2, nvp2)) != NULL) {
6827eda14cbcSMatt Macy 			char tsbuf[DATETIME_BUF_LEN];
6828a0b956f5SMartin Matuska 			const char *tagname = nvpair_name(nvp2);
6829eda14cbcSMatt Macy 			uint64_t val = 0;
6830eda14cbcSMatt Macy 			time_t time;
6831eda14cbcSMatt Macy 			struct tm t;
6832eda14cbcSMatt Macy 
6833eda14cbcSMatt Macy 			(void) nvpair_value_uint64(nvp2, &val);
6834eda14cbcSMatt Macy 			time = (time_t)val;
6835eda14cbcSMatt Macy 			(void) localtime_r(&time, &t);
6836eda14cbcSMatt Macy 			(void) strftime(tsbuf, DATETIME_BUF_LEN,
6837eda14cbcSMatt Macy 			    gettext(STRFTIME_FMT_STR), &t);
6838eda14cbcSMatt Macy 
6839eda14cbcSMatt Macy 			if (scripted) {
6840dbd5678dSMartin Matuska 				if (parsable) {
6841dbd5678dSMartin Matuska 					(void) printf("%s\t%s\t%ld\n", zname,
684291986515SMartin Matuska 					    tagname, (unsigned long)time);
6843dbd5678dSMartin Matuska 				} else {
6844eda14cbcSMatt Macy 					(void) printf("%s\t%s\t%s\n", zname,
6845eda14cbcSMatt Macy 					    tagname, tsbuf);
6846dbd5678dSMartin Matuska 				}
6847eda14cbcSMatt Macy 			} else {
6848dbd5678dSMartin Matuska 				if (parsable) {
6849dbd5678dSMartin Matuska 					(void) printf("%-*s  %-*s  %ld\n",
6850dbd5678dSMartin Matuska 					    nwidth, zname, tagwidth,
685191986515SMartin Matuska 					    tagname, (unsigned long)time);
6852dbd5678dSMartin Matuska 				} else {
6853dbd5678dSMartin Matuska 					(void) printf("%-*s  %-*s  %s\n",
6854dbd5678dSMartin Matuska 					    nwidth, zname, tagwidth,
6855dbd5678dSMartin Matuska 					    tagname, tsbuf);
6856dbd5678dSMartin Matuska 				}
6857eda14cbcSMatt Macy 			}
6858eda14cbcSMatt Macy 		}
6859eda14cbcSMatt Macy 	}
6860eda14cbcSMatt Macy }
6861eda14cbcSMatt Macy 
6862eda14cbcSMatt Macy /*
6863eda14cbcSMatt Macy  * Generic callback function to list a dataset or snapshot.
6864eda14cbcSMatt Macy  */
6865eda14cbcSMatt Macy static int
6866eda14cbcSMatt Macy holds_callback(zfs_handle_t *zhp, void *data)
6867eda14cbcSMatt Macy {
6868eda14cbcSMatt Macy 	holds_cbdata_t *cbp = data;
6869eda14cbcSMatt Macy 	nvlist_t *top_nvl = *cbp->cb_nvlp;
6870eda14cbcSMatt Macy 	nvlist_t *nvl = NULL;
6871eda14cbcSMatt Macy 	nvpair_t *nvp = NULL;
6872eda14cbcSMatt Macy 	const char *zname = zfs_get_name(zhp);
6873eda14cbcSMatt Macy 	size_t znamelen = strlen(zname);
6874eda14cbcSMatt Macy 
6875eda14cbcSMatt Macy 	if (cbp->cb_recursive) {
6876eda14cbcSMatt Macy 		const char *snapname;
6877eda14cbcSMatt Macy 		char *delim  = strchr(zname, '@');
6878eda14cbcSMatt Macy 		if (delim == NULL)
6879eda14cbcSMatt Macy 			return (0);
6880eda14cbcSMatt Macy 
6881eda14cbcSMatt Macy 		snapname = delim + 1;
6882eda14cbcSMatt Macy 		if (strcmp(cbp->cb_snapname, snapname))
6883eda14cbcSMatt Macy 			return (0);
6884eda14cbcSMatt Macy 	}
6885eda14cbcSMatt Macy 
6886eda14cbcSMatt Macy 	if (zfs_get_holds(zhp, &nvl) != 0)
6887eda14cbcSMatt Macy 		return (-1);
6888eda14cbcSMatt Macy 
6889eda14cbcSMatt Macy 	if (znamelen > cbp->cb_max_namelen)
6890eda14cbcSMatt Macy 		cbp->cb_max_namelen  = znamelen;
6891eda14cbcSMatt Macy 
6892eda14cbcSMatt Macy 	while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
6893eda14cbcSMatt Macy 		const char *tag = nvpair_name(nvp);
6894eda14cbcSMatt Macy 		size_t taglen = strlen(tag);
6895eda14cbcSMatt Macy 		if (taglen > cbp->cb_max_taglen)
6896eda14cbcSMatt Macy 			cbp->cb_max_taglen  = taglen;
6897eda14cbcSMatt Macy 	}
6898eda14cbcSMatt Macy 
6899eda14cbcSMatt Macy 	return (nvlist_add_nvlist(top_nvl, zname, nvl));
6900eda14cbcSMatt Macy }
6901eda14cbcSMatt Macy 
6902eda14cbcSMatt Macy /*
6903dbd5678dSMartin Matuska  * zfs holds [-rHp] <snap> ...
6904eda14cbcSMatt Macy  *
6905eda14cbcSMatt Macy  *	-r	Lists holds that are set on the named snapshots recursively.
6906eda14cbcSMatt Macy  *	-H	Scripted mode; elide headers and separate columns by tabs.
6907dbd5678dSMartin Matuska  *	-p	Display values in parsable (literal) format.
6908eda14cbcSMatt Macy  */
6909eda14cbcSMatt Macy static int
6910eda14cbcSMatt Macy zfs_do_holds(int argc, char **argv)
6911eda14cbcSMatt Macy {
6912eda14cbcSMatt Macy 	int c;
6913716fd348SMartin Matuska 	boolean_t errors = B_FALSE;
6914eda14cbcSMatt Macy 	boolean_t scripted = B_FALSE;
6915eda14cbcSMatt Macy 	boolean_t recursive = B_FALSE;
6916dbd5678dSMartin Matuska 	boolean_t parsable = B_FALSE;
6917eda14cbcSMatt Macy 
6918eda14cbcSMatt Macy 	int types = ZFS_TYPE_SNAPSHOT;
6919eda14cbcSMatt Macy 	holds_cbdata_t cb = { 0 };
6920eda14cbcSMatt Macy 
6921eda14cbcSMatt Macy 	int limit = 0;
6922eda14cbcSMatt Macy 	int ret = 0;
6923eda14cbcSMatt Macy 	int flags = 0;
6924eda14cbcSMatt Macy 
6925eda14cbcSMatt Macy 	/* check options */
6926dbd5678dSMartin Matuska 	while ((c = getopt(argc, argv, "rHp")) != -1) {
6927eda14cbcSMatt Macy 		switch (c) {
6928eda14cbcSMatt Macy 		case 'r':
6929eda14cbcSMatt Macy 			recursive = B_TRUE;
6930eda14cbcSMatt Macy 			break;
6931eda14cbcSMatt Macy 		case 'H':
6932eda14cbcSMatt Macy 			scripted = B_TRUE;
6933eda14cbcSMatt Macy 			break;
6934dbd5678dSMartin Matuska 		case 'p':
6935dbd5678dSMartin Matuska 			parsable = B_TRUE;
6936dbd5678dSMartin Matuska 			break;
6937eda14cbcSMatt Macy 		case '?':
6938eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
6939eda14cbcSMatt Macy 			    optopt);
6940eda14cbcSMatt Macy 			usage(B_FALSE);
6941eda14cbcSMatt Macy 		}
6942eda14cbcSMatt Macy 	}
6943eda14cbcSMatt Macy 
6944eda14cbcSMatt Macy 	if (recursive) {
6945eda14cbcSMatt Macy 		types |= ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME;
6946eda14cbcSMatt Macy 		flags |= ZFS_ITER_RECURSE;
6947eda14cbcSMatt Macy 	}
6948eda14cbcSMatt Macy 
6949eda14cbcSMatt Macy 	argc -= optind;
6950eda14cbcSMatt Macy 	argv += optind;
6951eda14cbcSMatt Macy 
6952eda14cbcSMatt Macy 	/* check number of arguments */
6953eda14cbcSMatt Macy 	if (argc < 1)
6954eda14cbcSMatt Macy 		usage(B_FALSE);
6955eda14cbcSMatt Macy 
6956716fd348SMartin Matuska 	nvlist_t *nvl = fnvlist_alloc();
6957eda14cbcSMatt Macy 
6958716fd348SMartin Matuska 	for (int i = 0; i < argc; ++i) {
6959eda14cbcSMatt Macy 		char *snapshot = argv[i];
6960eda14cbcSMatt Macy 		const char *delim;
6961eda14cbcSMatt Macy 		const char *snapname;
6962eda14cbcSMatt Macy 
6963eda14cbcSMatt Macy 		delim = strchr(snapshot, '@');
6964eda14cbcSMatt Macy 		if (delim == NULL) {
6965eda14cbcSMatt Macy 			(void) fprintf(stderr,
6966eda14cbcSMatt Macy 			    gettext("'%s' is not a snapshot\n"), snapshot);
6967716fd348SMartin Matuska 			errors = B_TRUE;
6968eda14cbcSMatt Macy 			continue;
6969eda14cbcSMatt Macy 		}
6970eda14cbcSMatt Macy 		snapname = delim + 1;
6971eda14cbcSMatt Macy 		if (recursive)
6972eda14cbcSMatt Macy 			snapshot[delim - snapshot] = '\0';
6973eda14cbcSMatt Macy 
6974eda14cbcSMatt Macy 		cb.cb_recursive = recursive;
6975eda14cbcSMatt Macy 		cb.cb_snapname = snapname;
6976eda14cbcSMatt Macy 		cb.cb_nvlp = &nvl;
6977eda14cbcSMatt Macy 
6978eda14cbcSMatt Macy 		/*
6979eda14cbcSMatt Macy 		 *  1. collect holds data, set format options
6980eda14cbcSMatt Macy 		 */
6981716fd348SMartin Matuska 		ret = zfs_for_each(1, argv + i, flags, types, NULL, NULL, limit,
6982eda14cbcSMatt Macy 		    holds_callback, &cb);
6983eda14cbcSMatt Macy 		if (ret != 0)
6984716fd348SMartin Matuska 			errors = B_TRUE;
6985eda14cbcSMatt Macy 	}
6986eda14cbcSMatt Macy 
6987eda14cbcSMatt Macy 	/*
6988eda14cbcSMatt Macy 	 *  2. print holds data
6989eda14cbcSMatt Macy 	 */
6990dbd5678dSMartin Matuska 	print_holds(scripted, cb.cb_max_namelen, cb.cb_max_taglen, nvl,
6991dbd5678dSMartin Matuska 	    parsable);
6992eda14cbcSMatt Macy 
6993eda14cbcSMatt Macy 	if (nvlist_empty(nvl))
6994eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("no datasets available\n"));
6995eda14cbcSMatt Macy 
6996eda14cbcSMatt Macy 	nvlist_free(nvl);
6997eda14cbcSMatt Macy 
6998716fd348SMartin Matuska 	return (errors);
6999eda14cbcSMatt Macy }
7000eda14cbcSMatt Macy 
7001eda14cbcSMatt Macy #define	CHECK_SPINNER 30
7002eda14cbcSMatt Macy #define	SPINNER_TIME 3		/* seconds */
7003eda14cbcSMatt Macy #define	MOUNT_TIME 1		/* seconds */
7004eda14cbcSMatt Macy 
7005eda14cbcSMatt Macy typedef struct get_all_state {
70061719886fSMartin Matuska 	char		**ga_datasets;
70071719886fSMartin Matuska 	int		ga_count;
7008eda14cbcSMatt Macy 	boolean_t	ga_verbose;
7009eda14cbcSMatt Macy 	get_all_cb_t	*ga_cbp;
7010eda14cbcSMatt Macy } get_all_state_t;
7011eda14cbcSMatt Macy 
7012eda14cbcSMatt Macy static int
7013eda14cbcSMatt Macy get_one_dataset(zfs_handle_t *zhp, void *data)
7014eda14cbcSMatt Macy {
7015a0b956f5SMartin Matuska 	static const char *const spin[] = { "-", "\\", "|", "/" };
7016eda14cbcSMatt Macy 	static int spinval = 0;
7017eda14cbcSMatt Macy 	static int spincheck = 0;
7018eda14cbcSMatt Macy 	static time_t last_spin_time = (time_t)0;
7019eda14cbcSMatt Macy 	get_all_state_t *state = data;
7020eda14cbcSMatt Macy 	zfs_type_t type = zfs_get_type(zhp);
7021eda14cbcSMatt Macy 
7022eda14cbcSMatt Macy 	if (state->ga_verbose) {
7023eda14cbcSMatt Macy 		if (--spincheck < 0) {
7024eda14cbcSMatt Macy 			time_t now = time(NULL);
7025eda14cbcSMatt Macy 			if (last_spin_time + SPINNER_TIME < now) {
7026eda14cbcSMatt Macy 				update_progress(spin[spinval++ % 4]);
7027eda14cbcSMatt Macy 				last_spin_time = now;
7028eda14cbcSMatt Macy 			}
7029eda14cbcSMatt Macy 			spincheck = CHECK_SPINNER;
7030eda14cbcSMatt Macy 		}
7031eda14cbcSMatt Macy 	}
7032eda14cbcSMatt Macy 
7033eda14cbcSMatt Macy 	/*
7034eda14cbcSMatt Macy 	 * Iterate over any nested datasets.
7035eda14cbcSMatt Macy 	 */
7036d411c1d6SMartin Matuska 	if (zfs_iter_filesystems_v2(zhp, 0, get_one_dataset, data) != 0) {
7037eda14cbcSMatt Macy 		zfs_close(zhp);
7038eda14cbcSMatt Macy 		return (1);
7039eda14cbcSMatt Macy 	}
7040eda14cbcSMatt Macy 
7041eda14cbcSMatt Macy 	/*
7042eda14cbcSMatt Macy 	 * Skip any datasets whose type does not match.
7043eda14cbcSMatt Macy 	 */
7044eda14cbcSMatt Macy 	if ((type & ZFS_TYPE_FILESYSTEM) == 0) {
7045eda14cbcSMatt Macy 		zfs_close(zhp);
7046eda14cbcSMatt Macy 		return (0);
7047eda14cbcSMatt Macy 	}
7048eda14cbcSMatt Macy 	libzfs_add_handle(state->ga_cbp, zhp);
7049eda14cbcSMatt Macy 	assert(state->ga_cbp->cb_used <= state->ga_cbp->cb_alloc);
7050eda14cbcSMatt Macy 
7051eda14cbcSMatt Macy 	return (0);
7052eda14cbcSMatt Macy }
7053eda14cbcSMatt Macy 
70541719886fSMartin Matuska static int
70551719886fSMartin Matuska get_recursive_datasets(zfs_handle_t *zhp, void *data)
7056eda14cbcSMatt Macy {
70571719886fSMartin Matuska 	get_all_state_t *state = data;
70581719886fSMartin Matuska 	int len = strlen(zfs_get_name(zhp));
70591719886fSMartin Matuska 	for (int i = 0; i < state->ga_count; ++i) {
70601719886fSMartin Matuska 		if (strcmp(state->ga_datasets[i], zfs_get_name(zhp)) == 0)
70611719886fSMartin Matuska 			return (get_one_dataset(zhp, data));
70621719886fSMartin Matuska 		else if ((strncmp(state->ga_datasets[i], zfs_get_name(zhp),
70631719886fSMartin Matuska 		    len) == 0) && state->ga_datasets[i][len] == '/') {
70641719886fSMartin Matuska 			(void) zfs_iter_filesystems_v2(zhp, 0,
70651719886fSMartin Matuska 			    get_recursive_datasets, data);
70661719886fSMartin Matuska 		}
70671719886fSMartin Matuska 	}
70681719886fSMartin Matuska 	zfs_close(zhp);
70691719886fSMartin Matuska 	return (0);
70701719886fSMartin Matuska }
7071eda14cbcSMatt Macy 
70721719886fSMartin Matuska static void
70731719886fSMartin Matuska get_all_datasets(get_all_state_t *state)
70741719886fSMartin Matuska {
70751719886fSMartin Matuska 	if (state->ga_verbose)
7076eda14cbcSMatt Macy 		set_progress_header(gettext("Reading ZFS config"));
70771719886fSMartin Matuska 	if (state->ga_datasets == NULL)
70781719886fSMartin Matuska 		(void) zfs_iter_root(g_zfs, get_one_dataset, state);
70791719886fSMartin Matuska 	else
70801719886fSMartin Matuska 		(void) zfs_iter_root(g_zfs, get_recursive_datasets, state);
7081eda14cbcSMatt Macy 
70821719886fSMartin Matuska 	if (state->ga_verbose)
7083eda14cbcSMatt Macy 		finish_progress(gettext("done."));
7084eda14cbcSMatt Macy }
7085eda14cbcSMatt Macy 
7086eda14cbcSMatt Macy /*
7087eda14cbcSMatt Macy  * Generic callback for sharing or mounting filesystems.  Because the code is so
7088eda14cbcSMatt Macy  * similar, we have a common function with an extra parameter to determine which
7089eda14cbcSMatt Macy  * mode we are using.
7090eda14cbcSMatt Macy  */
7091eda14cbcSMatt Macy typedef enum { OP_SHARE, OP_MOUNT } share_mount_op_t;
7092eda14cbcSMatt Macy 
7093eda14cbcSMatt Macy typedef struct share_mount_state {
7094eda14cbcSMatt Macy 	share_mount_op_t	sm_op;
7095eda14cbcSMatt Macy 	boolean_t	sm_verbose;
7096eda14cbcSMatt Macy 	int	sm_flags;
7097eda14cbcSMatt Macy 	char	*sm_options;
7098716fd348SMartin Matuska 	enum sa_protocol	sm_proto; /* only valid for OP_SHARE */
7099eda14cbcSMatt Macy 	pthread_mutex_t	sm_lock; /* protects the remaining fields */
7100eda14cbcSMatt Macy 	uint_t	sm_total; /* number of filesystems to process */
7101eda14cbcSMatt Macy 	uint_t	sm_done; /* number of filesystems processed */
7102eda14cbcSMatt Macy 	int	sm_status; /* -1 if any of the share/mount operations failed */
7103eda14cbcSMatt Macy } share_mount_state_t;
7104eda14cbcSMatt Macy 
7105eda14cbcSMatt Macy /*
7106eda14cbcSMatt Macy  * Share or mount a dataset.
7107eda14cbcSMatt Macy  */
7108eda14cbcSMatt Macy static int
7109716fd348SMartin Matuska share_mount_one(zfs_handle_t *zhp, int op, int flags, enum sa_protocol protocol,
7110eda14cbcSMatt Macy     boolean_t explicit, const char *options)
7111eda14cbcSMatt Macy {
7112eda14cbcSMatt Macy 	char mountpoint[ZFS_MAXPROPLEN];
7113eda14cbcSMatt Macy 	char shareopts[ZFS_MAXPROPLEN];
7114eda14cbcSMatt Macy 	char smbshareopts[ZFS_MAXPROPLEN];
7115eda14cbcSMatt Macy 	const char *cmdname = op == OP_SHARE ? "share" : "mount";
7116eda14cbcSMatt Macy 	struct mnttab mnt;
7117eda14cbcSMatt Macy 	uint64_t zoned, canmount;
7118eda14cbcSMatt Macy 	boolean_t shared_nfs, shared_smb;
7119eda14cbcSMatt Macy 
7120eda14cbcSMatt Macy 	assert(zfs_get_type(zhp) & ZFS_TYPE_FILESYSTEM);
7121eda14cbcSMatt Macy 
7122eda14cbcSMatt Macy 	/*
7123eda14cbcSMatt Macy 	 * Check to make sure we can mount/share this dataset.  If we
7124eda14cbcSMatt Macy 	 * are in the global zone and the filesystem is exported to a
7125eda14cbcSMatt Macy 	 * local zone, or if we are in a local zone and the
7126eda14cbcSMatt Macy 	 * filesystem is not exported, then it is an error.
7127eda14cbcSMatt Macy 	 */
7128eda14cbcSMatt Macy 	zoned = zfs_prop_get_int(zhp, ZFS_PROP_ZONED);
7129eda14cbcSMatt Macy 
7130eda14cbcSMatt Macy 	if (zoned && getzoneid() == GLOBAL_ZONEID) {
7131eda14cbcSMatt Macy 		if (!explicit)
7132eda14cbcSMatt Macy 			return (0);
7133eda14cbcSMatt Macy 
7134eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("cannot %s '%s': "
7135eda14cbcSMatt Macy 		    "dataset is exported to a local zone\n"), cmdname,
7136eda14cbcSMatt Macy 		    zfs_get_name(zhp));
7137eda14cbcSMatt Macy 		return (1);
7138eda14cbcSMatt Macy 
7139eda14cbcSMatt Macy 	} else if (!zoned && getzoneid() != GLOBAL_ZONEID) {
7140eda14cbcSMatt Macy 		if (!explicit)
7141eda14cbcSMatt Macy 			return (0);
7142eda14cbcSMatt Macy 
7143eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("cannot %s '%s': "
7144eda14cbcSMatt Macy 		    "permission denied\n"), cmdname,
7145eda14cbcSMatt Macy 		    zfs_get_name(zhp));
7146eda14cbcSMatt Macy 		return (1);
7147eda14cbcSMatt Macy 	}
7148eda14cbcSMatt Macy 
7149eda14cbcSMatt Macy 	/*
7150eda14cbcSMatt Macy 	 * Ignore any filesystems which don't apply to us. This
7151eda14cbcSMatt Macy 	 * includes those with a legacy mountpoint, or those with
7152eda14cbcSMatt Macy 	 * legacy share options.
7153eda14cbcSMatt Macy 	 */
7154eda14cbcSMatt Macy 	verify(zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint,
7155eda14cbcSMatt Macy 	    sizeof (mountpoint), NULL, NULL, 0, B_FALSE) == 0);
7156eda14cbcSMatt Macy 	verify(zfs_prop_get(zhp, ZFS_PROP_SHARENFS, shareopts,
7157eda14cbcSMatt Macy 	    sizeof (shareopts), NULL, NULL, 0, B_FALSE) == 0);
7158eda14cbcSMatt Macy 	verify(zfs_prop_get(zhp, ZFS_PROP_SHARESMB, smbshareopts,
7159eda14cbcSMatt Macy 	    sizeof (smbshareopts), NULL, NULL, 0, B_FALSE) == 0);
7160eda14cbcSMatt Macy 
7161eda14cbcSMatt Macy 	if (op == OP_SHARE && strcmp(shareopts, "off") == 0 &&
7162eda14cbcSMatt Macy 	    strcmp(smbshareopts, "off") == 0) {
7163eda14cbcSMatt Macy 		if (!explicit)
7164eda14cbcSMatt Macy 			return (0);
7165eda14cbcSMatt Macy 
7166eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("cannot share '%s': "
7167eda14cbcSMatt Macy 		    "legacy share\n"), zfs_get_name(zhp));
71687877fdebSMatt Macy 		(void) fprintf(stderr, gettext("use exports(5) or "
71697877fdebSMatt Macy 		    "smb.conf(5) to share this filesystem, or set "
71707877fdebSMatt Macy 		    "the sharenfs or sharesmb property\n"));
7171eda14cbcSMatt Macy 		return (1);
7172eda14cbcSMatt Macy 	}
7173eda14cbcSMatt Macy 
7174eda14cbcSMatt Macy 	/*
7175eda14cbcSMatt Macy 	 * We cannot share or mount legacy filesystems. If the
7176eda14cbcSMatt Macy 	 * shareopts is non-legacy but the mountpoint is legacy, we
7177eda14cbcSMatt Macy 	 * treat it as a legacy share.
7178eda14cbcSMatt Macy 	 */
7179eda14cbcSMatt Macy 	if (strcmp(mountpoint, "legacy") == 0) {
7180eda14cbcSMatt Macy 		if (!explicit)
7181eda14cbcSMatt Macy 			return (0);
7182eda14cbcSMatt Macy 
7183eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("cannot %s '%s': "
7184eda14cbcSMatt Macy 		    "legacy mountpoint\n"), cmdname, zfs_get_name(zhp));
71857877fdebSMatt Macy 		(void) fprintf(stderr, gettext("use %s(8) to "
7186eda14cbcSMatt Macy 		    "%s this filesystem\n"), cmdname, cmdname);
7187eda14cbcSMatt Macy 		return (1);
7188eda14cbcSMatt Macy 	}
7189eda14cbcSMatt Macy 
7190eda14cbcSMatt Macy 	if (strcmp(mountpoint, "none") == 0) {
7191eda14cbcSMatt Macy 		if (!explicit)
7192eda14cbcSMatt Macy 			return (0);
7193eda14cbcSMatt Macy 
7194eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("cannot %s '%s': no "
7195eda14cbcSMatt Macy 		    "mountpoint set\n"), cmdname, zfs_get_name(zhp));
7196eda14cbcSMatt Macy 		return (1);
7197eda14cbcSMatt Macy 	}
7198eda14cbcSMatt Macy 
7199eda14cbcSMatt Macy 	/*
7200eda14cbcSMatt Macy 	 * canmount	explicit	outcome
7201eda14cbcSMatt Macy 	 * on		no		pass through
7202eda14cbcSMatt Macy 	 * on		yes		pass through
7203eda14cbcSMatt Macy 	 * off		no		return 0
7204eda14cbcSMatt Macy 	 * off		yes		display error, return 1
7205eda14cbcSMatt Macy 	 * noauto	no		return 0
7206eda14cbcSMatt Macy 	 * noauto	yes		pass through
7207eda14cbcSMatt Macy 	 */
7208eda14cbcSMatt Macy 	canmount = zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT);
7209eda14cbcSMatt Macy 	if (canmount == ZFS_CANMOUNT_OFF) {
7210eda14cbcSMatt Macy 		if (!explicit)
7211eda14cbcSMatt Macy 			return (0);
7212eda14cbcSMatt Macy 
7213eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("cannot %s '%s': "
7214eda14cbcSMatt Macy 		    "'canmount' property is set to 'off'\n"), cmdname,
7215eda14cbcSMatt Macy 		    zfs_get_name(zhp));
7216eda14cbcSMatt Macy 		return (1);
7217eda14cbcSMatt Macy 	} else if (canmount == ZFS_CANMOUNT_NOAUTO && !explicit) {
7218eda14cbcSMatt Macy 		/*
7219eda14cbcSMatt Macy 		 * When performing a 'zfs mount -a', we skip any mounts for
7220eda14cbcSMatt Macy 		 * datasets that have 'noauto' set. Sharing a dataset with
7221eda14cbcSMatt Macy 		 * 'noauto' set is only allowed if it's mounted.
7222eda14cbcSMatt Macy 		 */
7223eda14cbcSMatt Macy 		if (op == OP_MOUNT)
7224eda14cbcSMatt Macy 			return (0);
7225eda14cbcSMatt Macy 		if (op == OP_SHARE && !zfs_is_mounted(zhp, NULL)) {
7226eda14cbcSMatt Macy 			/* also purge it from existing exports */
7227716fd348SMartin Matuska 			zfs_unshare(zhp, mountpoint, NULL);
7228eda14cbcSMatt Macy 			return (0);
7229eda14cbcSMatt Macy 		}
7230eda14cbcSMatt Macy 	}
7231eda14cbcSMatt Macy 
7232eda14cbcSMatt Macy 	/*
7233eda14cbcSMatt Macy 	 * If this filesystem is encrypted and does not have
7234eda14cbcSMatt Macy 	 * a loaded key, we can not mount it.
7235eda14cbcSMatt Macy 	 */
7236eda14cbcSMatt Macy 	if ((flags & MS_CRYPT) == 0 &&
7237eda14cbcSMatt Macy 	    zfs_prop_get_int(zhp, ZFS_PROP_ENCRYPTION) != ZIO_CRYPT_OFF &&
7238eda14cbcSMatt Macy 	    zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS) ==
7239eda14cbcSMatt Macy 	    ZFS_KEYSTATUS_UNAVAILABLE) {
7240eda14cbcSMatt Macy 		if (!explicit)
7241eda14cbcSMatt Macy 			return (0);
7242eda14cbcSMatt Macy 
7243eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("cannot %s '%s': "
7244eda14cbcSMatt Macy 		    "encryption key not loaded\n"), cmdname, zfs_get_name(zhp));
7245eda14cbcSMatt Macy 		return (1);
7246eda14cbcSMatt Macy 	}
7247eda14cbcSMatt Macy 
7248eda14cbcSMatt Macy 	/*
7249eda14cbcSMatt Macy 	 * If this filesystem is inconsistent and has a receive resume
7250eda14cbcSMatt Macy 	 * token, we can not mount it.
7251eda14cbcSMatt Macy 	 */
7252eda14cbcSMatt Macy 	if (zfs_prop_get_int(zhp, ZFS_PROP_INCONSISTENT) &&
7253eda14cbcSMatt Macy 	    zfs_prop_get(zhp, ZFS_PROP_RECEIVE_RESUME_TOKEN,
7254eda14cbcSMatt Macy 	    NULL, 0, NULL, NULL, 0, B_TRUE) == 0) {
7255eda14cbcSMatt Macy 		if (!explicit)
7256eda14cbcSMatt Macy 			return (0);
7257eda14cbcSMatt Macy 
7258eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("cannot %s '%s': "
7259eda14cbcSMatt Macy 		    "Contains partially-completed state from "
7260eda14cbcSMatt Macy 		    "\"zfs receive -s\", which can be resumed with "
7261eda14cbcSMatt Macy 		    "\"zfs send -t\"\n"),
7262eda14cbcSMatt Macy 		    cmdname, zfs_get_name(zhp));
7263eda14cbcSMatt Macy 		return (1);
7264eda14cbcSMatt Macy 	}
7265eda14cbcSMatt Macy 
7266eda14cbcSMatt Macy 	if (zfs_prop_get_int(zhp, ZFS_PROP_REDACTED) && !(flags & MS_FORCE)) {
7267eda14cbcSMatt Macy 		if (!explicit)
7268eda14cbcSMatt Macy 			return (0);
7269eda14cbcSMatt Macy 
7270eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("cannot %s '%s': "
7271eda14cbcSMatt Macy 		    "Dataset is not complete, was created by receiving "
7272eda14cbcSMatt Macy 		    "a redacted zfs send stream.\n"), cmdname,
7273eda14cbcSMatt Macy 		    zfs_get_name(zhp));
7274eda14cbcSMatt Macy 		return (1);
7275eda14cbcSMatt Macy 	}
7276eda14cbcSMatt Macy 
7277eda14cbcSMatt Macy 	/*
7278eda14cbcSMatt Macy 	 * At this point, we have verified that the mountpoint and/or
7279eda14cbcSMatt Macy 	 * shareopts are appropriate for auto management. If the
7280eda14cbcSMatt Macy 	 * filesystem is already mounted or shared, return (failing
7281eda14cbcSMatt Macy 	 * for explicit requests); otherwise mount or share the
7282eda14cbcSMatt Macy 	 * filesystem.
7283eda14cbcSMatt Macy 	 */
7284eda14cbcSMatt Macy 	switch (op) {
7285716fd348SMartin Matuska 	case OP_SHARE: {
7286716fd348SMartin Matuska 		enum sa_protocol prot[] = {SA_PROTOCOL_NFS, SA_NO_PROTOCOL};
7287716fd348SMartin Matuska 		shared_nfs = zfs_is_shared(zhp, NULL, prot);
7288716fd348SMartin Matuska 		*prot = SA_PROTOCOL_SMB;
7289716fd348SMartin Matuska 		shared_smb = zfs_is_shared(zhp, NULL, prot);
7290eda14cbcSMatt Macy 
7291eda14cbcSMatt Macy 		if ((shared_nfs && shared_smb) ||
7292eda14cbcSMatt Macy 		    (shared_nfs && strcmp(shareopts, "on") == 0 &&
7293eda14cbcSMatt Macy 		    strcmp(smbshareopts, "off") == 0) ||
7294eda14cbcSMatt Macy 		    (shared_smb && strcmp(smbshareopts, "on") == 0 &&
7295eda14cbcSMatt Macy 		    strcmp(shareopts, "off") == 0)) {
7296eda14cbcSMatt Macy 			if (!explicit)
7297eda14cbcSMatt Macy 				return (0);
7298eda14cbcSMatt Macy 
7299eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("cannot share "
7300eda14cbcSMatt Macy 			    "'%s': filesystem already shared\n"),
7301eda14cbcSMatt Macy 			    zfs_get_name(zhp));
7302eda14cbcSMatt Macy 			return (1);
7303eda14cbcSMatt Macy 		}
7304eda14cbcSMatt Macy 
7305eda14cbcSMatt Macy 		if (!zfs_is_mounted(zhp, NULL) &&
7306eda14cbcSMatt Macy 		    zfs_mount(zhp, NULL, flags) != 0)
7307eda14cbcSMatt Macy 			return (1);
7308eda14cbcSMatt Macy 
7309716fd348SMartin Matuska 		*prot = protocol;
7310716fd348SMartin Matuska 		if (zfs_share(zhp, protocol == SA_NO_PROTOCOL ? NULL : prot))
7311eda14cbcSMatt Macy 			return (1);
7312eda14cbcSMatt Macy 
7313716fd348SMartin Matuska 	}
7314eda14cbcSMatt Macy 		break;
7315eda14cbcSMatt Macy 
7316eda14cbcSMatt Macy 	case OP_MOUNT:
7317a0b956f5SMartin Matuska 		mnt.mnt_mntopts = (char *)(options ?: "");
7318eda14cbcSMatt Macy 
7319eda14cbcSMatt Macy 		if (!hasmntopt(&mnt, MNTOPT_REMOUNT) &&
7320eda14cbcSMatt Macy 		    zfs_is_mounted(zhp, NULL)) {
7321eda14cbcSMatt Macy 			if (!explicit)
7322eda14cbcSMatt Macy 				return (0);
7323eda14cbcSMatt Macy 
7324eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("cannot mount "
7325eda14cbcSMatt Macy 			    "'%s': filesystem already mounted\n"),
7326eda14cbcSMatt Macy 			    zfs_get_name(zhp));
7327eda14cbcSMatt Macy 			return (1);
7328eda14cbcSMatt Macy 		}
7329eda14cbcSMatt Macy 
7330eda14cbcSMatt Macy 		if (zfs_mount(zhp, options, flags) != 0)
7331eda14cbcSMatt Macy 			return (1);
7332eda14cbcSMatt Macy 		break;
7333eda14cbcSMatt Macy 	}
7334eda14cbcSMatt Macy 
7335eda14cbcSMatt Macy 	return (0);
7336eda14cbcSMatt Macy }
7337eda14cbcSMatt Macy 
7338eda14cbcSMatt Macy /*
7339eda14cbcSMatt Macy  * Reports progress in the form "(current/total)".  Not thread-safe.
7340eda14cbcSMatt Macy  */
7341eda14cbcSMatt Macy static void
7342eda14cbcSMatt Macy report_mount_progress(int current, int total)
7343eda14cbcSMatt Macy {
7344eda14cbcSMatt Macy 	static time_t last_progress_time = 0;
7345eda14cbcSMatt Macy 	time_t now = time(NULL);
7346eda14cbcSMatt Macy 	char info[32];
7347eda14cbcSMatt Macy 
7348eda14cbcSMatt Macy 	/* display header if we're here for the first time */
7349eda14cbcSMatt Macy 	if (current == 1) {
7350eda14cbcSMatt Macy 		set_progress_header(gettext("Mounting ZFS filesystems"));
7351eda14cbcSMatt Macy 	} else if (current != total && last_progress_time + MOUNT_TIME >= now) {
7352eda14cbcSMatt Macy 		/* too soon to report again */
7353eda14cbcSMatt Macy 		return;
7354eda14cbcSMatt Macy 	}
7355eda14cbcSMatt Macy 
7356eda14cbcSMatt Macy 	last_progress_time = now;
7357eda14cbcSMatt Macy 
7358eda14cbcSMatt Macy 	(void) sprintf(info, "(%d/%d)", current, total);
7359eda14cbcSMatt Macy 
7360eda14cbcSMatt Macy 	if (current == total)
7361eda14cbcSMatt Macy 		finish_progress(info);
7362eda14cbcSMatt Macy 	else
7363eda14cbcSMatt Macy 		update_progress(info);
7364eda14cbcSMatt Macy }
7365eda14cbcSMatt Macy 
7366eda14cbcSMatt Macy /*
7367eda14cbcSMatt Macy  * zfs_foreach_mountpoint() callback that mounts or shares one filesystem and
7368eda14cbcSMatt Macy  * updates the progress meter.
7369eda14cbcSMatt Macy  */
7370eda14cbcSMatt Macy static int
7371eda14cbcSMatt Macy share_mount_one_cb(zfs_handle_t *zhp, void *arg)
7372eda14cbcSMatt Macy {
7373eda14cbcSMatt Macy 	share_mount_state_t *sms = arg;
7374eda14cbcSMatt Macy 	int ret;
7375eda14cbcSMatt Macy 
7376eda14cbcSMatt Macy 	ret = share_mount_one(zhp, sms->sm_op, sms->sm_flags, sms->sm_proto,
7377eda14cbcSMatt Macy 	    B_FALSE, sms->sm_options);
7378eda14cbcSMatt Macy 
7379eda14cbcSMatt Macy 	pthread_mutex_lock(&sms->sm_lock);
7380eda14cbcSMatt Macy 	if (ret != 0)
7381eda14cbcSMatt Macy 		sms->sm_status = ret;
7382eda14cbcSMatt Macy 	sms->sm_done++;
7383eda14cbcSMatt Macy 	if (sms->sm_verbose)
7384eda14cbcSMatt Macy 		report_mount_progress(sms->sm_done, sms->sm_total);
7385eda14cbcSMatt Macy 	pthread_mutex_unlock(&sms->sm_lock);
7386eda14cbcSMatt Macy 	return (ret);
7387eda14cbcSMatt Macy }
7388eda14cbcSMatt Macy 
7389eda14cbcSMatt Macy static void
7390eda14cbcSMatt Macy append_options(char *mntopts, char *newopts)
7391eda14cbcSMatt Macy {
7392eda14cbcSMatt Macy 	int len = strlen(mntopts);
7393eda14cbcSMatt Macy 
7394eda14cbcSMatt Macy 	/* original length plus new string to append plus 1 for the comma */
7395eda14cbcSMatt Macy 	if (len + 1 + strlen(newopts) >= MNT_LINE_MAX) {
7396eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("the opts argument for "
7397eda14cbcSMatt Macy 		    "'%s' option is too long (more than %d chars)\n"),
7398eda14cbcSMatt Macy 		    "-o", MNT_LINE_MAX);
7399eda14cbcSMatt Macy 		usage(B_FALSE);
7400eda14cbcSMatt Macy 	}
7401eda14cbcSMatt Macy 
7402eda14cbcSMatt Macy 	if (*mntopts)
7403eda14cbcSMatt Macy 		mntopts[len++] = ',';
7404eda14cbcSMatt Macy 
7405eda14cbcSMatt Macy 	(void) strcpy(&mntopts[len], newopts);
7406eda14cbcSMatt Macy }
7407eda14cbcSMatt Macy 
7408716fd348SMartin Matuska static enum sa_protocol
7409716fd348SMartin Matuska sa_protocol_decode(const char *protocol)
7410716fd348SMartin Matuska {
7411716fd348SMartin Matuska 	for (enum sa_protocol i = 0; i < ARRAY_SIZE(sa_protocol_names); ++i)
7412716fd348SMartin Matuska 		if (strcmp(protocol, sa_protocol_names[i]) == 0)
7413716fd348SMartin Matuska 			return (i);
7414716fd348SMartin Matuska 
7415716fd348SMartin Matuska 	(void) fputs(gettext("share type must be one of: "), stderr);
7416716fd348SMartin Matuska 	for (enum sa_protocol i = 0;
7417716fd348SMartin Matuska 	    i < ARRAY_SIZE(sa_protocol_names); ++i)
7418716fd348SMartin Matuska 		(void) fprintf(stderr, "%s%s",
7419716fd348SMartin Matuska 		    i != 0 ? ", " : "", sa_protocol_names[i]);
7420716fd348SMartin Matuska 	(void) fputc('\n', stderr);
7421716fd348SMartin Matuska 	usage(B_FALSE);
7422716fd348SMartin Matuska }
7423716fd348SMartin Matuska 
7424eda14cbcSMatt Macy static int
7425eda14cbcSMatt Macy share_mount(int op, int argc, char **argv)
7426eda14cbcSMatt Macy {
7427eda14cbcSMatt Macy 	int do_all = 0;
74281719886fSMartin Matuska 	int recursive = 0;
7429eda14cbcSMatt Macy 	boolean_t verbose = B_FALSE;
7430*ce4dcb97SMartin Matuska 	boolean_t json = B_FALSE;
7431eda14cbcSMatt Macy 	int c, ret = 0;
7432eda14cbcSMatt Macy 	char *options = NULL;
7433eda14cbcSMatt Macy 	int flags = 0;
7434*ce4dcb97SMartin Matuska 	nvlist_t *jsobj, *data, *item;
7435aca928a5SMartin Matuska 	const uint_t mount_nthr = 512;
7436aca928a5SMartin Matuska 	uint_t nthr;
7437*ce4dcb97SMartin Matuska 	jsobj = data = item = NULL;
7438eda14cbcSMatt Macy 
7439eda14cbcSMatt Macy 	/* check options */
7440*ce4dcb97SMartin Matuska 	while ((c = getopt(argc, argv, op == OP_MOUNT ? ":ajRlvo:Of" : "al"))
7441eda14cbcSMatt Macy 	    != -1) {
7442eda14cbcSMatt Macy 		switch (c) {
7443eda14cbcSMatt Macy 		case 'a':
7444eda14cbcSMatt Macy 			do_all = 1;
7445eda14cbcSMatt Macy 			break;
74461719886fSMartin Matuska 		case 'R':
74471719886fSMartin Matuska 			recursive = 1;
74481719886fSMartin Matuska 			break;
7449eda14cbcSMatt Macy 		case 'v':
7450eda14cbcSMatt Macy 			verbose = B_TRUE;
7451eda14cbcSMatt Macy 			break;
7452eda14cbcSMatt Macy 		case 'l':
7453eda14cbcSMatt Macy 			flags |= MS_CRYPT;
7454eda14cbcSMatt Macy 			break;
7455*ce4dcb97SMartin Matuska 		case 'j':
7456*ce4dcb97SMartin Matuska 			json = B_TRUE;
7457*ce4dcb97SMartin Matuska 			jsobj = zfs_json_schema(0, 1);
7458*ce4dcb97SMartin Matuska 			data = fnvlist_alloc();
7459*ce4dcb97SMartin Matuska 			break;
7460eda14cbcSMatt Macy 		case 'o':
7461eda14cbcSMatt Macy 			if (*optarg == '\0') {
7462eda14cbcSMatt Macy 				(void) fprintf(stderr, gettext("empty mount "
7463eda14cbcSMatt Macy 				    "options (-o) specified\n"));
7464eda14cbcSMatt Macy 				usage(B_FALSE);
7465eda14cbcSMatt Macy 			}
7466eda14cbcSMatt Macy 
7467eda14cbcSMatt Macy 			if (options == NULL)
7468eda14cbcSMatt Macy 				options = safe_malloc(MNT_LINE_MAX + 1);
7469eda14cbcSMatt Macy 
7470eda14cbcSMatt Macy 			/* option validation is done later */
7471eda14cbcSMatt Macy 			append_options(options, optarg);
7472eda14cbcSMatt Macy 			break;
7473eda14cbcSMatt Macy 		case 'O':
7474eda14cbcSMatt Macy 			flags |= MS_OVERLAY;
7475eda14cbcSMatt Macy 			break;
7476eda14cbcSMatt Macy 		case 'f':
7477eda14cbcSMatt Macy 			flags |= MS_FORCE;
7478eda14cbcSMatt Macy 			break;
7479eda14cbcSMatt Macy 		case ':':
7480eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("missing argument for "
7481eda14cbcSMatt Macy 			    "'%c' option\n"), optopt);
7482eda14cbcSMatt Macy 			usage(B_FALSE);
7483eda14cbcSMatt Macy 			break;
7484eda14cbcSMatt Macy 		case '?':
7485eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
7486eda14cbcSMatt Macy 			    optopt);
7487eda14cbcSMatt Macy 			usage(B_FALSE);
7488eda14cbcSMatt Macy 		}
7489eda14cbcSMatt Macy 	}
7490eda14cbcSMatt Macy 
7491eda14cbcSMatt Macy 	argc -= optind;
7492eda14cbcSMatt Macy 	argv += optind;
7493eda14cbcSMatt Macy 
7494*ce4dcb97SMartin Matuska 	if (json && argc != 0) {
7495*ce4dcb97SMartin Matuska 		(void) fprintf(stderr, gettext("too many arguments\n"));
7496*ce4dcb97SMartin Matuska 		usage(B_FALSE);
7497*ce4dcb97SMartin Matuska 	}
7498*ce4dcb97SMartin Matuska 
7499eda14cbcSMatt Macy 	/* check number of arguments */
75001719886fSMartin Matuska 	if (do_all || recursive) {
7501716fd348SMartin Matuska 		enum sa_protocol protocol = SA_NO_PROTOCOL;
7502eda14cbcSMatt Macy 
7503eda14cbcSMatt Macy 		if (op == OP_SHARE && argc > 0) {
7504716fd348SMartin Matuska 			protocol = sa_protocol_decode(argv[0]);
7505eda14cbcSMatt Macy 			argc--;
7506eda14cbcSMatt Macy 			argv++;
7507eda14cbcSMatt Macy 		}
7508eda14cbcSMatt Macy 
75091719886fSMartin Matuska 		if (argc != 0 && do_all) {
7510eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("too many arguments\n"));
7511eda14cbcSMatt Macy 			usage(B_FALSE);
7512eda14cbcSMatt Macy 		}
7513eda14cbcSMatt Macy 
75141719886fSMartin Matuska 		if (argc == 0 && recursive) {
75151719886fSMartin Matuska 			(void) fprintf(stderr,
75161719886fSMartin Matuska 			    gettext("no dataset provided\n"));
75171719886fSMartin Matuska 			usage(B_FALSE);
75181719886fSMartin Matuska 		}
75191719886fSMartin Matuska 
7520eda14cbcSMatt Macy 		start_progress_timer();
7521eda14cbcSMatt Macy 		get_all_cb_t cb = { 0 };
75221719886fSMartin Matuska 		get_all_state_t state = { 0 };
75231719886fSMartin Matuska 		if (argc == 0) {
75241719886fSMartin Matuska 			state.ga_datasets = NULL;
75251719886fSMartin Matuska 			state.ga_count = -1;
75261719886fSMartin Matuska 		} else {
75271719886fSMartin Matuska 			zfs_handle_t *zhp;
75281719886fSMartin Matuska 			for (int i = 0; i < argc; i++) {
75291719886fSMartin Matuska 				zhp = zfs_open(g_zfs, argv[i],
75301719886fSMartin Matuska 				    ZFS_TYPE_FILESYSTEM);
75311719886fSMartin Matuska 				if (zhp == NULL)
75321719886fSMartin Matuska 					usage(B_FALSE);
75331719886fSMartin Matuska 				zfs_close(zhp);
75341719886fSMartin Matuska 			}
75351719886fSMartin Matuska 			state.ga_datasets = argv;
75361719886fSMartin Matuska 			state.ga_count = argc;
75371719886fSMartin Matuska 		}
75381719886fSMartin Matuska 		state.ga_verbose = verbose;
75391719886fSMartin Matuska 		state.ga_cbp = &cb;
75401719886fSMartin Matuska 		get_all_datasets(&state);
7541eda14cbcSMatt Macy 
7542eda14cbcSMatt Macy 		if (cb.cb_used == 0) {
7543eda14cbcSMatt Macy 			free(options);
7544eda14cbcSMatt Macy 			return (0);
7545eda14cbcSMatt Macy 		}
7546eda14cbcSMatt Macy 
7547eda14cbcSMatt Macy 		share_mount_state_t share_mount_state = { 0 };
7548eda14cbcSMatt Macy 		share_mount_state.sm_op = op;
7549eda14cbcSMatt Macy 		share_mount_state.sm_verbose = verbose;
7550eda14cbcSMatt Macy 		share_mount_state.sm_flags = flags;
7551eda14cbcSMatt Macy 		share_mount_state.sm_options = options;
7552eda14cbcSMatt Macy 		share_mount_state.sm_proto = protocol;
7553eda14cbcSMatt Macy 		share_mount_state.sm_total = cb.cb_used;
7554eda14cbcSMatt Macy 		pthread_mutex_init(&share_mount_state.sm_lock, NULL);
7555eda14cbcSMatt Macy 
7556c7046f76SMartin Matuska 		/* For a 'zfs share -a' operation start with a clean slate. */
755778ae60b4SMartin Matuska 		if (op == OP_SHARE)
7558c7046f76SMartin Matuska 			zfs_truncate_shares(NULL);
7559c7046f76SMartin Matuska 
7560eda14cbcSMatt Macy 		/*
7561eda14cbcSMatt Macy 		 * libshare isn't mt-safe, so only do the operation in parallel
7562eda14cbcSMatt Macy 		 * if we're mounting. Additionally, the key-loading option must
7563eda14cbcSMatt Macy 		 * be serialized so that we can prompt the user for their keys
7564eda14cbcSMatt Macy 		 * in a consistent manner.
7565eda14cbcSMatt Macy 		 */
7566aca928a5SMartin Matuska 		nthr = op == OP_MOUNT && !(flags & MS_CRYPT) ? mount_nthr : 1;
7567eda14cbcSMatt Macy 		zfs_foreach_mountpoint(g_zfs, cb.cb_handles, cb.cb_used,
7568aca928a5SMartin Matuska 		    share_mount_one_cb, &share_mount_state, nthr);
7569716fd348SMartin Matuska 		zfs_commit_shares(NULL);
7570eda14cbcSMatt Macy 
7571eda14cbcSMatt Macy 		ret = share_mount_state.sm_status;
7572eda14cbcSMatt Macy 
7573eda14cbcSMatt Macy 		for (int i = 0; i < cb.cb_used; i++)
7574eda14cbcSMatt Macy 			zfs_close(cb.cb_handles[i]);
7575eda14cbcSMatt Macy 		free(cb.cb_handles);
7576eda14cbcSMatt Macy 	} else if (argc == 0) {
757716038816SMartin Matuska 		FILE *mnttab;
7578eda14cbcSMatt Macy 		struct mnttab entry;
7579eda14cbcSMatt Macy 
7580eda14cbcSMatt Macy 		if ((op == OP_SHARE) || (options != NULL)) {
7581eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("missing filesystem "
7582eda14cbcSMatt Macy 			    "argument (specify -a for all)\n"));
7583eda14cbcSMatt Macy 			usage(B_FALSE);
7584eda14cbcSMatt Macy 		}
7585eda14cbcSMatt Macy 
7586eda14cbcSMatt Macy 		/*
7587eda14cbcSMatt Macy 		 * When mount is given no arguments, go through
7588eda14cbcSMatt Macy 		 * /proc/self/mounts and display any active ZFS mounts.
7589eda14cbcSMatt Macy 		 * We hide any snapshots, since they are controlled
7590eda14cbcSMatt Macy 		 * automatically.
7591eda14cbcSMatt Macy 		 */
7592eda14cbcSMatt Macy 
759316038816SMartin Matuska 		if ((mnttab = fopen(MNTTAB, "re")) == NULL) {
7594eda14cbcSMatt Macy 			free(options);
7595eda14cbcSMatt Macy 			return (ENOENT);
7596eda14cbcSMatt Macy 		}
7597eda14cbcSMatt Macy 
759816038816SMartin Matuska 		while (getmntent(mnttab, &entry) == 0) {
7599eda14cbcSMatt Macy 			if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0 ||
7600eda14cbcSMatt Macy 			    strchr(entry.mnt_special, '@') != NULL)
7601eda14cbcSMatt Macy 				continue;
7602*ce4dcb97SMartin Matuska 			if (json) {
7603*ce4dcb97SMartin Matuska 				item = fnvlist_alloc();
7604*ce4dcb97SMartin Matuska 				fnvlist_add_string(item, "filesystem",
7605*ce4dcb97SMartin Matuska 				    entry.mnt_special);
7606*ce4dcb97SMartin Matuska 				fnvlist_add_string(item, "mountpoint",
7607*ce4dcb97SMartin Matuska 				    entry.mnt_mountp);
7608*ce4dcb97SMartin Matuska 				fnvlist_add_nvlist(data, entry.mnt_special,
7609*ce4dcb97SMartin Matuska 				    item);
7610*ce4dcb97SMartin Matuska 				fnvlist_free(item);
7611*ce4dcb97SMartin Matuska 			} else {
7612eda14cbcSMatt Macy 				(void) printf("%-30s  %s\n", entry.mnt_special,
7613eda14cbcSMatt Macy 				    entry.mnt_mountp);
7614eda14cbcSMatt Macy 			}
7615*ce4dcb97SMartin Matuska 		}
7616eda14cbcSMatt Macy 
761716038816SMartin Matuska 		(void) fclose(mnttab);
7618*ce4dcb97SMartin Matuska 		if (json) {
7619*ce4dcb97SMartin Matuska 			fnvlist_add_nvlist(jsobj, "datasets", data);
7620*ce4dcb97SMartin Matuska 			if (nvlist_empty(data))
7621*ce4dcb97SMartin Matuska 				fnvlist_free(jsobj);
7622*ce4dcb97SMartin Matuska 			else
7623*ce4dcb97SMartin Matuska 				zcmd_print_json(jsobj);
7624*ce4dcb97SMartin Matuska 			fnvlist_free(data);
7625*ce4dcb97SMartin Matuska 		}
7626eda14cbcSMatt Macy 	} else {
7627eda14cbcSMatt Macy 		zfs_handle_t *zhp;
7628eda14cbcSMatt Macy 
7629eda14cbcSMatt Macy 		if (argc > 1) {
7630eda14cbcSMatt Macy 			(void) fprintf(stderr,
7631eda14cbcSMatt Macy 			    gettext("too many arguments\n"));
7632eda14cbcSMatt Macy 			usage(B_FALSE);
7633eda14cbcSMatt Macy 		}
7634eda14cbcSMatt Macy 
7635eda14cbcSMatt Macy 		if ((zhp = zfs_open(g_zfs, argv[0],
7636eda14cbcSMatt Macy 		    ZFS_TYPE_FILESYSTEM)) == NULL) {
7637eda14cbcSMatt Macy 			ret = 1;
7638eda14cbcSMatt Macy 		} else {
7639716fd348SMartin Matuska 			ret = share_mount_one(zhp, op, flags, SA_NO_PROTOCOL,
7640716fd348SMartin Matuska 			    B_TRUE, options);
7641716fd348SMartin Matuska 			zfs_commit_shares(NULL);
7642eda14cbcSMatt Macy 			zfs_close(zhp);
7643eda14cbcSMatt Macy 		}
7644eda14cbcSMatt Macy 	}
7645eda14cbcSMatt Macy 
7646eda14cbcSMatt Macy 	free(options);
7647eda14cbcSMatt Macy 	return (ret);
7648eda14cbcSMatt Macy }
7649eda14cbcSMatt Macy 
7650eda14cbcSMatt Macy /*
7651716fd348SMartin Matuska  * zfs mount -a
7652eda14cbcSMatt Macy  * zfs mount filesystem
7653eda14cbcSMatt Macy  *
7654eda14cbcSMatt Macy  * Mount all filesystems, or mount the given filesystem.
7655eda14cbcSMatt Macy  */
7656eda14cbcSMatt Macy static int
7657eda14cbcSMatt Macy zfs_do_mount(int argc, char **argv)
7658eda14cbcSMatt Macy {
7659eda14cbcSMatt Macy 	return (share_mount(OP_MOUNT, argc, argv));
7660eda14cbcSMatt Macy }
7661eda14cbcSMatt Macy 
7662eda14cbcSMatt Macy /*
7663eda14cbcSMatt Macy  * zfs share -a [nfs | smb]
7664eda14cbcSMatt Macy  * zfs share filesystem
7665eda14cbcSMatt Macy  *
7666eda14cbcSMatt Macy  * Share all filesystems, or share the given filesystem.
7667eda14cbcSMatt Macy  */
7668eda14cbcSMatt Macy static int
7669eda14cbcSMatt Macy zfs_do_share(int argc, char **argv)
7670eda14cbcSMatt Macy {
7671eda14cbcSMatt Macy 	return (share_mount(OP_SHARE, argc, argv));
7672eda14cbcSMatt Macy }
7673eda14cbcSMatt Macy 
7674eda14cbcSMatt Macy typedef struct unshare_unmount_node {
7675eda14cbcSMatt Macy 	zfs_handle_t	*un_zhp;
7676eda14cbcSMatt Macy 	char		*un_mountp;
7677eda14cbcSMatt Macy 	uu_avl_node_t	un_avlnode;
7678eda14cbcSMatt Macy } unshare_unmount_node_t;
7679eda14cbcSMatt Macy 
7680eda14cbcSMatt Macy static int
7681eda14cbcSMatt Macy unshare_unmount_compare(const void *larg, const void *rarg, void *unused)
7682eda14cbcSMatt Macy {
7683681ce946SMartin Matuska 	(void) unused;
7684eda14cbcSMatt Macy 	const unshare_unmount_node_t *l = larg;
7685eda14cbcSMatt Macy 	const unshare_unmount_node_t *r = rarg;
7686eda14cbcSMatt Macy 
7687eda14cbcSMatt Macy 	return (strcmp(l->un_mountp, r->un_mountp));
7688eda14cbcSMatt Macy }
7689eda14cbcSMatt Macy 
7690eda14cbcSMatt Macy /*
7691eda14cbcSMatt Macy  * Convenience routine used by zfs_do_umount() and manual_unmount().  Given an
7692eda14cbcSMatt Macy  * absolute path, find the entry /proc/self/mounts, verify that it's a
7693eda14cbcSMatt Macy  * ZFS filesystem, and unmount it appropriately.
7694eda14cbcSMatt Macy  */
7695eda14cbcSMatt Macy static int
7696eda14cbcSMatt Macy unshare_unmount_path(int op, char *path, int flags, boolean_t is_manual)
7697eda14cbcSMatt Macy {
7698eda14cbcSMatt Macy 	zfs_handle_t *zhp;
7699eda14cbcSMatt Macy 	int ret = 0;
7700eda14cbcSMatt Macy 	struct stat64 statbuf;
7701eda14cbcSMatt Macy 	struct extmnttab entry;
7702eda14cbcSMatt Macy 	const char *cmdname = (op == OP_SHARE) ? "unshare" : "unmount";
7703eda14cbcSMatt Macy 	ino_t path_inode;
7704eda14cbcSMatt Macy 
7705eda14cbcSMatt Macy 	/*
7706eda14cbcSMatt Macy 	 * Search for the given (major,minor) pair in the mount table.
7707eda14cbcSMatt Macy 	 */
7708eda14cbcSMatt Macy 
7709eda14cbcSMatt Macy 	if (getextmntent(path, &entry, &statbuf) != 0) {
7710eda14cbcSMatt Macy 		if (op == OP_SHARE) {
7711eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("cannot %s '%s': not "
7712eda14cbcSMatt Macy 			    "currently mounted\n"), cmdname, path);
7713eda14cbcSMatt Macy 			return (1);
7714eda14cbcSMatt Macy 		}
7715eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("warning: %s not in"
7716eda14cbcSMatt Macy 		    "/proc/self/mounts\n"), path);
7717eda14cbcSMatt Macy 		if ((ret = umount2(path, flags)) != 0)
7718eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("%s: %s\n"), path,
7719eda14cbcSMatt Macy 			    strerror(errno));
7720eda14cbcSMatt Macy 		return (ret != 0);
7721eda14cbcSMatt Macy 	}
7722eda14cbcSMatt Macy 	path_inode = statbuf.st_ino;
7723eda14cbcSMatt Macy 
7724eda14cbcSMatt Macy 	if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0) {
7725eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("cannot %s '%s': not a ZFS "
7726eda14cbcSMatt Macy 		    "filesystem\n"), cmdname, path);
7727eda14cbcSMatt Macy 		return (1);
7728eda14cbcSMatt Macy 	}
7729eda14cbcSMatt Macy 
7730eda14cbcSMatt Macy 	if ((zhp = zfs_open(g_zfs, entry.mnt_special,
7731eda14cbcSMatt Macy 	    ZFS_TYPE_FILESYSTEM)) == NULL)
7732eda14cbcSMatt Macy 		return (1);
7733eda14cbcSMatt Macy 
7734eda14cbcSMatt Macy 	ret = 1;
7735eda14cbcSMatt Macy 	if (stat64(entry.mnt_mountp, &statbuf) != 0) {
7736eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("cannot %s '%s': %s\n"),
7737eda14cbcSMatt Macy 		    cmdname, path, strerror(errno));
7738eda14cbcSMatt Macy 		goto out;
7739eda14cbcSMatt Macy 	} else if (statbuf.st_ino != path_inode) {
7740eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("cannot "
7741eda14cbcSMatt Macy 		    "%s '%s': not a mountpoint\n"), cmdname, path);
7742eda14cbcSMatt Macy 		goto out;
7743eda14cbcSMatt Macy 	}
7744eda14cbcSMatt Macy 
7745eda14cbcSMatt Macy 	if (op == OP_SHARE) {
7746eda14cbcSMatt Macy 		char nfs_mnt_prop[ZFS_MAXPROPLEN];
7747eda14cbcSMatt Macy 		char smbshare_prop[ZFS_MAXPROPLEN];
7748eda14cbcSMatt Macy 
7749eda14cbcSMatt Macy 		verify(zfs_prop_get(zhp, ZFS_PROP_SHARENFS, nfs_mnt_prop,
7750eda14cbcSMatt Macy 		    sizeof (nfs_mnt_prop), NULL, NULL, 0, B_FALSE) == 0);
7751eda14cbcSMatt Macy 		verify(zfs_prop_get(zhp, ZFS_PROP_SHARESMB, smbshare_prop,
7752eda14cbcSMatt Macy 		    sizeof (smbshare_prop), NULL, NULL, 0, B_FALSE) == 0);
7753eda14cbcSMatt Macy 
7754eda14cbcSMatt Macy 		if (strcmp(nfs_mnt_prop, "off") == 0 &&
7755eda14cbcSMatt Macy 		    strcmp(smbshare_prop, "off") == 0) {
7756eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("cannot unshare "
7757eda14cbcSMatt Macy 			    "'%s': legacy share\n"), path);
7758eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("use exportfs(8) "
7759eda14cbcSMatt Macy 			    "or smbcontrol(1) to unshare this filesystem\n"));
7760716fd348SMartin Matuska 		} else if (!zfs_is_shared(zhp, NULL, NULL)) {
7761eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("cannot unshare '%s': "
7762eda14cbcSMatt Macy 			    "not currently shared\n"), path);
7763eda14cbcSMatt Macy 		} else {
7764716fd348SMartin Matuska 			ret = zfs_unshare(zhp, path, NULL);
7765716fd348SMartin Matuska 			zfs_commit_shares(NULL);
7766eda14cbcSMatt Macy 		}
7767eda14cbcSMatt Macy 	} else {
7768eda14cbcSMatt Macy 		char mtpt_prop[ZFS_MAXPROPLEN];
7769eda14cbcSMatt Macy 
7770eda14cbcSMatt Macy 		verify(zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mtpt_prop,
7771eda14cbcSMatt Macy 		    sizeof (mtpt_prop), NULL, NULL, 0, B_FALSE) == 0);
7772eda14cbcSMatt Macy 
7773eda14cbcSMatt Macy 		if (is_manual) {
7774eda14cbcSMatt Macy 			ret = zfs_unmount(zhp, NULL, flags);
7775eda14cbcSMatt Macy 		} else if (strcmp(mtpt_prop, "legacy") == 0) {
7776eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("cannot unmount "
7777eda14cbcSMatt Macy 			    "'%s': legacy mountpoint\n"),
7778eda14cbcSMatt Macy 			    zfs_get_name(zhp));
7779eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("use umount(8) "
7780eda14cbcSMatt Macy 			    "to unmount this filesystem\n"));
7781eda14cbcSMatt Macy 		} else {
7782eda14cbcSMatt Macy 			ret = zfs_unmountall(zhp, flags);
7783eda14cbcSMatt Macy 		}
7784eda14cbcSMatt Macy 	}
7785eda14cbcSMatt Macy 
7786eda14cbcSMatt Macy out:
7787eda14cbcSMatt Macy 	zfs_close(zhp);
7788eda14cbcSMatt Macy 
7789eda14cbcSMatt Macy 	return (ret != 0);
7790eda14cbcSMatt Macy }
7791eda14cbcSMatt Macy 
7792eda14cbcSMatt Macy /*
7793eda14cbcSMatt Macy  * Generic callback for unsharing or unmounting a filesystem.
7794eda14cbcSMatt Macy  */
7795eda14cbcSMatt Macy static int
7796eda14cbcSMatt Macy unshare_unmount(int op, int argc, char **argv)
7797eda14cbcSMatt Macy {
7798eda14cbcSMatt Macy 	int do_all = 0;
7799eda14cbcSMatt Macy 	int flags = 0;
7800eda14cbcSMatt Macy 	int ret = 0;
7801eda14cbcSMatt Macy 	int c;
7802eda14cbcSMatt Macy 	zfs_handle_t *zhp;
7803eda14cbcSMatt Macy 	char nfs_mnt_prop[ZFS_MAXPROPLEN];
7804eda14cbcSMatt Macy 	char sharesmb[ZFS_MAXPROPLEN];
7805eda14cbcSMatt Macy 
7806eda14cbcSMatt Macy 	/* check options */
7807eda14cbcSMatt Macy 	while ((c = getopt(argc, argv, op == OP_SHARE ? ":a" : "afu")) != -1) {
7808eda14cbcSMatt Macy 		switch (c) {
7809eda14cbcSMatt Macy 		case 'a':
7810eda14cbcSMatt Macy 			do_all = 1;
7811eda14cbcSMatt Macy 			break;
7812eda14cbcSMatt Macy 		case 'f':
7813eda14cbcSMatt Macy 			flags |= MS_FORCE;
7814eda14cbcSMatt Macy 			break;
7815eda14cbcSMatt Macy 		case 'u':
7816eda14cbcSMatt Macy 			flags |= MS_CRYPT;
7817eda14cbcSMatt Macy 			break;
7818eda14cbcSMatt Macy 		case ':':
7819eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("missing argument for "
7820eda14cbcSMatt Macy 			    "'%c' option\n"), optopt);
7821eda14cbcSMatt Macy 			usage(B_FALSE);
7822eda14cbcSMatt Macy 			break;
7823eda14cbcSMatt Macy 		case '?':
7824eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
7825eda14cbcSMatt Macy 			    optopt);
7826eda14cbcSMatt Macy 			usage(B_FALSE);
7827eda14cbcSMatt Macy 		}
7828eda14cbcSMatt Macy 	}
7829eda14cbcSMatt Macy 
7830eda14cbcSMatt Macy 	argc -= optind;
7831eda14cbcSMatt Macy 	argv += optind;
7832eda14cbcSMatt Macy 
7833eda14cbcSMatt Macy 	if (do_all) {
7834eda14cbcSMatt Macy 		/*
7835eda14cbcSMatt Macy 		 * We could make use of zfs_for_each() to walk all datasets in
7836eda14cbcSMatt Macy 		 * the system, but this would be very inefficient, especially
7837eda14cbcSMatt Macy 		 * since we would have to linearly search /proc/self/mounts for
7838eda14cbcSMatt Macy 		 * each one. Instead, do one pass through /proc/self/mounts
7839eda14cbcSMatt Macy 		 * looking for zfs entries and call zfs_unmount() for each one.
7840eda14cbcSMatt Macy 		 *
7841eda14cbcSMatt Macy 		 * Things get a little tricky if the administrator has created
7842eda14cbcSMatt Macy 		 * mountpoints beneath other ZFS filesystems.  In this case, we
7843eda14cbcSMatt Macy 		 * have to unmount the deepest filesystems first.  To accomplish
7844eda14cbcSMatt Macy 		 * this, we place all the mountpoints in an AVL tree sorted by
7845eda14cbcSMatt Macy 		 * the special type (dataset name), and walk the result in
7846eda14cbcSMatt Macy 		 * reverse to make sure to get any snapshots first.
7847eda14cbcSMatt Macy 		 */
784816038816SMartin Matuska 		FILE *mnttab;
7849eda14cbcSMatt Macy 		struct mnttab entry;
7850eda14cbcSMatt Macy 		uu_avl_pool_t *pool;
7851eda14cbcSMatt Macy 		uu_avl_t *tree = NULL;
7852eda14cbcSMatt Macy 		unshare_unmount_node_t *node;
7853eda14cbcSMatt Macy 		uu_avl_index_t idx;
7854eda14cbcSMatt Macy 		uu_avl_walk_t *walk;
7855716fd348SMartin Matuska 		enum sa_protocol *protocol = NULL,
7856716fd348SMartin Matuska 		    single_protocol[] = {SA_NO_PROTOCOL, SA_NO_PROTOCOL};
7857eda14cbcSMatt Macy 
7858eda14cbcSMatt Macy 		if (op == OP_SHARE && argc > 0) {
7859716fd348SMartin Matuska 			*single_protocol = sa_protocol_decode(argv[0]);
7860716fd348SMartin Matuska 			protocol = single_protocol;
7861eda14cbcSMatt Macy 			argc--;
7862eda14cbcSMatt Macy 			argv++;
7863eda14cbcSMatt Macy 		}
7864eda14cbcSMatt Macy 
7865eda14cbcSMatt Macy 		if (argc != 0) {
7866eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("too many arguments\n"));
7867eda14cbcSMatt Macy 			usage(B_FALSE);
7868eda14cbcSMatt Macy 		}
7869eda14cbcSMatt Macy 
7870eda14cbcSMatt Macy 		if (((pool = uu_avl_pool_create("unmount_pool",
7871eda14cbcSMatt Macy 		    sizeof (unshare_unmount_node_t),
7872eda14cbcSMatt Macy 		    offsetof(unshare_unmount_node_t, un_avlnode),
7873eda14cbcSMatt Macy 		    unshare_unmount_compare, UU_DEFAULT)) == NULL) ||
7874eda14cbcSMatt Macy 		    ((tree = uu_avl_create(pool, NULL, UU_DEFAULT)) == NULL))
7875eda14cbcSMatt Macy 			nomem();
7876eda14cbcSMatt Macy 
7877be181ee2SMartin Matuska 		if ((mnttab = fopen(MNTTAB, "re")) == NULL) {
7878be181ee2SMartin Matuska 			uu_avl_destroy(tree);
7879be181ee2SMartin Matuska 			uu_avl_pool_destroy(pool);
7880eda14cbcSMatt Macy 			return (ENOENT);
7881be181ee2SMartin Matuska 		}
7882eda14cbcSMatt Macy 
788316038816SMartin Matuska 		while (getmntent(mnttab, &entry) == 0) {
7884eda14cbcSMatt Macy 
7885eda14cbcSMatt Macy 			/* ignore non-ZFS entries */
7886eda14cbcSMatt Macy 			if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0)
7887eda14cbcSMatt Macy 				continue;
7888eda14cbcSMatt Macy 
7889eda14cbcSMatt Macy 			/* ignore snapshots */
7890eda14cbcSMatt Macy 			if (strchr(entry.mnt_special, '@') != NULL)
7891eda14cbcSMatt Macy 				continue;
7892eda14cbcSMatt Macy 
7893eda14cbcSMatt Macy 			if ((zhp = zfs_open(g_zfs, entry.mnt_special,
7894eda14cbcSMatt Macy 			    ZFS_TYPE_FILESYSTEM)) == NULL) {
7895eda14cbcSMatt Macy 				ret = 1;
7896eda14cbcSMatt Macy 				continue;
7897eda14cbcSMatt Macy 			}
7898eda14cbcSMatt Macy 
7899eda14cbcSMatt Macy 			/*
7900eda14cbcSMatt Macy 			 * Ignore datasets that are excluded/restricted by
7901eda14cbcSMatt Macy 			 * parent pool name.
7902eda14cbcSMatt Macy 			 */
7903eda14cbcSMatt Macy 			if (zpool_skip_pool(zfs_get_pool_name(zhp))) {
7904eda14cbcSMatt Macy 				zfs_close(zhp);
7905eda14cbcSMatt Macy 				continue;
7906eda14cbcSMatt Macy 			}
7907eda14cbcSMatt Macy 
7908eda14cbcSMatt Macy 			switch (op) {
7909eda14cbcSMatt Macy 			case OP_SHARE:
7910eda14cbcSMatt Macy 				verify(zfs_prop_get(zhp, ZFS_PROP_SHARENFS,
7911eda14cbcSMatt Macy 				    nfs_mnt_prop,
7912eda14cbcSMatt Macy 				    sizeof (nfs_mnt_prop),
7913eda14cbcSMatt Macy 				    NULL, NULL, 0, B_FALSE) == 0);
7914eda14cbcSMatt Macy 				if (strcmp(nfs_mnt_prop, "off") != 0)
7915eda14cbcSMatt Macy 					break;
7916eda14cbcSMatt Macy 				verify(zfs_prop_get(zhp, ZFS_PROP_SHARESMB,
7917eda14cbcSMatt Macy 				    nfs_mnt_prop,
7918eda14cbcSMatt Macy 				    sizeof (nfs_mnt_prop),
7919eda14cbcSMatt Macy 				    NULL, NULL, 0, B_FALSE) == 0);
7920eda14cbcSMatt Macy 				if (strcmp(nfs_mnt_prop, "off") == 0)
7921eda14cbcSMatt Macy 					continue;
7922eda14cbcSMatt Macy 				break;
7923eda14cbcSMatt Macy 			case OP_MOUNT:
7924eda14cbcSMatt Macy 				/* Ignore legacy mounts */
7925eda14cbcSMatt Macy 				verify(zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT,
7926eda14cbcSMatt Macy 				    nfs_mnt_prop,
7927eda14cbcSMatt Macy 				    sizeof (nfs_mnt_prop),
7928eda14cbcSMatt Macy 				    NULL, NULL, 0, B_FALSE) == 0);
7929eda14cbcSMatt Macy 				if (strcmp(nfs_mnt_prop, "legacy") == 0)
7930eda14cbcSMatt Macy 					continue;
7931eda14cbcSMatt Macy 				/* Ignore canmount=noauto mounts */
7932eda14cbcSMatt Macy 				if (zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT) ==
7933eda14cbcSMatt Macy 				    ZFS_CANMOUNT_NOAUTO)
7934eda14cbcSMatt Macy 					continue;
793553b70c86SMartin Matuska 				break;
7936eda14cbcSMatt Macy 			default:
7937eda14cbcSMatt Macy 				break;
7938eda14cbcSMatt Macy 			}
7939eda14cbcSMatt Macy 
7940eda14cbcSMatt Macy 			node = safe_malloc(sizeof (unshare_unmount_node_t));
7941eda14cbcSMatt Macy 			node->un_zhp = zhp;
7942eda14cbcSMatt Macy 			node->un_mountp = safe_strdup(entry.mnt_mountp);
7943eda14cbcSMatt Macy 
7944eda14cbcSMatt Macy 			uu_avl_node_init(node, &node->un_avlnode, pool);
7945eda14cbcSMatt Macy 
7946eda14cbcSMatt Macy 			if (uu_avl_find(tree, node, NULL, &idx) == NULL) {
7947eda14cbcSMatt Macy 				uu_avl_insert(tree, node, idx);
7948eda14cbcSMatt Macy 			} else {
7949eda14cbcSMatt Macy 				zfs_close(node->un_zhp);
7950eda14cbcSMatt Macy 				free(node->un_mountp);
7951eda14cbcSMatt Macy 				free(node);
7952eda14cbcSMatt Macy 			}
7953eda14cbcSMatt Macy 		}
795416038816SMartin Matuska 		(void) fclose(mnttab);
7955eda14cbcSMatt Macy 
7956eda14cbcSMatt Macy 		/*
7957eda14cbcSMatt Macy 		 * Walk the AVL tree in reverse, unmounting each filesystem and
7958eda14cbcSMatt Macy 		 * removing it from the AVL tree in the process.
7959eda14cbcSMatt Macy 		 */
7960eda14cbcSMatt Macy 		if ((walk = uu_avl_walk_start(tree,
7961eda14cbcSMatt Macy 		    UU_WALK_REVERSE | UU_WALK_ROBUST)) == NULL)
7962eda14cbcSMatt Macy 			nomem();
7963eda14cbcSMatt Macy 
7964eda14cbcSMatt Macy 		while ((node = uu_avl_walk_next(walk)) != NULL) {
7965eda14cbcSMatt Macy 			const char *mntarg = NULL;
7966eda14cbcSMatt Macy 
7967eda14cbcSMatt Macy 			uu_avl_remove(tree, node);
7968eda14cbcSMatt Macy 			switch (op) {
7969eda14cbcSMatt Macy 			case OP_SHARE:
7970716fd348SMartin Matuska 				if (zfs_unshare(node->un_zhp,
7971eda14cbcSMatt Macy 				    node->un_mountp, protocol) != 0)
7972eda14cbcSMatt Macy 					ret = 1;
7973eda14cbcSMatt Macy 				break;
7974eda14cbcSMatt Macy 
7975eda14cbcSMatt Macy 			case OP_MOUNT:
7976eda14cbcSMatt Macy 				if (zfs_unmount(node->un_zhp,
7977eda14cbcSMatt Macy 				    mntarg, flags) != 0)
7978eda14cbcSMatt Macy 					ret = 1;
7979eda14cbcSMatt Macy 				break;
7980eda14cbcSMatt Macy 			}
7981eda14cbcSMatt Macy 
7982eda14cbcSMatt Macy 			zfs_close(node->un_zhp);
7983eda14cbcSMatt Macy 			free(node->un_mountp);
7984eda14cbcSMatt Macy 			free(node);
7985eda14cbcSMatt Macy 		}
7986eda14cbcSMatt Macy 
7987eda14cbcSMatt Macy 		if (op == OP_SHARE)
7988eda14cbcSMatt Macy 			zfs_commit_shares(protocol);
7989eda14cbcSMatt Macy 
7990eda14cbcSMatt Macy 		uu_avl_walk_end(walk);
7991eda14cbcSMatt Macy 		uu_avl_destroy(tree);
7992eda14cbcSMatt Macy 		uu_avl_pool_destroy(pool);
7993eda14cbcSMatt Macy 
7994eda14cbcSMatt Macy 	} else {
7995eda14cbcSMatt Macy 		if (argc != 1) {
7996eda14cbcSMatt Macy 			if (argc == 0)
7997eda14cbcSMatt Macy 				(void) fprintf(stderr,
7998eda14cbcSMatt Macy 				    gettext("missing filesystem argument\n"));
7999eda14cbcSMatt Macy 			else
8000eda14cbcSMatt Macy 				(void) fprintf(stderr,
8001eda14cbcSMatt Macy 				    gettext("too many arguments\n"));
8002eda14cbcSMatt Macy 			usage(B_FALSE);
8003eda14cbcSMatt Macy 		}
8004eda14cbcSMatt Macy 
8005eda14cbcSMatt Macy 		/*
8006eda14cbcSMatt Macy 		 * We have an argument, but it may be a full path or a ZFS
8007eda14cbcSMatt Macy 		 * filesystem.  Pass full paths off to unmount_path() (shared by
8008eda14cbcSMatt Macy 		 * manual_unmount), otherwise open the filesystem and pass to
8009eda14cbcSMatt Macy 		 * zfs_unmount().
8010eda14cbcSMatt Macy 		 */
8011eda14cbcSMatt Macy 		if (argv[0][0] == '/')
8012eda14cbcSMatt Macy 			return (unshare_unmount_path(op, argv[0],
8013eda14cbcSMatt Macy 			    flags, B_FALSE));
8014eda14cbcSMatt Macy 
8015eda14cbcSMatt Macy 		if ((zhp = zfs_open(g_zfs, argv[0],
8016eda14cbcSMatt Macy 		    ZFS_TYPE_FILESYSTEM)) == NULL)
8017eda14cbcSMatt Macy 			return (1);
8018eda14cbcSMatt Macy 
8019eda14cbcSMatt Macy 		verify(zfs_prop_get(zhp, op == OP_SHARE ?
8020eda14cbcSMatt Macy 		    ZFS_PROP_SHARENFS : ZFS_PROP_MOUNTPOINT,
8021eda14cbcSMatt Macy 		    nfs_mnt_prop, sizeof (nfs_mnt_prop), NULL,
8022eda14cbcSMatt Macy 		    NULL, 0, B_FALSE) == 0);
8023eda14cbcSMatt Macy 
8024eda14cbcSMatt Macy 		switch (op) {
8025eda14cbcSMatt Macy 		case OP_SHARE:
8026eda14cbcSMatt Macy 			verify(zfs_prop_get(zhp, ZFS_PROP_SHARENFS,
8027eda14cbcSMatt Macy 			    nfs_mnt_prop,
8028eda14cbcSMatt Macy 			    sizeof (nfs_mnt_prop),
8029eda14cbcSMatt Macy 			    NULL, NULL, 0, B_FALSE) == 0);
8030eda14cbcSMatt Macy 			verify(zfs_prop_get(zhp, ZFS_PROP_SHARESMB,
8031eda14cbcSMatt Macy 			    sharesmb, sizeof (sharesmb), NULL, NULL,
8032eda14cbcSMatt Macy 			    0, B_FALSE) == 0);
8033eda14cbcSMatt Macy 
8034eda14cbcSMatt Macy 			if (strcmp(nfs_mnt_prop, "off") == 0 &&
8035eda14cbcSMatt Macy 			    strcmp(sharesmb, "off") == 0) {
8036eda14cbcSMatt Macy 				(void) fprintf(stderr, gettext("cannot "
8037eda14cbcSMatt Macy 				    "unshare '%s': legacy share\n"),
8038eda14cbcSMatt Macy 				    zfs_get_name(zhp));
8039eda14cbcSMatt Macy 				(void) fprintf(stderr, gettext("use "
80407877fdebSMatt Macy 				    "exports(5) or smb.conf(5) to unshare "
80417877fdebSMatt Macy 				    "this filesystem\n"));
8042eda14cbcSMatt Macy 				ret = 1;
8043716fd348SMartin Matuska 			} else if (!zfs_is_shared(zhp, NULL, NULL)) {
8044eda14cbcSMatt Macy 				(void) fprintf(stderr, gettext("cannot "
8045eda14cbcSMatt Macy 				    "unshare '%s': not currently "
8046eda14cbcSMatt Macy 				    "shared\n"), zfs_get_name(zhp));
8047eda14cbcSMatt Macy 				ret = 1;
8048716fd348SMartin Matuska 			} else if (zfs_unshareall(zhp, NULL) != 0) {
8049eda14cbcSMatt Macy 				ret = 1;
8050eda14cbcSMatt Macy 			}
8051eda14cbcSMatt Macy 			break;
8052eda14cbcSMatt Macy 
8053eda14cbcSMatt Macy 		case OP_MOUNT:
8054eda14cbcSMatt Macy 			if (strcmp(nfs_mnt_prop, "legacy") == 0) {
8055eda14cbcSMatt Macy 				(void) fprintf(stderr, gettext("cannot "
8056eda14cbcSMatt Macy 				    "unmount '%s': legacy "
8057eda14cbcSMatt Macy 				    "mountpoint\n"), zfs_get_name(zhp));
8058eda14cbcSMatt Macy 				(void) fprintf(stderr, gettext("use "
80597877fdebSMatt Macy 				    "umount(8) to unmount this "
8060eda14cbcSMatt Macy 				    "filesystem\n"));
8061eda14cbcSMatt Macy 				ret = 1;
8062eda14cbcSMatt Macy 			} else if (!zfs_is_mounted(zhp, NULL)) {
8063eda14cbcSMatt Macy 				(void) fprintf(stderr, gettext("cannot "
8064eda14cbcSMatt Macy 				    "unmount '%s': not currently "
8065eda14cbcSMatt Macy 				    "mounted\n"),
8066eda14cbcSMatt Macy 				    zfs_get_name(zhp));
8067eda14cbcSMatt Macy 				ret = 1;
8068eda14cbcSMatt Macy 			} else if (zfs_unmountall(zhp, flags) != 0) {
8069eda14cbcSMatt Macy 				ret = 1;
8070eda14cbcSMatt Macy 			}
8071eda14cbcSMatt Macy 			break;
8072eda14cbcSMatt Macy 		}
8073eda14cbcSMatt Macy 
8074eda14cbcSMatt Macy 		zfs_close(zhp);
8075eda14cbcSMatt Macy 	}
8076eda14cbcSMatt Macy 
8077eda14cbcSMatt Macy 	return (ret);
8078eda14cbcSMatt Macy }
8079eda14cbcSMatt Macy 
8080eda14cbcSMatt Macy /*
8081eda14cbcSMatt Macy  * zfs unmount [-fu] -a
8082eda14cbcSMatt Macy  * zfs unmount [-fu] filesystem
8083eda14cbcSMatt Macy  *
8084eda14cbcSMatt Macy  * Unmount all filesystems, or a specific ZFS filesystem.
8085eda14cbcSMatt Macy  */
8086eda14cbcSMatt Macy static int
8087eda14cbcSMatt Macy zfs_do_unmount(int argc, char **argv)
8088eda14cbcSMatt Macy {
8089eda14cbcSMatt Macy 	return (unshare_unmount(OP_MOUNT, argc, argv));
8090eda14cbcSMatt Macy }
8091eda14cbcSMatt Macy 
8092eda14cbcSMatt Macy /*
8093eda14cbcSMatt Macy  * zfs unshare -a
8094eda14cbcSMatt Macy  * zfs unshare filesystem
8095eda14cbcSMatt Macy  *
8096eda14cbcSMatt Macy  * Unshare all filesystems, or a specific ZFS filesystem.
8097eda14cbcSMatt Macy  */
8098eda14cbcSMatt Macy static int
8099eda14cbcSMatt Macy zfs_do_unshare(int argc, char **argv)
8100eda14cbcSMatt Macy {
8101eda14cbcSMatt Macy 	return (unshare_unmount(OP_SHARE, argc, argv));
8102eda14cbcSMatt Macy }
8103eda14cbcSMatt Macy 
8104eda14cbcSMatt Macy static int
8105a0b956f5SMartin Matuska find_command_idx(const char *command, int *idx)
8106eda14cbcSMatt Macy {
8107eda14cbcSMatt Macy 	int i;
8108eda14cbcSMatt Macy 
8109eda14cbcSMatt Macy 	for (i = 0; i < NCOMMAND; i++) {
8110eda14cbcSMatt Macy 		if (command_table[i].name == NULL)
8111eda14cbcSMatt Macy 			continue;
8112eda14cbcSMatt Macy 
8113eda14cbcSMatt Macy 		if (strcmp(command, command_table[i].name) == 0) {
8114eda14cbcSMatt Macy 			*idx = i;
8115eda14cbcSMatt Macy 			return (0);
8116eda14cbcSMatt Macy 		}
8117eda14cbcSMatt Macy 	}
8118eda14cbcSMatt Macy 	return (1);
8119eda14cbcSMatt Macy }
8120eda14cbcSMatt Macy 
8121eda14cbcSMatt Macy static int
8122eda14cbcSMatt Macy zfs_do_diff(int argc, char **argv)
8123eda14cbcSMatt Macy {
8124eda14cbcSMatt Macy 	zfs_handle_t *zhp;
8125eda14cbcSMatt Macy 	int flags = 0;
8126eda14cbcSMatt Macy 	char *tosnap = NULL;
8127eda14cbcSMatt Macy 	char *fromsnap = NULL;
8128eda14cbcSMatt Macy 	char *atp, *copy;
8129eda14cbcSMatt Macy 	int err = 0;
8130eda14cbcSMatt Macy 	int c;
8131eda14cbcSMatt Macy 	struct sigaction sa;
8132eda14cbcSMatt Macy 
8133681ce946SMartin Matuska 	while ((c = getopt(argc, argv, "FHth")) != -1) {
8134eda14cbcSMatt Macy 		switch (c) {
8135eda14cbcSMatt Macy 		case 'F':
8136eda14cbcSMatt Macy 			flags |= ZFS_DIFF_CLASSIFY;
8137eda14cbcSMatt Macy 			break;
8138eda14cbcSMatt Macy 		case 'H':
8139eda14cbcSMatt Macy 			flags |= ZFS_DIFF_PARSEABLE;
8140eda14cbcSMatt Macy 			break;
8141eda14cbcSMatt Macy 		case 't':
8142eda14cbcSMatt Macy 			flags |= ZFS_DIFF_TIMESTAMP;
8143eda14cbcSMatt Macy 			break;
8144681ce946SMartin Matuska 		case 'h':
8145681ce946SMartin Matuska 			flags |= ZFS_DIFF_NO_MANGLE;
8146681ce946SMartin Matuska 			break;
8147eda14cbcSMatt Macy 		default:
8148eda14cbcSMatt Macy 			(void) fprintf(stderr,
8149eda14cbcSMatt Macy 			    gettext("invalid option '%c'\n"), optopt);
8150eda14cbcSMatt Macy 			usage(B_FALSE);
8151eda14cbcSMatt Macy 		}
8152eda14cbcSMatt Macy 	}
8153eda14cbcSMatt Macy 
8154eda14cbcSMatt Macy 	argc -= optind;
8155eda14cbcSMatt Macy 	argv += optind;
8156eda14cbcSMatt Macy 
8157eda14cbcSMatt Macy 	if (argc < 1) {
8158eda14cbcSMatt Macy 		(void) fprintf(stderr,
8159eda14cbcSMatt Macy 		    gettext("must provide at least one snapshot name\n"));
8160eda14cbcSMatt Macy 		usage(B_FALSE);
8161eda14cbcSMatt Macy 	}
8162eda14cbcSMatt Macy 
8163eda14cbcSMatt Macy 	if (argc > 2) {
8164eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("too many arguments\n"));
8165eda14cbcSMatt Macy 		usage(B_FALSE);
8166eda14cbcSMatt Macy 	}
8167eda14cbcSMatt Macy 
8168eda14cbcSMatt Macy 	fromsnap = argv[0];
8169eda14cbcSMatt Macy 	tosnap = (argc == 2) ? argv[1] : NULL;
8170eda14cbcSMatt Macy 
8171eda14cbcSMatt Macy 	copy = NULL;
8172eda14cbcSMatt Macy 	if (*fromsnap != '@')
8173eda14cbcSMatt Macy 		copy = strdup(fromsnap);
8174eda14cbcSMatt Macy 	else if (tosnap)
8175eda14cbcSMatt Macy 		copy = strdup(tosnap);
8176eda14cbcSMatt Macy 	if (copy == NULL)
8177eda14cbcSMatt Macy 		usage(B_FALSE);
8178eda14cbcSMatt Macy 
8179eda14cbcSMatt Macy 	if ((atp = strchr(copy, '@')) != NULL)
8180eda14cbcSMatt Macy 		*atp = '\0';
8181eda14cbcSMatt Macy 
8182eda14cbcSMatt Macy 	if ((zhp = zfs_open(g_zfs, copy, ZFS_TYPE_FILESYSTEM)) == NULL) {
8183eda14cbcSMatt Macy 		free(copy);
8184eda14cbcSMatt Macy 		return (1);
8185eda14cbcSMatt Macy 	}
8186eda14cbcSMatt Macy 	free(copy);
8187eda14cbcSMatt Macy 
8188eda14cbcSMatt Macy 	/*
8189eda14cbcSMatt Macy 	 * Ignore SIGPIPE so that the library can give us
8190eda14cbcSMatt Macy 	 * information on any failure
8191eda14cbcSMatt Macy 	 */
8192eda14cbcSMatt Macy 	if (sigemptyset(&sa.sa_mask) == -1) {
8193eda14cbcSMatt Macy 		err = errno;
8194eda14cbcSMatt Macy 		goto out;
8195eda14cbcSMatt Macy 	}
8196eda14cbcSMatt Macy 	sa.sa_flags = 0;
8197eda14cbcSMatt Macy 	sa.sa_handler = SIG_IGN;
8198eda14cbcSMatt Macy 	if (sigaction(SIGPIPE, &sa, NULL) == -1) {
8199eda14cbcSMatt Macy 		err = errno;
8200eda14cbcSMatt Macy 		goto out;
8201eda14cbcSMatt Macy 	}
8202eda14cbcSMatt Macy 
8203eda14cbcSMatt Macy 	err = zfs_show_diffs(zhp, STDOUT_FILENO, fromsnap, tosnap, flags);
8204eda14cbcSMatt Macy out:
8205eda14cbcSMatt Macy 	zfs_close(zhp);
8206eda14cbcSMatt Macy 
8207eda14cbcSMatt Macy 	return (err != 0);
8208eda14cbcSMatt Macy }
8209eda14cbcSMatt Macy 
8210eda14cbcSMatt Macy /*
8211eda14cbcSMatt Macy  * zfs bookmark <fs@source>|<fs#source> <fs#bookmark>
8212eda14cbcSMatt Macy  *
8213eda14cbcSMatt Macy  * Creates a bookmark with the given name from the source snapshot
8214eda14cbcSMatt Macy  * or creates a copy of an existing source bookmark.
8215eda14cbcSMatt Macy  */
8216eda14cbcSMatt Macy static int
8217eda14cbcSMatt Macy zfs_do_bookmark(int argc, char **argv)
8218eda14cbcSMatt Macy {
8219eda14cbcSMatt Macy 	char *source, *bookname;
8220eda14cbcSMatt Macy 	char expbuf[ZFS_MAX_DATASET_NAME_LEN];
8221eda14cbcSMatt Macy 	int source_type;
8222eda14cbcSMatt Macy 	nvlist_t *nvl;
8223eda14cbcSMatt Macy 	int ret = 0;
8224eda14cbcSMatt Macy 	int c;
8225eda14cbcSMatt Macy 
8226eda14cbcSMatt Macy 	/* check options */
8227eda14cbcSMatt Macy 	while ((c = getopt(argc, argv, "")) != -1) {
8228eda14cbcSMatt Macy 		switch (c) {
8229eda14cbcSMatt Macy 		case '?':
8230eda14cbcSMatt Macy 			(void) fprintf(stderr,
8231eda14cbcSMatt Macy 			    gettext("invalid option '%c'\n"), optopt);
8232eda14cbcSMatt Macy 			goto usage;
8233eda14cbcSMatt Macy 		}
8234eda14cbcSMatt Macy 	}
8235eda14cbcSMatt Macy 
8236eda14cbcSMatt Macy 	argc -= optind;
8237eda14cbcSMatt Macy 	argv += optind;
8238eda14cbcSMatt Macy 
8239eda14cbcSMatt Macy 	/* check number of arguments */
8240eda14cbcSMatt Macy 	if (argc < 1) {
8241eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("missing source argument\n"));
8242eda14cbcSMatt Macy 		goto usage;
8243eda14cbcSMatt Macy 	}
8244eda14cbcSMatt Macy 	if (argc < 2) {
8245eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("missing bookmark argument\n"));
8246eda14cbcSMatt Macy 		goto usage;
8247eda14cbcSMatt Macy 	}
8248eda14cbcSMatt Macy 
8249eda14cbcSMatt Macy 	source = argv[0];
8250eda14cbcSMatt Macy 	bookname = argv[1];
8251eda14cbcSMatt Macy 
8252eda14cbcSMatt Macy 	if (strchr(source, '@') == NULL && strchr(source, '#') == NULL) {
8253eda14cbcSMatt Macy 		(void) fprintf(stderr,
8254eda14cbcSMatt Macy 		    gettext("invalid source name '%s': "
8255eda14cbcSMatt Macy 		    "must contain a '@' or '#'\n"), source);
8256eda14cbcSMatt Macy 		goto usage;
8257eda14cbcSMatt Macy 	}
8258eda14cbcSMatt Macy 	if (strchr(bookname, '#') == NULL) {
8259eda14cbcSMatt Macy 		(void) fprintf(stderr,
8260eda14cbcSMatt Macy 		    gettext("invalid bookmark name '%s': "
8261eda14cbcSMatt Macy 		    "must contain a '#'\n"), bookname);
8262eda14cbcSMatt Macy 		goto usage;
8263eda14cbcSMatt Macy 	}
8264eda14cbcSMatt Macy 
8265eda14cbcSMatt Macy 	/*
8266eda14cbcSMatt Macy 	 * expand source or bookname to full path:
8267eda14cbcSMatt Macy 	 * one of them may be specified as short name
8268eda14cbcSMatt Macy 	 */
8269eda14cbcSMatt Macy 	{
8270eda14cbcSMatt Macy 		char **expand;
8271eda14cbcSMatt Macy 		char *source_short, *bookname_short;
8272eda14cbcSMatt Macy 		source_short = strpbrk(source, "@#");
8273eda14cbcSMatt Macy 		bookname_short = strpbrk(bookname, "#");
8274eda14cbcSMatt Macy 		if (source_short == source &&
8275eda14cbcSMatt Macy 		    bookname_short == bookname) {
8276eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext(
8277eda14cbcSMatt Macy 			    "either source or bookmark must be specified as "
8278eda14cbcSMatt Macy 			    "full dataset paths"));
8279eda14cbcSMatt Macy 			goto usage;
8280eda14cbcSMatt Macy 		} else if (source_short != source &&
8281eda14cbcSMatt Macy 		    bookname_short != bookname) {
8282eda14cbcSMatt Macy 			expand = NULL;
8283eda14cbcSMatt Macy 		} else if (source_short != source) {
8284eda14cbcSMatt Macy 			strlcpy(expbuf, source, sizeof (expbuf));
8285eda14cbcSMatt Macy 			expand = &bookname;
8286eda14cbcSMatt Macy 		} else if (bookname_short != bookname) {
8287eda14cbcSMatt Macy 			strlcpy(expbuf, bookname, sizeof (expbuf));
8288eda14cbcSMatt Macy 			expand = &source;
8289eda14cbcSMatt Macy 		} else {
8290eda14cbcSMatt Macy 			abort();
8291eda14cbcSMatt Macy 		}
8292eda14cbcSMatt Macy 		if (expand != NULL) {
8293eda14cbcSMatt Macy 			*strpbrk(expbuf, "@#") = '\0'; /* dataset name in buf */
8294eda14cbcSMatt Macy 			(void) strlcat(expbuf, *expand, sizeof (expbuf));
8295eda14cbcSMatt Macy 			*expand = expbuf;
8296eda14cbcSMatt Macy 		}
8297eda14cbcSMatt Macy 	}
8298eda14cbcSMatt Macy 
8299eda14cbcSMatt Macy 	/* determine source type */
8300eda14cbcSMatt Macy 	switch (*strpbrk(source, "@#")) {
8301eda14cbcSMatt Macy 		case '@': source_type = ZFS_TYPE_SNAPSHOT; break;
8302eda14cbcSMatt Macy 		case '#': source_type = ZFS_TYPE_BOOKMARK; break;
8303eda14cbcSMatt Macy 		default: abort();
8304eda14cbcSMatt Macy 	}
8305eda14cbcSMatt Macy 
8306eda14cbcSMatt Macy 	/* test the source exists */
8307eda14cbcSMatt Macy 	zfs_handle_t *zhp;
8308eda14cbcSMatt Macy 	zhp = zfs_open(g_zfs, source, source_type);
8309eda14cbcSMatt Macy 	if (zhp == NULL)
8310eda14cbcSMatt Macy 		goto usage;
8311eda14cbcSMatt Macy 	zfs_close(zhp);
8312eda14cbcSMatt Macy 
8313eda14cbcSMatt Macy 	nvl = fnvlist_alloc();
8314eda14cbcSMatt Macy 	fnvlist_add_string(nvl, bookname, source);
8315eda14cbcSMatt Macy 	ret = lzc_bookmark(nvl, NULL);
8316eda14cbcSMatt Macy 	fnvlist_free(nvl);
8317eda14cbcSMatt Macy 
8318eda14cbcSMatt Macy 	if (ret != 0) {
8319eda14cbcSMatt Macy 		const char *err_msg = NULL;
8320eda14cbcSMatt Macy 		char errbuf[1024];
8321eda14cbcSMatt Macy 
8322eda14cbcSMatt Macy 		(void) snprintf(errbuf, sizeof (errbuf),
8323eda14cbcSMatt Macy 		    dgettext(TEXT_DOMAIN,
8324eda14cbcSMatt Macy 		    "cannot create bookmark '%s'"), bookname);
8325eda14cbcSMatt Macy 
8326eda14cbcSMatt Macy 		switch (ret) {
8327eda14cbcSMatt Macy 		case EXDEV:
8328eda14cbcSMatt Macy 			err_msg = "bookmark is in a different pool";
8329eda14cbcSMatt Macy 			break;
8330eda14cbcSMatt Macy 		case ZFS_ERR_BOOKMARK_SOURCE_NOT_ANCESTOR:
8331eda14cbcSMatt Macy 			err_msg = "source is not an ancestor of the "
8332eda14cbcSMatt Macy 			    "new bookmark's dataset";
8333eda14cbcSMatt Macy 			break;
8334eda14cbcSMatt Macy 		case EEXIST:
8335eda14cbcSMatt Macy 			err_msg = "bookmark exists";
8336eda14cbcSMatt Macy 			break;
8337eda14cbcSMatt Macy 		case EINVAL:
8338eda14cbcSMatt Macy 			err_msg = "invalid argument";
8339eda14cbcSMatt Macy 			break;
8340eda14cbcSMatt Macy 		case ENOTSUP:
8341eda14cbcSMatt Macy 			err_msg = "bookmark feature not enabled";
8342eda14cbcSMatt Macy 			break;
8343eda14cbcSMatt Macy 		case ENOSPC:
8344eda14cbcSMatt Macy 			err_msg = "out of space";
8345eda14cbcSMatt Macy 			break;
8346eda14cbcSMatt Macy 		case ENOENT:
8347eda14cbcSMatt Macy 			err_msg = "dataset does not exist";
8348eda14cbcSMatt Macy 			break;
8349eda14cbcSMatt Macy 		default:
8350eda14cbcSMatt Macy 			(void) zfs_standard_error(g_zfs, ret, errbuf);
8351eda14cbcSMatt Macy 			break;
8352eda14cbcSMatt Macy 		}
8353eda14cbcSMatt Macy 		if (err_msg != NULL) {
8354eda14cbcSMatt Macy 			(void) fprintf(stderr, "%s: %s\n", errbuf,
8355eda14cbcSMatt Macy 			    dgettext(TEXT_DOMAIN, err_msg));
8356eda14cbcSMatt Macy 		}
8357eda14cbcSMatt Macy 	}
8358eda14cbcSMatt Macy 
8359eda14cbcSMatt Macy 	return (ret != 0);
8360eda14cbcSMatt Macy 
8361eda14cbcSMatt Macy usage:
8362eda14cbcSMatt Macy 	usage(B_FALSE);
8363eda14cbcSMatt Macy 	return (-1);
8364eda14cbcSMatt Macy }
8365eda14cbcSMatt Macy 
8366eda14cbcSMatt Macy static int
8367eda14cbcSMatt Macy zfs_do_channel_program(int argc, char **argv)
8368eda14cbcSMatt Macy {
8369eda14cbcSMatt Macy 	int ret, fd, c;
8370eda14cbcSMatt Macy 	size_t progsize, progread;
8371eda14cbcSMatt Macy 	nvlist_t *outnvl = NULL;
8372eda14cbcSMatt Macy 	uint64_t instrlimit = ZCP_DEFAULT_INSTRLIMIT;
8373eda14cbcSMatt Macy 	uint64_t memlimit = ZCP_DEFAULT_MEMLIMIT;
8374eda14cbcSMatt Macy 	boolean_t sync_flag = B_TRUE, json_output = B_FALSE;
8375eda14cbcSMatt Macy 	zpool_handle_t *zhp;
8376eda14cbcSMatt Macy 
8377eda14cbcSMatt Macy 	/* check options */
8378eda14cbcSMatt Macy 	while ((c = getopt(argc, argv, "nt:m:j")) != -1) {
8379eda14cbcSMatt Macy 		switch (c) {
8380eda14cbcSMatt Macy 		case 't':
8381eda14cbcSMatt Macy 		case 'm': {
8382eda14cbcSMatt Macy 			uint64_t arg;
8383eda14cbcSMatt Macy 			char *endp;
8384eda14cbcSMatt Macy 
8385eda14cbcSMatt Macy 			errno = 0;
8386eda14cbcSMatt Macy 			arg = strtoull(optarg, &endp, 0);
8387eda14cbcSMatt Macy 			if (errno != 0 || *endp != '\0') {
8388eda14cbcSMatt Macy 				(void) fprintf(stderr, gettext(
8389eda14cbcSMatt Macy 				    "invalid argument "
8390eda14cbcSMatt Macy 				    "'%s': expected integer\n"), optarg);
8391eda14cbcSMatt Macy 				goto usage;
8392eda14cbcSMatt Macy 			}
8393eda14cbcSMatt Macy 
8394eda14cbcSMatt Macy 			if (c == 't') {
8395eda14cbcSMatt Macy 				instrlimit = arg;
8396eda14cbcSMatt Macy 			} else {
8397eda14cbcSMatt Macy 				ASSERT3U(c, ==, 'm');
8398eda14cbcSMatt Macy 				memlimit = arg;
8399eda14cbcSMatt Macy 			}
8400eda14cbcSMatt Macy 			break;
8401eda14cbcSMatt Macy 		}
8402eda14cbcSMatt Macy 		case 'n': {
8403eda14cbcSMatt Macy 			sync_flag = B_FALSE;
8404eda14cbcSMatt Macy 			break;
8405eda14cbcSMatt Macy 		}
8406eda14cbcSMatt Macy 		case 'j': {
8407eda14cbcSMatt Macy 			json_output = B_TRUE;
8408eda14cbcSMatt Macy 			break;
8409eda14cbcSMatt Macy 		}
8410eda14cbcSMatt Macy 		case '?':
8411eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
8412eda14cbcSMatt Macy 			    optopt);
8413eda14cbcSMatt Macy 			goto usage;
8414eda14cbcSMatt Macy 		}
8415eda14cbcSMatt Macy 	}
8416eda14cbcSMatt Macy 
8417eda14cbcSMatt Macy 	argc -= optind;
8418eda14cbcSMatt Macy 	argv += optind;
8419eda14cbcSMatt Macy 
8420eda14cbcSMatt Macy 	if (argc < 2) {
8421eda14cbcSMatt Macy 		(void) fprintf(stderr,
8422eda14cbcSMatt Macy 		    gettext("invalid number of arguments\n"));
8423eda14cbcSMatt Macy 		goto usage;
8424eda14cbcSMatt Macy 	}
8425eda14cbcSMatt Macy 
8426a0b956f5SMartin Matuska 	const char *poolname = argv[0];
8427a0b956f5SMartin Matuska 	const char *filename = argv[1];
8428eda14cbcSMatt Macy 	if (strcmp(filename, "-") == 0) {
8429eda14cbcSMatt Macy 		fd = 0;
8430eda14cbcSMatt Macy 		filename = "standard input";
8431eda14cbcSMatt Macy 	} else if ((fd = open(filename, O_RDONLY)) < 0) {
8432eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("cannot open '%s': %s\n"),
8433eda14cbcSMatt Macy 		    filename, strerror(errno));
8434eda14cbcSMatt Macy 		return (1);
8435eda14cbcSMatt Macy 	}
8436eda14cbcSMatt Macy 
8437eda14cbcSMatt Macy 	if ((zhp = zpool_open(g_zfs, poolname)) == NULL) {
8438eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("cannot open pool '%s'\n"),
8439eda14cbcSMatt Macy 		    poolname);
8440eda14cbcSMatt Macy 		if (fd != 0)
8441eda14cbcSMatt Macy 			(void) close(fd);
8442eda14cbcSMatt Macy 		return (1);
8443eda14cbcSMatt Macy 	}
8444eda14cbcSMatt Macy 	zpool_close(zhp);
8445eda14cbcSMatt Macy 
8446eda14cbcSMatt Macy 	/*
8447eda14cbcSMatt Macy 	 * Read in the channel program, expanding the program buffer as
8448eda14cbcSMatt Macy 	 * necessary.
8449eda14cbcSMatt Macy 	 */
8450eda14cbcSMatt Macy 	progread = 0;
8451eda14cbcSMatt Macy 	progsize = 1024;
8452a0b956f5SMartin Matuska 	char *progbuf = safe_malloc(progsize);
8453eda14cbcSMatt Macy 	do {
8454eda14cbcSMatt Macy 		ret = read(fd, progbuf + progread, progsize - progread);
8455eda14cbcSMatt Macy 		progread += ret;
8456eda14cbcSMatt Macy 		if (progread == progsize && ret > 0) {
8457eda14cbcSMatt Macy 			progsize *= 2;
8458eda14cbcSMatt Macy 			progbuf = safe_realloc(progbuf, progsize);
8459eda14cbcSMatt Macy 		}
8460eda14cbcSMatt Macy 	} while (ret > 0);
8461eda14cbcSMatt Macy 
8462eda14cbcSMatt Macy 	if (fd != 0)
8463eda14cbcSMatt Macy 		(void) close(fd);
8464eda14cbcSMatt Macy 	if (ret < 0) {
8465eda14cbcSMatt Macy 		free(progbuf);
8466eda14cbcSMatt Macy 		(void) fprintf(stderr,
8467eda14cbcSMatt Macy 		    gettext("cannot read '%s': %s\n"),
8468eda14cbcSMatt Macy 		    filename, strerror(errno));
8469eda14cbcSMatt Macy 		return (1);
8470eda14cbcSMatt Macy 	}
8471eda14cbcSMatt Macy 	progbuf[progread] = '\0';
8472eda14cbcSMatt Macy 
8473eda14cbcSMatt Macy 	/*
8474eda14cbcSMatt Macy 	 * Any remaining arguments are passed as arguments to the lua script as
8475eda14cbcSMatt Macy 	 * a string array:
8476eda14cbcSMatt Macy 	 * {
8477eda14cbcSMatt Macy 	 *	"argv" -> [ "arg 1", ... "arg n" ],
8478eda14cbcSMatt Macy 	 * }
8479eda14cbcSMatt Macy 	 */
8480eda14cbcSMatt Macy 	nvlist_t *argnvl = fnvlist_alloc();
8481681ce946SMartin Matuska 	fnvlist_add_string_array(argnvl, ZCP_ARG_CLIARGV,
8482681ce946SMartin Matuska 	    (const char **)argv + 2, argc - 2);
8483eda14cbcSMatt Macy 
8484eda14cbcSMatt Macy 	if (sync_flag) {
8485eda14cbcSMatt Macy 		ret = lzc_channel_program(poolname, progbuf,
8486eda14cbcSMatt Macy 		    instrlimit, memlimit, argnvl, &outnvl);
8487eda14cbcSMatt Macy 	} else {
8488eda14cbcSMatt Macy 		ret = lzc_channel_program_nosync(poolname, progbuf,
8489eda14cbcSMatt Macy 		    instrlimit, memlimit, argnvl, &outnvl);
8490eda14cbcSMatt Macy 	}
8491eda14cbcSMatt Macy 
8492eda14cbcSMatt Macy 	if (ret != 0) {
8493eda14cbcSMatt Macy 		/*
8494eda14cbcSMatt Macy 		 * On error, report the error message handed back by lua if one
8495eda14cbcSMatt Macy 		 * exists.  Otherwise, generate an appropriate error message,
8496eda14cbcSMatt Macy 		 * falling back on strerror() for an unexpected return code.
8497eda14cbcSMatt Macy 		 */
8498a0b956f5SMartin Matuska 		const char *errstring = NULL;
8499eda14cbcSMatt Macy 		const char *msg = gettext("Channel program execution failed");
8500eda14cbcSMatt Macy 		uint64_t instructions = 0;
8501eda14cbcSMatt Macy 		if (outnvl != NULL && nvlist_exists(outnvl, ZCP_RET_ERROR)) {
85022a58b312SMartin Matuska 			const char *es = NULL;
8503eda14cbcSMatt Macy 			(void) nvlist_lookup_string(outnvl,
8504a0b956f5SMartin Matuska 			    ZCP_RET_ERROR, &es);
8505a0b956f5SMartin Matuska 			if (es == NULL)
8506eda14cbcSMatt Macy 				errstring = strerror(ret);
8507a0b956f5SMartin Matuska 			else
8508a0b956f5SMartin Matuska 				errstring = es;
8509eda14cbcSMatt Macy 			if (ret == ETIME) {
8510eda14cbcSMatt Macy 				(void) nvlist_lookup_uint64(outnvl,
8511eda14cbcSMatt Macy 				    ZCP_ARG_INSTRLIMIT, &instructions);
8512eda14cbcSMatt Macy 			}
8513eda14cbcSMatt Macy 		} else {
8514eda14cbcSMatt Macy 			switch (ret) {
8515eda14cbcSMatt Macy 			case EINVAL:
8516eda14cbcSMatt Macy 				errstring =
8517eda14cbcSMatt Macy 				    "Invalid instruction or memory limit.";
8518eda14cbcSMatt Macy 				break;
8519eda14cbcSMatt Macy 			case ENOMEM:
8520eda14cbcSMatt Macy 				errstring = "Return value too large.";
8521eda14cbcSMatt Macy 				break;
8522eda14cbcSMatt Macy 			case ENOSPC:
8523eda14cbcSMatt Macy 				errstring = "Memory limit exhausted.";
8524eda14cbcSMatt Macy 				break;
8525eda14cbcSMatt Macy 			case ETIME:
8526eda14cbcSMatt Macy 				errstring = "Timed out.";
8527eda14cbcSMatt Macy 				break;
8528eda14cbcSMatt Macy 			case EPERM:
8529eda14cbcSMatt Macy 				errstring = "Permission denied. Channel "
8530eda14cbcSMatt Macy 				    "programs must be run as root.";
8531eda14cbcSMatt Macy 				break;
8532eda14cbcSMatt Macy 			default:
8533eda14cbcSMatt Macy 				(void) zfs_standard_error(g_zfs, ret, msg);
8534eda14cbcSMatt Macy 			}
8535eda14cbcSMatt Macy 		}
8536eda14cbcSMatt Macy 		if (errstring != NULL)
8537eda14cbcSMatt Macy 			(void) fprintf(stderr, "%s:\n%s\n", msg, errstring);
8538eda14cbcSMatt Macy 
8539eda14cbcSMatt Macy 		if (ret == ETIME && instructions != 0)
8540eda14cbcSMatt Macy 			(void) fprintf(stderr,
8541eda14cbcSMatt Macy 			    gettext("%llu Lua instructions\n"),
8542eda14cbcSMatt Macy 			    (u_longlong_t)instructions);
8543eda14cbcSMatt Macy 	} else {
8544eda14cbcSMatt Macy 		if (json_output) {
8545eda14cbcSMatt Macy 			(void) nvlist_print_json(stdout, outnvl);
8546eda14cbcSMatt Macy 		} else if (nvlist_empty(outnvl)) {
8547eda14cbcSMatt Macy 			(void) fprintf(stdout, gettext("Channel program fully "
8548eda14cbcSMatt Macy 			    "executed and did not produce output.\n"));
8549eda14cbcSMatt Macy 		} else {
8550eda14cbcSMatt Macy 			(void) fprintf(stdout, gettext("Channel program fully "
8551eda14cbcSMatt Macy 			    "executed and produced output:\n"));
8552eda14cbcSMatt Macy 			dump_nvlist(outnvl, 4);
8553eda14cbcSMatt Macy 		}
8554eda14cbcSMatt Macy 	}
8555eda14cbcSMatt Macy 
8556eda14cbcSMatt Macy 	free(progbuf);
8557eda14cbcSMatt Macy 	fnvlist_free(outnvl);
8558eda14cbcSMatt Macy 	fnvlist_free(argnvl);
8559eda14cbcSMatt Macy 	return (ret != 0);
8560eda14cbcSMatt Macy 
8561eda14cbcSMatt Macy usage:
8562eda14cbcSMatt Macy 	usage(B_FALSE);
8563eda14cbcSMatt Macy 	return (-1);
8564eda14cbcSMatt Macy }
8565eda14cbcSMatt Macy 
8566eda14cbcSMatt Macy 
8567eda14cbcSMatt Macy typedef struct loadkey_cbdata {
8568eda14cbcSMatt Macy 	boolean_t cb_loadkey;
8569eda14cbcSMatt Macy 	boolean_t cb_recursive;
8570eda14cbcSMatt Macy 	boolean_t cb_noop;
8571eda14cbcSMatt Macy 	char *cb_keylocation;
8572eda14cbcSMatt Macy 	uint64_t cb_numfailed;
8573eda14cbcSMatt Macy 	uint64_t cb_numattempted;
8574eda14cbcSMatt Macy } loadkey_cbdata_t;
8575eda14cbcSMatt Macy 
8576eda14cbcSMatt Macy static int
8577eda14cbcSMatt Macy load_key_callback(zfs_handle_t *zhp, void *data)
8578eda14cbcSMatt Macy {
8579eda14cbcSMatt Macy 	int ret;
8580eda14cbcSMatt Macy 	boolean_t is_encroot;
8581eda14cbcSMatt Macy 	loadkey_cbdata_t *cb = data;
8582eda14cbcSMatt Macy 	uint64_t keystatus = zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS);
8583eda14cbcSMatt Macy 
8584eda14cbcSMatt Macy 	/*
8585eda14cbcSMatt Macy 	 * If we are working recursively, we want to skip loading / unloading
8586eda14cbcSMatt Macy 	 * keys for non-encryption roots and datasets whose keys are already
8587eda14cbcSMatt Macy 	 * in the desired end-state.
8588eda14cbcSMatt Macy 	 */
8589eda14cbcSMatt Macy 	if (cb->cb_recursive) {
8590eda14cbcSMatt Macy 		ret = zfs_crypto_get_encryption_root(zhp, &is_encroot, NULL);
8591eda14cbcSMatt Macy 		if (ret != 0)
8592eda14cbcSMatt Macy 			return (ret);
8593eda14cbcSMatt Macy 		if (!is_encroot)
8594eda14cbcSMatt Macy 			return (0);
8595eda14cbcSMatt Macy 
8596eda14cbcSMatt Macy 		if ((cb->cb_loadkey && keystatus == ZFS_KEYSTATUS_AVAILABLE) ||
8597eda14cbcSMatt Macy 		    (!cb->cb_loadkey && keystatus == ZFS_KEYSTATUS_UNAVAILABLE))
8598eda14cbcSMatt Macy 			return (0);
8599eda14cbcSMatt Macy 	}
8600eda14cbcSMatt Macy 
8601eda14cbcSMatt Macy 	cb->cb_numattempted++;
8602eda14cbcSMatt Macy 
8603eda14cbcSMatt Macy 	if (cb->cb_loadkey)
8604eda14cbcSMatt Macy 		ret = zfs_crypto_load_key(zhp, cb->cb_noop, cb->cb_keylocation);
8605eda14cbcSMatt Macy 	else
8606eda14cbcSMatt Macy 		ret = zfs_crypto_unload_key(zhp);
8607eda14cbcSMatt Macy 
8608eda14cbcSMatt Macy 	if (ret != 0) {
8609eda14cbcSMatt Macy 		cb->cb_numfailed++;
8610eda14cbcSMatt Macy 		return (ret);
8611eda14cbcSMatt Macy 	}
8612eda14cbcSMatt Macy 
8613eda14cbcSMatt Macy 	return (0);
8614eda14cbcSMatt Macy }
8615eda14cbcSMatt Macy 
8616eda14cbcSMatt Macy static int
8617eda14cbcSMatt Macy load_unload_keys(int argc, char **argv, boolean_t loadkey)
8618eda14cbcSMatt Macy {
8619eda14cbcSMatt Macy 	int c, ret = 0, flags = 0;
8620eda14cbcSMatt Macy 	boolean_t do_all = B_FALSE;
8621eda14cbcSMatt Macy 	loadkey_cbdata_t cb = { 0 };
8622eda14cbcSMatt Macy 
8623eda14cbcSMatt Macy 	cb.cb_loadkey = loadkey;
8624eda14cbcSMatt Macy 
8625eda14cbcSMatt Macy 	while ((c = getopt(argc, argv, "anrL:")) != -1) {
8626eda14cbcSMatt Macy 		/* noop and alternate keylocations only apply to zfs load-key */
8627eda14cbcSMatt Macy 		if (loadkey) {
8628eda14cbcSMatt Macy 			switch (c) {
8629eda14cbcSMatt Macy 			case 'n':
8630eda14cbcSMatt Macy 				cb.cb_noop = B_TRUE;
8631eda14cbcSMatt Macy 				continue;
8632eda14cbcSMatt Macy 			case 'L':
8633eda14cbcSMatt Macy 				cb.cb_keylocation = optarg;
8634eda14cbcSMatt Macy 				continue;
8635eda14cbcSMatt Macy 			default:
8636eda14cbcSMatt Macy 				break;
8637eda14cbcSMatt Macy 			}
8638eda14cbcSMatt Macy 		}
8639eda14cbcSMatt Macy 
8640eda14cbcSMatt Macy 		switch (c) {
8641eda14cbcSMatt Macy 		case 'a':
8642eda14cbcSMatt Macy 			do_all = B_TRUE;
8643eda14cbcSMatt Macy 			cb.cb_recursive = B_TRUE;
8644eda14cbcSMatt Macy 			break;
8645eda14cbcSMatt Macy 		case 'r':
8646eda14cbcSMatt Macy 			flags |= ZFS_ITER_RECURSE;
8647eda14cbcSMatt Macy 			cb.cb_recursive = B_TRUE;
8648eda14cbcSMatt Macy 			break;
8649eda14cbcSMatt Macy 		default:
8650eda14cbcSMatt Macy 			(void) fprintf(stderr,
8651eda14cbcSMatt Macy 			    gettext("invalid option '%c'\n"), optopt);
8652eda14cbcSMatt Macy 			usage(B_FALSE);
8653eda14cbcSMatt Macy 		}
8654eda14cbcSMatt Macy 	}
8655eda14cbcSMatt Macy 
8656eda14cbcSMatt Macy 	argc -= optind;
8657eda14cbcSMatt Macy 	argv += optind;
8658eda14cbcSMatt Macy 
8659eda14cbcSMatt Macy 	if (!do_all && argc == 0) {
8660eda14cbcSMatt Macy 		(void) fprintf(stderr,
8661eda14cbcSMatt Macy 		    gettext("Missing dataset argument or -a option\n"));
8662eda14cbcSMatt Macy 		usage(B_FALSE);
8663eda14cbcSMatt Macy 	}
8664eda14cbcSMatt Macy 
8665eda14cbcSMatt Macy 	if (do_all && argc != 0) {
8666eda14cbcSMatt Macy 		(void) fprintf(stderr,
8667eda14cbcSMatt Macy 		    gettext("Cannot specify dataset with -a option\n"));
8668eda14cbcSMatt Macy 		usage(B_FALSE);
8669eda14cbcSMatt Macy 	}
8670eda14cbcSMatt Macy 
8671eda14cbcSMatt Macy 	if (cb.cb_recursive && cb.cb_keylocation != NULL &&
8672eda14cbcSMatt Macy 	    strcmp(cb.cb_keylocation, "prompt") != 0) {
8673eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("alternate keylocation may only "
8674eda14cbcSMatt Macy 		    "be 'prompt' with -r or -a\n"));
8675eda14cbcSMatt Macy 		usage(B_FALSE);
8676eda14cbcSMatt Macy 	}
8677eda14cbcSMatt Macy 
8678eda14cbcSMatt Macy 	ret = zfs_for_each(argc, argv, flags,
8679eda14cbcSMatt Macy 	    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME, NULL, NULL, 0,
8680eda14cbcSMatt Macy 	    load_key_callback, &cb);
8681eda14cbcSMatt Macy 
8682eda14cbcSMatt Macy 	if (cb.cb_noop || (cb.cb_recursive && cb.cb_numattempted != 0)) {
8683eda14cbcSMatt Macy 		(void) printf(gettext("%llu / %llu key(s) successfully %s\n"),
8684eda14cbcSMatt Macy 		    (u_longlong_t)(cb.cb_numattempted - cb.cb_numfailed),
8685eda14cbcSMatt Macy 		    (u_longlong_t)cb.cb_numattempted,
8686eda14cbcSMatt Macy 		    loadkey ? (cb.cb_noop ? "verified" : "loaded") :
8687eda14cbcSMatt Macy 		    "unloaded");
8688eda14cbcSMatt Macy 	}
8689eda14cbcSMatt Macy 
8690eda14cbcSMatt Macy 	if (cb.cb_numfailed != 0)
8691eda14cbcSMatt Macy 		ret = -1;
8692eda14cbcSMatt Macy 
8693eda14cbcSMatt Macy 	return (ret);
8694eda14cbcSMatt Macy }
8695eda14cbcSMatt Macy 
8696eda14cbcSMatt Macy static int
8697eda14cbcSMatt Macy zfs_do_load_key(int argc, char **argv)
8698eda14cbcSMatt Macy {
8699eda14cbcSMatt Macy 	return (load_unload_keys(argc, argv, B_TRUE));
8700eda14cbcSMatt Macy }
8701eda14cbcSMatt Macy 
8702eda14cbcSMatt Macy 
8703eda14cbcSMatt Macy static int
8704eda14cbcSMatt Macy zfs_do_unload_key(int argc, char **argv)
8705eda14cbcSMatt Macy {
8706eda14cbcSMatt Macy 	return (load_unload_keys(argc, argv, B_FALSE));
8707eda14cbcSMatt Macy }
8708eda14cbcSMatt Macy 
8709eda14cbcSMatt Macy static int
8710eda14cbcSMatt Macy zfs_do_change_key(int argc, char **argv)
8711eda14cbcSMatt Macy {
8712eda14cbcSMatt Macy 	int c, ret;
8713eda14cbcSMatt Macy 	uint64_t keystatus;
8714eda14cbcSMatt Macy 	boolean_t loadkey = B_FALSE, inheritkey = B_FALSE;
8715eda14cbcSMatt Macy 	zfs_handle_t *zhp = NULL;
8716eda14cbcSMatt Macy 	nvlist_t *props = fnvlist_alloc();
8717eda14cbcSMatt Macy 
8718eda14cbcSMatt Macy 	while ((c = getopt(argc, argv, "lio:")) != -1) {
8719eda14cbcSMatt Macy 		switch (c) {
8720eda14cbcSMatt Macy 		case 'l':
8721eda14cbcSMatt Macy 			loadkey = B_TRUE;
8722eda14cbcSMatt Macy 			break;
8723eda14cbcSMatt Macy 		case 'i':
8724eda14cbcSMatt Macy 			inheritkey = B_TRUE;
8725eda14cbcSMatt Macy 			break;
8726eda14cbcSMatt Macy 		case 'o':
8727eda14cbcSMatt Macy 			if (!parseprop(props, optarg)) {
8728eda14cbcSMatt Macy 				nvlist_free(props);
8729eda14cbcSMatt Macy 				return (1);
8730eda14cbcSMatt Macy 			}
8731eda14cbcSMatt Macy 			break;
8732eda14cbcSMatt Macy 		default:
8733eda14cbcSMatt Macy 			(void) fprintf(stderr,
8734eda14cbcSMatt Macy 			    gettext("invalid option '%c'\n"), optopt);
8735eda14cbcSMatt Macy 			usage(B_FALSE);
8736eda14cbcSMatt Macy 		}
8737eda14cbcSMatt Macy 	}
8738eda14cbcSMatt Macy 
8739eda14cbcSMatt Macy 	if (inheritkey && !nvlist_empty(props)) {
8740eda14cbcSMatt Macy 		(void) fprintf(stderr,
8741eda14cbcSMatt Macy 		    gettext("Properties not allowed for inheriting\n"));
8742eda14cbcSMatt Macy 		usage(B_FALSE);
8743eda14cbcSMatt Macy 	}
8744eda14cbcSMatt Macy 
8745eda14cbcSMatt Macy 	argc -= optind;
8746eda14cbcSMatt Macy 	argv += optind;
8747eda14cbcSMatt Macy 
8748eda14cbcSMatt Macy 	if (argc < 1) {
8749eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("Missing dataset argument\n"));
8750eda14cbcSMatt Macy 		usage(B_FALSE);
8751eda14cbcSMatt Macy 	}
8752eda14cbcSMatt Macy 
8753eda14cbcSMatt Macy 	if (argc > 1) {
8754eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("Too many arguments\n"));
8755eda14cbcSMatt Macy 		usage(B_FALSE);
8756eda14cbcSMatt Macy 	}
8757eda14cbcSMatt Macy 
8758eda14cbcSMatt Macy 	zhp = zfs_open(g_zfs, argv[argc - 1],
8759eda14cbcSMatt Macy 	    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
8760eda14cbcSMatt Macy 	if (zhp == NULL)
8761eda14cbcSMatt Macy 		usage(B_FALSE);
8762eda14cbcSMatt Macy 
8763eda14cbcSMatt Macy 	if (loadkey) {
8764eda14cbcSMatt Macy 		keystatus = zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS);
8765eda14cbcSMatt Macy 		if (keystatus != ZFS_KEYSTATUS_AVAILABLE) {
8766eda14cbcSMatt Macy 			ret = zfs_crypto_load_key(zhp, B_FALSE, NULL);
8767eda14cbcSMatt Macy 			if (ret != 0) {
8768eda14cbcSMatt Macy 				nvlist_free(props);
8769eda14cbcSMatt Macy 				zfs_close(zhp);
8770eda14cbcSMatt Macy 				return (-1);
8771eda14cbcSMatt Macy 			}
8772eda14cbcSMatt Macy 		}
8773eda14cbcSMatt Macy 
8774eda14cbcSMatt Macy 		/* refresh the properties so the new keystatus is visible */
8775eda14cbcSMatt Macy 		zfs_refresh_properties(zhp);
8776eda14cbcSMatt Macy 	}
8777eda14cbcSMatt Macy 
8778eda14cbcSMatt Macy 	ret = zfs_crypto_rewrap(zhp, props, inheritkey);
8779eda14cbcSMatt Macy 	if (ret != 0) {
8780eda14cbcSMatt Macy 		nvlist_free(props);
8781eda14cbcSMatt Macy 		zfs_close(zhp);
8782eda14cbcSMatt Macy 		return (-1);
8783eda14cbcSMatt Macy 	}
8784eda14cbcSMatt Macy 
8785eda14cbcSMatt Macy 	nvlist_free(props);
8786eda14cbcSMatt Macy 	zfs_close(zhp);
8787eda14cbcSMatt Macy 	return (0);
8788eda14cbcSMatt Macy }
8789eda14cbcSMatt Macy 
8790eda14cbcSMatt Macy /*
8791eda14cbcSMatt Macy  * 1) zfs project [-d|-r] <file|directory ...>
8792eda14cbcSMatt Macy  *    List project ID and inherit flag of file(s) or directories.
8793eda14cbcSMatt Macy  *    -d: List the directory itself, not its children.
8794eda14cbcSMatt Macy  *    -r: List subdirectories recursively.
8795eda14cbcSMatt Macy  *
8796eda14cbcSMatt Macy  * 2) zfs project -C [-k] [-r] <file|directory ...>
8797eda14cbcSMatt Macy  *    Clear project inherit flag and/or ID on the file(s) or directories.
8798eda14cbcSMatt Macy  *    -k: Keep the project ID unchanged. If not specified, the project ID
8799eda14cbcSMatt Macy  *	  will be reset as zero.
8800eda14cbcSMatt Macy  *    -r: Clear on subdirectories recursively.
8801eda14cbcSMatt Macy  *
8802eda14cbcSMatt Macy  * 3) zfs project -c [-0] [-d|-r] [-p id] <file|directory ...>
8803eda14cbcSMatt Macy  *    Check project ID and inherit flag on the file(s) or directories,
8804eda14cbcSMatt Macy  *    report the outliers.
8805eda14cbcSMatt Macy  *    -0: Print file name followed by a NUL instead of newline.
8806eda14cbcSMatt Macy  *    -d: Check the directory itself, not its children.
8807eda14cbcSMatt Macy  *    -p: Specify the referenced ID for comparing with the target file(s)
8808eda14cbcSMatt Macy  *	  or directories' project IDs. If not specified, the target (top)
8809eda14cbcSMatt Macy  *	  directory's project ID will be used as the referenced one.
8810eda14cbcSMatt Macy  *    -r: Check subdirectories recursively.
8811eda14cbcSMatt Macy  *
8812eda14cbcSMatt Macy  * 4) zfs project [-p id] [-r] [-s] <file|directory ...>
8813eda14cbcSMatt Macy  *    Set project ID and/or inherit flag on the file(s) or directories.
8814eda14cbcSMatt Macy  *    -p: Set the project ID as the given id.
8815eda14cbcSMatt Macy  *    -r: Set on subdirectories recursively. If not specify "-p" option,
8816eda14cbcSMatt Macy  *	  it will use top-level directory's project ID as the given id,
8817eda14cbcSMatt Macy  *	  then set both project ID and inherit flag on all descendants
8818eda14cbcSMatt Macy  *	  of the top-level directory.
8819eda14cbcSMatt Macy  *    -s: Set project inherit flag.
8820eda14cbcSMatt Macy  */
8821eda14cbcSMatt Macy static int
8822eda14cbcSMatt Macy zfs_do_project(int argc, char **argv)
8823eda14cbcSMatt Macy {
8824eda14cbcSMatt Macy 	zfs_project_control_t zpc = {
8825eda14cbcSMatt Macy 		.zpc_expected_projid = ZFS_INVALID_PROJID,
8826eda14cbcSMatt Macy 		.zpc_op = ZFS_PROJECT_OP_DEFAULT,
8827eda14cbcSMatt Macy 		.zpc_dironly = B_FALSE,
8828eda14cbcSMatt Macy 		.zpc_keep_projid = B_FALSE,
8829eda14cbcSMatt Macy 		.zpc_newline = B_TRUE,
8830eda14cbcSMatt Macy 		.zpc_recursive = B_FALSE,
8831eda14cbcSMatt Macy 		.zpc_set_flag = B_FALSE,
8832eda14cbcSMatt Macy 	};
8833eda14cbcSMatt Macy 	int ret = 0, c;
8834eda14cbcSMatt Macy 
8835eda14cbcSMatt Macy 	if (argc < 2)
8836eda14cbcSMatt Macy 		usage(B_FALSE);
8837eda14cbcSMatt Macy 
8838eda14cbcSMatt Macy 	while ((c = getopt(argc, argv, "0Ccdkp:rs")) != -1) {
8839eda14cbcSMatt Macy 		switch (c) {
8840eda14cbcSMatt Macy 		case '0':
8841eda14cbcSMatt Macy 			zpc.zpc_newline = B_FALSE;
8842eda14cbcSMatt Macy 			break;
8843eda14cbcSMatt Macy 		case 'C':
8844eda14cbcSMatt Macy 			if (zpc.zpc_op != ZFS_PROJECT_OP_DEFAULT) {
8845eda14cbcSMatt Macy 				(void) fprintf(stderr, gettext("cannot "
8846eda14cbcSMatt Macy 				    "specify '-C' '-c' '-s' together\n"));
8847eda14cbcSMatt Macy 				usage(B_FALSE);
8848eda14cbcSMatt Macy 			}
8849eda14cbcSMatt Macy 
8850eda14cbcSMatt Macy 			zpc.zpc_op = ZFS_PROJECT_OP_CLEAR;
8851eda14cbcSMatt Macy 			break;
8852eda14cbcSMatt Macy 		case 'c':
8853eda14cbcSMatt Macy 			if (zpc.zpc_op != ZFS_PROJECT_OP_DEFAULT) {
8854eda14cbcSMatt Macy 				(void) fprintf(stderr, gettext("cannot "
8855eda14cbcSMatt Macy 				    "specify '-C' '-c' '-s' together\n"));
8856eda14cbcSMatt Macy 				usage(B_FALSE);
8857eda14cbcSMatt Macy 			}
8858eda14cbcSMatt Macy 
8859eda14cbcSMatt Macy 			zpc.zpc_op = ZFS_PROJECT_OP_CHECK;
8860eda14cbcSMatt Macy 			break;
8861eda14cbcSMatt Macy 		case 'd':
8862eda14cbcSMatt Macy 			zpc.zpc_dironly = B_TRUE;
8863eda14cbcSMatt Macy 			/* overwrite "-r" option */
8864eda14cbcSMatt Macy 			zpc.zpc_recursive = B_FALSE;
8865eda14cbcSMatt Macy 			break;
8866eda14cbcSMatt Macy 		case 'k':
8867eda14cbcSMatt Macy 			zpc.zpc_keep_projid = B_TRUE;
8868eda14cbcSMatt Macy 			break;
8869eda14cbcSMatt Macy 		case 'p': {
8870eda14cbcSMatt Macy 			char *endptr;
8871eda14cbcSMatt Macy 
8872eda14cbcSMatt Macy 			errno = 0;
8873eda14cbcSMatt Macy 			zpc.zpc_expected_projid = strtoull(optarg, &endptr, 0);
8874eda14cbcSMatt Macy 			if (errno != 0 || *endptr != '\0') {
8875eda14cbcSMatt Macy 				(void) fprintf(stderr,
8876eda14cbcSMatt Macy 				    gettext("project ID must be less than "
8877eda14cbcSMatt Macy 				    "%u\n"), UINT32_MAX);
8878eda14cbcSMatt Macy 				usage(B_FALSE);
8879eda14cbcSMatt Macy 			}
8880eda14cbcSMatt Macy 			if (zpc.zpc_expected_projid >= UINT32_MAX) {
8881eda14cbcSMatt Macy 				(void) fprintf(stderr,
8882eda14cbcSMatt Macy 				    gettext("invalid project ID\n"));
8883eda14cbcSMatt Macy 				usage(B_FALSE);
8884eda14cbcSMatt Macy 			}
8885eda14cbcSMatt Macy 			break;
8886eda14cbcSMatt Macy 		}
8887eda14cbcSMatt Macy 		case 'r':
8888eda14cbcSMatt Macy 			zpc.zpc_recursive = B_TRUE;
8889eda14cbcSMatt Macy 			/* overwrite "-d" option */
8890eda14cbcSMatt Macy 			zpc.zpc_dironly = B_FALSE;
8891eda14cbcSMatt Macy 			break;
8892eda14cbcSMatt Macy 		case 's':
8893eda14cbcSMatt Macy 			if (zpc.zpc_op != ZFS_PROJECT_OP_DEFAULT) {
8894eda14cbcSMatt Macy 				(void) fprintf(stderr, gettext("cannot "
8895eda14cbcSMatt Macy 				    "specify '-C' '-c' '-s' together\n"));
8896eda14cbcSMatt Macy 				usage(B_FALSE);
8897eda14cbcSMatt Macy 			}
8898eda14cbcSMatt Macy 
8899eda14cbcSMatt Macy 			zpc.zpc_set_flag = B_TRUE;
8900eda14cbcSMatt Macy 			zpc.zpc_op = ZFS_PROJECT_OP_SET;
8901eda14cbcSMatt Macy 			break;
8902eda14cbcSMatt Macy 		default:
8903eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
8904eda14cbcSMatt Macy 			    optopt);
8905eda14cbcSMatt Macy 			usage(B_FALSE);
8906eda14cbcSMatt Macy 		}
8907eda14cbcSMatt Macy 	}
8908eda14cbcSMatt Macy 
8909eda14cbcSMatt Macy 	if (zpc.zpc_op == ZFS_PROJECT_OP_DEFAULT) {
8910eda14cbcSMatt Macy 		if (zpc.zpc_expected_projid != ZFS_INVALID_PROJID)
8911eda14cbcSMatt Macy 			zpc.zpc_op = ZFS_PROJECT_OP_SET;
8912eda14cbcSMatt Macy 		else
8913eda14cbcSMatt Macy 			zpc.zpc_op = ZFS_PROJECT_OP_LIST;
8914eda14cbcSMatt Macy 	}
8915eda14cbcSMatt Macy 
8916eda14cbcSMatt Macy 	switch (zpc.zpc_op) {
8917eda14cbcSMatt Macy 	case ZFS_PROJECT_OP_LIST:
8918eda14cbcSMatt Macy 		if (zpc.zpc_keep_projid) {
8919eda14cbcSMatt Macy 			(void) fprintf(stderr,
8920eda14cbcSMatt Macy 			    gettext("'-k' is only valid together with '-C'\n"));
8921eda14cbcSMatt Macy 			usage(B_FALSE);
8922eda14cbcSMatt Macy 		}
8923eda14cbcSMatt Macy 		if (!zpc.zpc_newline) {
8924eda14cbcSMatt Macy 			(void) fprintf(stderr,
8925eda14cbcSMatt Macy 			    gettext("'-0' is only valid together with '-c'\n"));
8926eda14cbcSMatt Macy 			usage(B_FALSE);
8927eda14cbcSMatt Macy 		}
8928eda14cbcSMatt Macy 		break;
8929eda14cbcSMatt Macy 	case ZFS_PROJECT_OP_CHECK:
8930eda14cbcSMatt Macy 		if (zpc.zpc_keep_projid) {
8931eda14cbcSMatt Macy 			(void) fprintf(stderr,
8932eda14cbcSMatt Macy 			    gettext("'-k' is only valid together with '-C'\n"));
8933eda14cbcSMatt Macy 			usage(B_FALSE);
8934eda14cbcSMatt Macy 		}
8935eda14cbcSMatt Macy 		break;
8936eda14cbcSMatt Macy 	case ZFS_PROJECT_OP_CLEAR:
8937eda14cbcSMatt Macy 		if (zpc.zpc_dironly) {
8938eda14cbcSMatt Macy 			(void) fprintf(stderr,
8939eda14cbcSMatt Macy 			    gettext("'-d' is useless together with '-C'\n"));
8940eda14cbcSMatt Macy 			usage(B_FALSE);
8941eda14cbcSMatt Macy 		}
8942eda14cbcSMatt Macy 		if (!zpc.zpc_newline) {
8943eda14cbcSMatt Macy 			(void) fprintf(stderr,
8944eda14cbcSMatt Macy 			    gettext("'-0' is only valid together with '-c'\n"));
8945eda14cbcSMatt Macy 			usage(B_FALSE);
8946eda14cbcSMatt Macy 		}
8947eda14cbcSMatt Macy 		if (zpc.zpc_expected_projid != ZFS_INVALID_PROJID) {
8948eda14cbcSMatt Macy 			(void) fprintf(stderr,
8949eda14cbcSMatt Macy 			    gettext("'-p' is useless together with '-C'\n"));
8950eda14cbcSMatt Macy 			usage(B_FALSE);
8951eda14cbcSMatt Macy 		}
8952eda14cbcSMatt Macy 		break;
8953eda14cbcSMatt Macy 	case ZFS_PROJECT_OP_SET:
8954eda14cbcSMatt Macy 		if (zpc.zpc_dironly) {
8955eda14cbcSMatt Macy 			(void) fprintf(stderr,
8956eda14cbcSMatt Macy 			    gettext("'-d' is useless for set project ID and/or "
8957eda14cbcSMatt Macy 			    "inherit flag\n"));
8958eda14cbcSMatt Macy 			usage(B_FALSE);
8959eda14cbcSMatt Macy 		}
8960eda14cbcSMatt Macy 		if (zpc.zpc_keep_projid) {
8961eda14cbcSMatt Macy 			(void) fprintf(stderr,
8962eda14cbcSMatt Macy 			    gettext("'-k' is only valid together with '-C'\n"));
8963eda14cbcSMatt Macy 			usage(B_FALSE);
8964eda14cbcSMatt Macy 		}
8965eda14cbcSMatt Macy 		if (!zpc.zpc_newline) {
8966eda14cbcSMatt Macy 			(void) fprintf(stderr,
8967eda14cbcSMatt Macy 			    gettext("'-0' is only valid together with '-c'\n"));
8968eda14cbcSMatt Macy 			usage(B_FALSE);
8969eda14cbcSMatt Macy 		}
8970eda14cbcSMatt Macy 		break;
8971eda14cbcSMatt Macy 	default:
8972eda14cbcSMatt Macy 		ASSERT(0);
8973eda14cbcSMatt Macy 		break;
8974eda14cbcSMatt Macy 	}
8975eda14cbcSMatt Macy 
8976eda14cbcSMatt Macy 	argv += optind;
8977eda14cbcSMatt Macy 	argc -= optind;
8978eda14cbcSMatt Macy 	if (argc == 0) {
8979eda14cbcSMatt Macy 		(void) fprintf(stderr,
8980eda14cbcSMatt Macy 		    gettext("missing file or directory target(s)\n"));
8981eda14cbcSMatt Macy 		usage(B_FALSE);
8982eda14cbcSMatt Macy 	}
8983eda14cbcSMatt Macy 
8984eda14cbcSMatt Macy 	for (int i = 0; i < argc; i++) {
8985eda14cbcSMatt Macy 		int err;
8986eda14cbcSMatt Macy 
8987eda14cbcSMatt Macy 		err = zfs_project_handle(argv[i], &zpc);
8988eda14cbcSMatt Macy 		if (err && !ret)
8989eda14cbcSMatt Macy 			ret = err;
8990eda14cbcSMatt Macy 	}
8991eda14cbcSMatt Macy 
8992eda14cbcSMatt Macy 	return (ret);
8993eda14cbcSMatt Macy }
8994eda14cbcSMatt Macy 
8995eda14cbcSMatt Macy static int
8996eda14cbcSMatt Macy zfs_do_wait(int argc, char **argv)
8997eda14cbcSMatt Macy {
8998eda14cbcSMatt Macy 	boolean_t enabled[ZFS_WAIT_NUM_ACTIVITIES];
8999dbd5678dSMartin Matuska 	int error = 0, i;
90007877fdebSMatt Macy 	int c;
9001eda14cbcSMatt Macy 
9002eda14cbcSMatt Macy 	/* By default, wait for all types of activity. */
9003eda14cbcSMatt Macy 	for (i = 0; i < ZFS_WAIT_NUM_ACTIVITIES; i++)
9004eda14cbcSMatt Macy 		enabled[i] = B_TRUE;
9005eda14cbcSMatt Macy 
9006eda14cbcSMatt Macy 	while ((c = getopt(argc, argv, "t:")) != -1) {
9007eda14cbcSMatt Macy 		switch (c) {
9008eda14cbcSMatt Macy 		case 't':
9009eda14cbcSMatt Macy 			/* Reset activities array */
9010da5137abSMartin Matuska 			memset(&enabled, 0, sizeof (enabled));
9011eda14cbcSMatt Macy 
9012da5137abSMartin Matuska 			for (char *tok; (tok = strsep(&optarg, ",")); ) {
9013da5137abSMartin Matuska 				static const char *const col_subopts[
9014da5137abSMartin Matuska 				    ZFS_WAIT_NUM_ACTIVITIES] = { "deleteq" };
9015da5137abSMartin Matuska 
9016da5137abSMartin Matuska 				for (i = 0; i < ARRAY_SIZE(col_subopts); ++i)
9017da5137abSMartin Matuska 					if (strcmp(tok, col_subopts[i]) == 0) {
9018da5137abSMartin Matuska 						enabled[i] = B_TRUE;
9019da5137abSMartin Matuska 						goto found;
9020eda14cbcSMatt Macy 					}
9021eda14cbcSMatt Macy 
9022da5137abSMartin Matuska 				(void) fprintf(stderr,
9023da5137abSMartin Matuska 				    gettext("invalid activity '%s'\n"), tok);
9024da5137abSMartin Matuska 				usage(B_FALSE);
9025da5137abSMartin Matuska found:;
9026eda14cbcSMatt Macy 			}
9027eda14cbcSMatt Macy 			break;
9028eda14cbcSMatt Macy 		case '?':
9029eda14cbcSMatt Macy 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
9030eda14cbcSMatt Macy 			    optopt);
9031eda14cbcSMatt Macy 			usage(B_FALSE);
9032eda14cbcSMatt Macy 		}
9033eda14cbcSMatt Macy 	}
9034eda14cbcSMatt Macy 
9035eda14cbcSMatt Macy 	argv += optind;
9036eda14cbcSMatt Macy 	argc -= optind;
9037eda14cbcSMatt Macy 	if (argc < 1) {
9038eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("missing 'filesystem' "
9039eda14cbcSMatt Macy 		    "argument\n"));
9040eda14cbcSMatt Macy 		usage(B_FALSE);
9041eda14cbcSMatt Macy 	}
9042eda14cbcSMatt Macy 	if (argc > 1) {
9043eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("too many arguments\n"));
9044eda14cbcSMatt Macy 		usage(B_FALSE);
9045eda14cbcSMatt Macy 	}
9046eda14cbcSMatt Macy 
9047eda14cbcSMatt Macy 	zfs_handle_t *zhp = zfs_open(g_zfs, argv[0], ZFS_TYPE_FILESYSTEM);
9048eda14cbcSMatt Macy 	if (zhp == NULL)
9049eda14cbcSMatt Macy 		return (1);
9050eda14cbcSMatt Macy 
9051eda14cbcSMatt Macy 	for (;;) {
9052eda14cbcSMatt Macy 		boolean_t missing = B_FALSE;
9053eda14cbcSMatt Macy 		boolean_t any_waited = B_FALSE;
9054eda14cbcSMatt Macy 
9055eda14cbcSMatt Macy 		for (int i = 0; i < ZFS_WAIT_NUM_ACTIVITIES; i++) {
9056eda14cbcSMatt Macy 			boolean_t waited;
9057eda14cbcSMatt Macy 
9058eda14cbcSMatt Macy 			if (!enabled[i])
9059eda14cbcSMatt Macy 				continue;
9060eda14cbcSMatt Macy 
9061eda14cbcSMatt Macy 			error = zfs_wait_status(zhp, i, &missing, &waited);
9062eda14cbcSMatt Macy 			if (error != 0 || missing)
9063eda14cbcSMatt Macy 				break;
9064eda14cbcSMatt Macy 
9065eda14cbcSMatt Macy 			any_waited = (any_waited || waited);
9066eda14cbcSMatt Macy 		}
9067eda14cbcSMatt Macy 
9068eda14cbcSMatt Macy 		if (error != 0 || missing || !any_waited)
9069eda14cbcSMatt Macy 			break;
9070eda14cbcSMatt Macy 	}
9071eda14cbcSMatt Macy 
9072eda14cbcSMatt Macy 	zfs_close(zhp);
9073eda14cbcSMatt Macy 
9074eda14cbcSMatt Macy 	return (error);
9075eda14cbcSMatt Macy }
9076eda14cbcSMatt Macy 
9077eda14cbcSMatt Macy /*
9078eda14cbcSMatt Macy  * Display version message
9079eda14cbcSMatt Macy  */
9080eda14cbcSMatt Macy static int
9081eda14cbcSMatt Macy zfs_do_version(int argc, char **argv)
9082eda14cbcSMatt Macy {
9083*ce4dcb97SMartin Matuska 	int c;
9084*ce4dcb97SMartin Matuska 	nvlist_t *jsobj = NULL, *zfs_ver = NULL;
9085*ce4dcb97SMartin Matuska 	boolean_t json = B_FALSE;
9086*ce4dcb97SMartin Matuska 	while ((c = getopt(argc, argv, "j")) != -1) {
9087*ce4dcb97SMartin Matuska 		switch (c) {
9088*ce4dcb97SMartin Matuska 		case 'j':
9089*ce4dcb97SMartin Matuska 			json = B_TRUE;
9090*ce4dcb97SMartin Matuska 			jsobj = zfs_json_schema(0, 1);
9091*ce4dcb97SMartin Matuska 			break;
9092*ce4dcb97SMartin Matuska 		case '?':
9093*ce4dcb97SMartin Matuska 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
9094*ce4dcb97SMartin Matuska 			    optopt);
9095*ce4dcb97SMartin Matuska 			usage(B_FALSE);
9096*ce4dcb97SMartin Matuska 		}
9097*ce4dcb97SMartin Matuska 	}
9098*ce4dcb97SMartin Matuska 
9099*ce4dcb97SMartin Matuska 	argc -= optind;
9100*ce4dcb97SMartin Matuska 	if (argc != 0) {
9101*ce4dcb97SMartin Matuska 		(void) fprintf(stderr, "too many arguments\n");
9102*ce4dcb97SMartin Matuska 		usage(B_FALSE);
9103*ce4dcb97SMartin Matuska 	}
9104*ce4dcb97SMartin Matuska 
9105*ce4dcb97SMartin Matuska 	if (json) {
9106*ce4dcb97SMartin Matuska 		zfs_ver = zfs_version_nvlist();
9107*ce4dcb97SMartin Matuska 		if (zfs_ver) {
9108*ce4dcb97SMartin Matuska 			fnvlist_add_nvlist(jsobj, "zfs_version", zfs_ver);
9109*ce4dcb97SMartin Matuska 			zcmd_print_json(jsobj);
9110*ce4dcb97SMartin Matuska 			fnvlist_free(zfs_ver);
9111*ce4dcb97SMartin Matuska 			return (0);
9112*ce4dcb97SMartin Matuska 		} else
9113*ce4dcb97SMartin Matuska 			return (-1);
9114*ce4dcb97SMartin Matuska 	} else
9115e3aa18adSMartin Matuska 		return (zfs_version_print() != 0);
9116eda14cbcSMatt Macy }
9117eda14cbcSMatt Macy 
9118cbfe9975SMartin Matuska /* Display documentation */
9119cbfe9975SMartin Matuska static int
9120cbfe9975SMartin Matuska zfs_do_help(int argc, char **argv)
9121cbfe9975SMartin Matuska {
9122cbfe9975SMartin Matuska 	char page[MAXNAMELEN];
9123cbfe9975SMartin Matuska 	if (argc < 3 || strcmp(argv[2], "zfs") == 0)
9124cbfe9975SMartin Matuska 		strcpy(page, "zfs");
9125cbfe9975SMartin Matuska 	else if (strcmp(argv[2], "concepts") == 0 ||
9126cbfe9975SMartin Matuska 	    strcmp(argv[2], "props") == 0)
9127cbfe9975SMartin Matuska 		snprintf(page, sizeof (page), "zfs%s", argv[2]);
9128cbfe9975SMartin Matuska 	else
9129cbfe9975SMartin Matuska 		snprintf(page, sizeof (page), "zfs-%s", argv[2]);
9130cbfe9975SMartin Matuska 
9131cbfe9975SMartin Matuska 	execlp("man", "man", page, NULL);
9132cbfe9975SMartin Matuska 
9133cbfe9975SMartin Matuska 	fprintf(stderr, "couldn't run man program: %s", strerror(errno));
9134cbfe9975SMartin Matuska 	return (-1);
9135cbfe9975SMartin Matuska }
9136cbfe9975SMartin Matuska 
9137eda14cbcSMatt Macy int
9138eda14cbcSMatt Macy main(int argc, char **argv)
9139eda14cbcSMatt Macy {
9140eda14cbcSMatt Macy 	int ret = 0;
9141eda14cbcSMatt Macy 	int i = 0;
9142a0b956f5SMartin Matuska 	const char *cmdname;
9143eda14cbcSMatt Macy 	char **newargv;
9144eda14cbcSMatt Macy 
9145eda14cbcSMatt Macy 	(void) setlocale(LC_ALL, "");
91462c48331dSMatt Macy 	(void) setlocale(LC_NUMERIC, "C");
9147eda14cbcSMatt Macy 	(void) textdomain(TEXT_DOMAIN);
9148eda14cbcSMatt Macy 
9149eda14cbcSMatt Macy 	opterr = 0;
9150eda14cbcSMatt Macy 
9151eda14cbcSMatt Macy 	/*
9152eda14cbcSMatt Macy 	 * Make sure the user has specified some command.
9153eda14cbcSMatt Macy 	 */
9154eda14cbcSMatt Macy 	if (argc < 2) {
9155eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("missing command\n"));
9156eda14cbcSMatt Macy 		usage(B_FALSE);
9157eda14cbcSMatt Macy 	}
9158eda14cbcSMatt Macy 
9159eda14cbcSMatt Macy 	cmdname = argv[1];
9160eda14cbcSMatt Macy 
9161eda14cbcSMatt Macy 	/*
9162eda14cbcSMatt Macy 	 * The 'umount' command is an alias for 'unmount'
9163eda14cbcSMatt Macy 	 */
9164eda14cbcSMatt Macy 	if (strcmp(cmdname, "umount") == 0)
9165eda14cbcSMatt Macy 		cmdname = "unmount";
9166eda14cbcSMatt Macy 
9167eda14cbcSMatt Macy 	/*
9168eda14cbcSMatt Macy 	 * The 'recv' command is an alias for 'receive'
9169eda14cbcSMatt Macy 	 */
9170eda14cbcSMatt Macy 	if (strcmp(cmdname, "recv") == 0)
9171eda14cbcSMatt Macy 		cmdname = "receive";
9172eda14cbcSMatt Macy 
9173eda14cbcSMatt Macy 	/*
9174eda14cbcSMatt Macy 	 * The 'snap' command is an alias for 'snapshot'
9175eda14cbcSMatt Macy 	 */
9176eda14cbcSMatt Macy 	if (strcmp(cmdname, "snap") == 0)
9177eda14cbcSMatt Macy 		cmdname = "snapshot";
9178eda14cbcSMatt Macy 
9179eda14cbcSMatt Macy 	/*
9180eda14cbcSMatt Macy 	 * Special case '-?'
9181eda14cbcSMatt Macy 	 */
9182eda14cbcSMatt Macy 	if ((strcmp(cmdname, "-?") == 0) ||
9183eda14cbcSMatt Macy 	    (strcmp(cmdname, "--help") == 0))
9184eda14cbcSMatt Macy 		usage(B_TRUE);
9185eda14cbcSMatt Macy 
9186eda14cbcSMatt Macy 	/*
9187eda14cbcSMatt Macy 	 * Special case '-V|--version'
9188eda14cbcSMatt Macy 	 */
9189eda14cbcSMatt Macy 	if ((strcmp(cmdname, "-V") == 0) || (strcmp(cmdname, "--version") == 0))
9190eda14cbcSMatt Macy 		return (zfs_do_version(argc, argv));
9191eda14cbcSMatt Macy 
9192cbfe9975SMartin Matuska 	/*
9193cbfe9975SMartin Matuska 	 * Special case 'help'
9194cbfe9975SMartin Matuska 	 */
9195cbfe9975SMartin Matuska 	if (strcmp(cmdname, "help") == 0)
9196cbfe9975SMartin Matuska 		return (zfs_do_help(argc, argv));
9197cbfe9975SMartin Matuska 
9198eda14cbcSMatt Macy 	if ((g_zfs = libzfs_init()) == NULL) {
9199eda14cbcSMatt Macy 		(void) fprintf(stderr, "%s\n", libzfs_error_init(errno));
9200eda14cbcSMatt Macy 		return (1);
9201eda14cbcSMatt Macy 	}
9202eda14cbcSMatt Macy 
9203eda14cbcSMatt Macy 	zfs_save_arguments(argc, argv, history_str, sizeof (history_str));
9204eda14cbcSMatt Macy 
9205eda14cbcSMatt Macy 	libzfs_print_on_error(g_zfs, B_TRUE);
9206eda14cbcSMatt Macy 
920715f0b8c3SMartin Matuska 	zfs_setproctitle_init(argc, argv, environ);
920815f0b8c3SMartin Matuska 
9209eda14cbcSMatt Macy 	/*
9210eda14cbcSMatt Macy 	 * Many commands modify input strings for string parsing reasons.
9211eda14cbcSMatt Macy 	 * We create a copy to protect the original argv.
9212eda14cbcSMatt Macy 	 */
9213716fd348SMartin Matuska 	newargv = safe_malloc((argc + 1) * sizeof (newargv[0]));
9214eda14cbcSMatt Macy 	for (i = 0; i < argc; i++)
9215eda14cbcSMatt Macy 		newargv[i] = strdup(argv[i]);
9216eda14cbcSMatt Macy 	newargv[argc] = NULL;
9217eda14cbcSMatt Macy 
9218eda14cbcSMatt Macy 	/*
9219eda14cbcSMatt Macy 	 * Run the appropriate command.
9220eda14cbcSMatt Macy 	 */
9221eda14cbcSMatt Macy 	libzfs_mnttab_cache(g_zfs, B_TRUE);
9222eda14cbcSMatt Macy 	if (find_command_idx(cmdname, &i) == 0) {
9223eda14cbcSMatt Macy 		current_command = &command_table[i];
9224eda14cbcSMatt Macy 		ret = command_table[i].func(argc - 1, newargv + 1);
9225eda14cbcSMatt Macy 	} else if (strchr(cmdname, '=') != NULL) {
9226eda14cbcSMatt Macy 		verify(find_command_idx("set", &i) == 0);
9227eda14cbcSMatt Macy 		current_command = &command_table[i];
9228eda14cbcSMatt Macy 		ret = command_table[i].func(argc, newargv);
9229eda14cbcSMatt Macy 	} else {
9230eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("unrecognized "
9231eda14cbcSMatt Macy 		    "command '%s'\n"), cmdname);
9232eda14cbcSMatt Macy 		usage(B_FALSE);
9233eda14cbcSMatt Macy 		ret = 1;
9234eda14cbcSMatt Macy 	}
9235eda14cbcSMatt Macy 
9236eda14cbcSMatt Macy 	for (i = 0; i < argc; i++)
9237eda14cbcSMatt Macy 		free(newargv[i]);
9238eda14cbcSMatt Macy 	free(newargv);
9239eda14cbcSMatt Macy 
9240eda14cbcSMatt Macy 	if (ret == 0 && log_history)
9241eda14cbcSMatt Macy 		(void) zpool_log_history(g_zfs, history_str);
9242eda14cbcSMatt Macy 
9243eda14cbcSMatt Macy 	libzfs_fini(g_zfs);
9244eda14cbcSMatt Macy 
9245eda14cbcSMatt Macy 	/*
9246eda14cbcSMatt Macy 	 * The 'ZFS_ABORT' environment variable causes us to dump core on exit
9247eda14cbcSMatt Macy 	 * for the purposes of running ::findleaks.
9248eda14cbcSMatt Macy 	 */
9249eda14cbcSMatt Macy 	if (getenv("ZFS_ABORT") != NULL) {
9250eda14cbcSMatt Macy 		(void) printf("dumping core by request\n");
9251eda14cbcSMatt Macy 		abort();
9252eda14cbcSMatt Macy 	}
9253eda14cbcSMatt Macy 
9254eda14cbcSMatt Macy 	return (ret);
9255eda14cbcSMatt Macy }
9256eda14cbcSMatt Macy 
92571f1e2261SMartin Matuska /*
92581f1e2261SMartin Matuska  * zfs zone nsfile filesystem
92591f1e2261SMartin Matuska  *
92601f1e2261SMartin Matuska  * Add or delete the given dataset to/from the namespace.
92611f1e2261SMartin Matuska  */
92621f1e2261SMartin Matuska #ifdef __linux__
92631f1e2261SMartin Matuska static int
92641f1e2261SMartin Matuska zfs_do_zone_impl(int argc, char **argv, boolean_t attach)
92651f1e2261SMartin Matuska {
92661f1e2261SMartin Matuska 	zfs_handle_t *zhp;
92671f1e2261SMartin Matuska 	int ret;
92681f1e2261SMartin Matuska 
92691f1e2261SMartin Matuska 	if (argc < 3) {
92701f1e2261SMartin Matuska 		(void) fprintf(stderr, gettext("missing argument(s)\n"));
92711f1e2261SMartin Matuska 		usage(B_FALSE);
92721f1e2261SMartin Matuska 	}
92731f1e2261SMartin Matuska 	if (argc > 3) {
92741f1e2261SMartin Matuska 		(void) fprintf(stderr, gettext("too many arguments\n"));
92751f1e2261SMartin Matuska 		usage(B_FALSE);
92761f1e2261SMartin Matuska 	}
92771f1e2261SMartin Matuska 
92781f1e2261SMartin Matuska 	zhp = zfs_open(g_zfs, argv[2], ZFS_TYPE_FILESYSTEM);
92791f1e2261SMartin Matuska 	if (zhp == NULL)
92801f1e2261SMartin Matuska 		return (1);
92811f1e2261SMartin Matuska 
92821f1e2261SMartin Matuska 	ret = (zfs_userns(zhp, argv[1], attach) != 0);
92831f1e2261SMartin Matuska 
92841f1e2261SMartin Matuska 	zfs_close(zhp);
92851f1e2261SMartin Matuska 	return (ret);
92861f1e2261SMartin Matuska }
92871f1e2261SMartin Matuska 
92881f1e2261SMartin Matuska static int
92891f1e2261SMartin Matuska zfs_do_zone(int argc, char **argv)
92901f1e2261SMartin Matuska {
92911f1e2261SMartin Matuska 	return (zfs_do_zone_impl(argc, argv, B_TRUE));
92921f1e2261SMartin Matuska }
92931f1e2261SMartin Matuska 
92941f1e2261SMartin Matuska static int
92951f1e2261SMartin Matuska zfs_do_unzone(int argc, char **argv)
92961f1e2261SMartin Matuska {
92971f1e2261SMartin Matuska 	return (zfs_do_zone_impl(argc, argv, B_FALSE));
92981f1e2261SMartin Matuska }
92991f1e2261SMartin Matuska #endif
93001f1e2261SMartin Matuska 
9301eda14cbcSMatt Macy #ifdef __FreeBSD__
9302eda14cbcSMatt Macy #include <sys/jail.h>
9303eda14cbcSMatt Macy #include <jail.h>
9304eda14cbcSMatt Macy /*
9305eda14cbcSMatt Macy  * Attach/detach the given dataset to/from the given jail
9306eda14cbcSMatt Macy  */
9307eda14cbcSMatt Macy static int
9308eda14cbcSMatt Macy zfs_do_jail_impl(int argc, char **argv, boolean_t attach)
9309eda14cbcSMatt Macy {
9310eda14cbcSMatt Macy 	zfs_handle_t *zhp;
9311eda14cbcSMatt Macy 	int jailid, ret;
9312eda14cbcSMatt Macy 
9313eda14cbcSMatt Macy 	/* check number of arguments */
9314eda14cbcSMatt Macy 	if (argc < 3) {
9315eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("missing argument(s)\n"));
9316eda14cbcSMatt Macy 		usage(B_FALSE);
9317eda14cbcSMatt Macy 	}
9318eda14cbcSMatt Macy 	if (argc > 3) {
9319eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("too many arguments\n"));
9320eda14cbcSMatt Macy 		usage(B_FALSE);
9321eda14cbcSMatt Macy 	}
9322eda14cbcSMatt Macy 
9323eda14cbcSMatt Macy 	jailid = jail_getid(argv[1]);
9324eda14cbcSMatt Macy 	if (jailid < 0) {
9325eda14cbcSMatt Macy 		(void) fprintf(stderr, gettext("invalid jail id or name\n"));
9326eda14cbcSMatt Macy 		usage(B_FALSE);
9327eda14cbcSMatt Macy 	}
9328eda14cbcSMatt Macy 
9329eda14cbcSMatt Macy 	zhp = zfs_open(g_zfs, argv[2], ZFS_TYPE_FILESYSTEM);
9330eda14cbcSMatt Macy 	if (zhp == NULL)
9331eda14cbcSMatt Macy 		return (1);
9332eda14cbcSMatt Macy 
9333eda14cbcSMatt Macy 	ret = (zfs_jail(zhp, jailid, attach) != 0);
9334eda14cbcSMatt Macy 
9335eda14cbcSMatt Macy 	zfs_close(zhp);
9336eda14cbcSMatt Macy 	return (ret);
9337eda14cbcSMatt Macy }
9338eda14cbcSMatt Macy 
9339eda14cbcSMatt Macy /*
9340eda14cbcSMatt Macy  * zfs jail jailid filesystem
9341eda14cbcSMatt Macy  *
9342eda14cbcSMatt Macy  * Attach the given dataset to the given jail
9343eda14cbcSMatt Macy  */
9344eda14cbcSMatt Macy static int
9345eda14cbcSMatt Macy zfs_do_jail(int argc, char **argv)
9346eda14cbcSMatt Macy {
9347eda14cbcSMatt Macy 	return (zfs_do_jail_impl(argc, argv, B_TRUE));
9348eda14cbcSMatt Macy }
9349eda14cbcSMatt Macy 
9350eda14cbcSMatt Macy /*
9351eda14cbcSMatt Macy  * zfs unjail jailid filesystem
9352eda14cbcSMatt Macy  *
9353eda14cbcSMatt Macy  * Detach the given dataset from the given jail
9354eda14cbcSMatt Macy  */
9355eda14cbcSMatt Macy static int
9356eda14cbcSMatt Macy zfs_do_unjail(int argc, char **argv)
9357eda14cbcSMatt Macy {
9358eda14cbcSMatt Macy 	return (zfs_do_jail_impl(argc, argv, B_FALSE));
9359eda14cbcSMatt Macy }
9360eda14cbcSMatt Macy #endif
9361