xref: /titanic_50/usr/src/cmd/zfs/zfs_main.c (revision 55b04f29c323ed82101153bca072045450b7acd2)
1fa9e4066Sahrens /*
2fa9e4066Sahrens  * CDDL HEADER START
3fa9e4066Sahrens  *
4fa9e4066Sahrens  * The contents of this file are subject to the terms of the
5ea8dc4b6Seschrock  * Common Development and Distribution License (the "License").
6ea8dc4b6Seschrock  * You may not use this file except in compliance with the License.
7fa9e4066Sahrens  *
8fa9e4066Sahrens  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9fa9e4066Sahrens  * or http://www.opensolaris.org/os/licensing.
10fa9e4066Sahrens  * See the License for the specific language governing permissions
11fa9e4066Sahrens  * and limitations under the License.
12fa9e4066Sahrens  *
13fa9e4066Sahrens  * When distributing Covered Code, include this CDDL HEADER in each
14fa9e4066Sahrens  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15fa9e4066Sahrens  * If applicable, add the following below this CDDL HEADER, with the
16fa9e4066Sahrens  * fields enclosed by brackets "[]" replaced with your own identifying
17fa9e4066Sahrens  * information: Portions Copyright [yyyy] [name of copyright owner]
18fa9e4066Sahrens  *
19fa9e4066Sahrens  * CDDL HEADER END
20fa9e4066Sahrens  */
21fa9e4066Sahrens /*
226b90ca48Slling  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
23fa9e4066Sahrens  * Use is subject to license terms.
24fa9e4066Sahrens  */
25fa9e4066Sahrens 
26fa9e4066Sahrens #pragma ident	"%Z%%M%	%I%	%E% SMI"
27fa9e4066Sahrens 
28fa9e4066Sahrens #include <assert.h>
29fa9e4066Sahrens #include <errno.h>
30fa9e4066Sahrens #include <libgen.h>
31fa9e4066Sahrens #include <libintl.h>
32fa9e4066Sahrens #include <libuutil.h>
33fa9e4066Sahrens #include <locale.h>
34fa9e4066Sahrens #include <stddef.h>
35fa9e4066Sahrens #include <stdio.h>
36fa9e4066Sahrens #include <stdlib.h>
37fa9e4066Sahrens #include <strings.h>
38fa9e4066Sahrens #include <unistd.h>
39fa9e4066Sahrens #include <fcntl.h>
40fa9e4066Sahrens #include <zone.h>
41fa9e4066Sahrens #include <sys/mkdev.h>
42fa9e4066Sahrens #include <sys/mntent.h>
43fa9e4066Sahrens #include <sys/mnttab.h>
44fa9e4066Sahrens #include <sys/mount.h>
45fa9e4066Sahrens #include <sys/stat.h>
46fa9e4066Sahrens 
47fa9e4066Sahrens #include <libzfs.h>
48fa9e4066Sahrens 
49fa9e4066Sahrens #include "zfs_iter.h"
5099653d4eSeschrock #include "zfs_util.h"
5199653d4eSeschrock 
5299653d4eSeschrock libzfs_handle_t *g_zfs;
53fa9e4066Sahrens 
54fa9e4066Sahrens static FILE *mnttab_file;
55fa9e4066Sahrens 
56fa9e4066Sahrens static int zfs_do_clone(int argc, char **argv);
57fa9e4066Sahrens static int zfs_do_create(int argc, char **argv);
58fa9e4066Sahrens static int zfs_do_destroy(int argc, char **argv);
59fa9e4066Sahrens static int zfs_do_get(int argc, char **argv);
60fa9e4066Sahrens static int zfs_do_inherit(int argc, char **argv);
61fa9e4066Sahrens static int zfs_do_list(int argc, char **argv);
62fa9e4066Sahrens static int zfs_do_mount(int argc, char **argv);
63fa9e4066Sahrens static int zfs_do_rename(int argc, char **argv);
64fa9e4066Sahrens static int zfs_do_rollback(int argc, char **argv);
65fa9e4066Sahrens static int zfs_do_set(int argc, char **argv);
66fa9e4066Sahrens static int zfs_do_snapshot(int argc, char **argv);
67fa9e4066Sahrens static int zfs_do_unmount(int argc, char **argv);
68fa9e4066Sahrens static int zfs_do_share(int argc, char **argv);
69fa9e4066Sahrens static int zfs_do_unshare(int argc, char **argv);
70f2a3c691Sahrens static int zfs_do_send(int argc, char **argv);
71f2a3c691Sahrens static int zfs_do_receive(int argc, char **argv);
7299653d4eSeschrock static int zfs_do_promote(int argc, char **argv);
73fa9e4066Sahrens 
74fa9e4066Sahrens /*
75fa9e4066Sahrens  * These libumem hooks provide a reasonable set of defaults for the allocator's
76fa9e4066Sahrens  * debugging facilities.
77fa9e4066Sahrens  */
78fa9e4066Sahrens const char *
79fa9e4066Sahrens _umem_debug_init()
80fa9e4066Sahrens {
81fa9e4066Sahrens 	return ("default,verbose"); /* $UMEM_DEBUG setting */
82fa9e4066Sahrens }
83fa9e4066Sahrens 
84fa9e4066Sahrens const char *
85fa9e4066Sahrens _umem_logging_init(void)
86fa9e4066Sahrens {
87fa9e4066Sahrens 	return ("fail,contents"); /* $UMEM_LOGGING setting */
88fa9e4066Sahrens }
89fa9e4066Sahrens 
9065cd9f28Seschrock typedef enum {
9165cd9f28Seschrock 	HELP_CLONE,
9265cd9f28Seschrock 	HELP_CREATE,
9365cd9f28Seschrock 	HELP_DESTROY,
9465cd9f28Seschrock 	HELP_GET,
9565cd9f28Seschrock 	HELP_INHERIT,
9665cd9f28Seschrock 	HELP_LIST,
9765cd9f28Seschrock 	HELP_MOUNT,
9899653d4eSeschrock 	HELP_PROMOTE,
99f2a3c691Sahrens 	HELP_RECEIVE,
10065cd9f28Seschrock 	HELP_RENAME,
10165cd9f28Seschrock 	HELP_ROLLBACK,
102f2a3c691Sahrens 	HELP_SEND,
10365cd9f28Seschrock 	HELP_SET,
10465cd9f28Seschrock 	HELP_SHARE,
10565cd9f28Seschrock 	HELP_SNAPSHOT,
10665cd9f28Seschrock 	HELP_UNMOUNT,
10765cd9f28Seschrock 	HELP_UNSHARE
10865cd9f28Seschrock } zfs_help_t;
10965cd9f28Seschrock 
110fa9e4066Sahrens typedef struct zfs_command {
111fa9e4066Sahrens 	const char	*name;
112fa9e4066Sahrens 	int		(*func)(int argc, char **argv);
11365cd9f28Seschrock 	zfs_help_t	usage;
114fa9e4066Sahrens } zfs_command_t;
115fa9e4066Sahrens 
116fa9e4066Sahrens /*
117fa9e4066Sahrens  * Master command table.  Each ZFS command has a name, associated function, and
118ea8dc4b6Seschrock  * usage message.  The usage messages need to be internationalized, so we have
119ea8dc4b6Seschrock  * to have a function to return the usage message based on a command index.
12065cd9f28Seschrock  *
12165cd9f28Seschrock  * These commands are organized according to how they are displayed in the usage
12265cd9f28Seschrock  * message.  An empty command (one with a NULL name) indicates an empty line in
12365cd9f28Seschrock  * the generic usage message.
124fa9e4066Sahrens  */
125fa9e4066Sahrens static zfs_command_t command_table[] = {
12665cd9f28Seschrock 	{ "create",	zfs_do_create,		HELP_CREATE		},
12765cd9f28Seschrock 	{ "destroy",	zfs_do_destroy,		HELP_DESTROY		},
128fa9e4066Sahrens 	{ NULL },
12965cd9f28Seschrock 	{ "snapshot",	zfs_do_snapshot,	HELP_SNAPSHOT		},
13065cd9f28Seschrock 	{ "rollback",	zfs_do_rollback,	HELP_ROLLBACK		},
13165cd9f28Seschrock 	{ "clone",	zfs_do_clone,		HELP_CLONE		},
13299653d4eSeschrock 	{ "promote",	zfs_do_promote,		HELP_PROMOTE		},
13365cd9f28Seschrock 	{ "rename",	zfs_do_rename,		HELP_RENAME		},
134fa9e4066Sahrens 	{ NULL },
13565cd9f28Seschrock 	{ "list",	zfs_do_list,		HELP_LIST		},
136fa9e4066Sahrens 	{ NULL },
13765cd9f28Seschrock 	{ "set",	zfs_do_set,		HELP_SET		},
13865cd9f28Seschrock 	{ "get", 	zfs_do_get,		HELP_GET		},
13965cd9f28Seschrock 	{ "inherit",	zfs_do_inherit,		HELP_INHERIT		},
140fa9e4066Sahrens 	{ NULL },
14165cd9f28Seschrock 	{ "mount",	zfs_do_mount,		HELP_MOUNT		},
142fa9e4066Sahrens 	{ NULL },
14365cd9f28Seschrock 	{ "unmount",	zfs_do_unmount,		HELP_UNMOUNT		},
144fa9e4066Sahrens 	{ NULL },
14565cd9f28Seschrock 	{ "share",	zfs_do_share,		HELP_SHARE		},
146fa9e4066Sahrens 	{ NULL },
14765cd9f28Seschrock 	{ "unshare",	zfs_do_unshare,		HELP_UNSHARE		},
148fa9e4066Sahrens 	{ NULL },
149f2a3c691Sahrens 	{ "send",	zfs_do_send,		HELP_SEND		},
150f2a3c691Sahrens 	{ "receive",	zfs_do_receive,		HELP_RECEIVE		},
151fa9e4066Sahrens };
152fa9e4066Sahrens 
153fa9e4066Sahrens #define	NCOMMAND	(sizeof (command_table) / sizeof (command_table[0]))
154fa9e4066Sahrens 
155fa9e4066Sahrens zfs_command_t *current_command;
156fa9e4066Sahrens 
15765cd9f28Seschrock static const char *
15865cd9f28Seschrock get_usage(zfs_help_t idx)
15965cd9f28Seschrock {
16065cd9f28Seschrock 	switch (idx) {
16165cd9f28Seschrock 	case HELP_CLONE:
16265cd9f28Seschrock 		return (gettext("\tclone <snapshot> <filesystem|volume>\n"));
16365cd9f28Seschrock 	case HELP_CREATE:
16465cd9f28Seschrock 		return (gettext("\tcreate <filesystem>\n"
16565cd9f28Seschrock 		    "\tcreate [-s] [-b blocksize] -V <size> <volume>\n"));
16665cd9f28Seschrock 	case HELP_DESTROY:
16765cd9f28Seschrock 		return (gettext("\tdestroy [-rRf] "
16865cd9f28Seschrock 		    "<filesystem|volume|snapshot>\n"));
16965cd9f28Seschrock 	case HELP_GET:
17065cd9f28Seschrock 		return (gettext("\tget [-rHp] [-o field[,field]...] "
17165cd9f28Seschrock 		    "[-s source[,source]...]\n"
17265cd9f28Seschrock 		    "\t    <all | property[,property]...> "
17365cd9f28Seschrock 		    "<filesystem|volume|snapshot> ...\n"));
17465cd9f28Seschrock 	case HELP_INHERIT:
17565cd9f28Seschrock 		return (gettext("\tinherit [-r] <property> "
17665cd9f28Seschrock 		    "<filesystem|volume> ...\n"));
17765cd9f28Seschrock 	case HELP_LIST:
17865cd9f28Seschrock 		return (gettext("\tlist [-rH] [-o property[,property]...] "
17965cd9f28Seschrock 		    "[-t type[,type]...]\n"
18065cd9f28Seschrock 		    "\t    [filesystem|volume|snapshot] ...\n"));
18165cd9f28Seschrock 	case HELP_MOUNT:
18265cd9f28Seschrock 		return (gettext("\tmount\n"
18365cd9f28Seschrock 		    "\tmount [-o opts] [-O] -a\n"
18465cd9f28Seschrock 		    "\tmount [-o opts] [-O] <filesystem>\n"));
18599653d4eSeschrock 	case HELP_PROMOTE:
18699653d4eSeschrock 		return (gettext("\tpromote <clone filesystem>\n"));
187f2a3c691Sahrens 	case HELP_RECEIVE:
188f2a3c691Sahrens 		return (gettext("\treceive [-vn] <filesystem|volume|snapshot>\n"
189f2a3c691Sahrens 		    "\treceive [-vn] -d <filesystem>\n"));
19065cd9f28Seschrock 	case HELP_RENAME:
19165cd9f28Seschrock 		return (gettext("\trename <filesystem|volume|snapshot> "
19265cd9f28Seschrock 		    "<filesystem|volume|snapshot>\n"));
19365cd9f28Seschrock 	case HELP_ROLLBACK:
19465cd9f28Seschrock 		return (gettext("\trollback [-rRf] <snapshot>\n"));
195f2a3c691Sahrens 	case HELP_SEND:
196f2a3c691Sahrens 		return (gettext("\tsend [-i <snapshot>] <snapshot>\n"));
19765cd9f28Seschrock 	case HELP_SET:
19865cd9f28Seschrock 		return (gettext("\tset <property=value> "
19965cd9f28Seschrock 		    "<filesystem|volume> ...\n"));
20065cd9f28Seschrock 	case HELP_SHARE:
20165cd9f28Seschrock 		return (gettext("\tshare -a\n"
20265cd9f28Seschrock 		    "\tshare <filesystem>\n"));
20365cd9f28Seschrock 	case HELP_SNAPSHOT:
2041d452cf5Sahrens 		return (gettext("\tsnapshot [-r] "
2051d452cf5Sahrens 		    "<filesystem@name|volume@name>\n"));
20665cd9f28Seschrock 	case HELP_UNMOUNT:
20765cd9f28Seschrock 		return (gettext("\tunmount [-f] -a\n"
20865cd9f28Seschrock 		    "\tunmount [-f] <filesystem|mountpoint>\n"));
20965cd9f28Seschrock 	case HELP_UNSHARE:
21065cd9f28Seschrock 		return (gettext("\tunshare [-f] -a\n"
21165cd9f28Seschrock 		    "\tunshare [-f] <filesystem|mountpoint>\n"));
21265cd9f28Seschrock 	}
21365cd9f28Seschrock 
21465cd9f28Seschrock 	abort();
21565cd9f28Seschrock 	/* NOTREACHED */
21665cd9f28Seschrock }
21765cd9f28Seschrock 
218fa9e4066Sahrens /*
219fa9e4066Sahrens  * Utility function to guarantee malloc() success.
220fa9e4066Sahrens  */
221fa9e4066Sahrens void *
222fa9e4066Sahrens safe_malloc(size_t size)
223fa9e4066Sahrens {
224fa9e4066Sahrens 	void *data;
225fa9e4066Sahrens 
226fa9e4066Sahrens 	if ((data = calloc(1, size)) == NULL) {
227fa9e4066Sahrens 		(void) fprintf(stderr, "internal error: out of memory\n");
228fa9e4066Sahrens 		exit(1);
229fa9e4066Sahrens 	}
230fa9e4066Sahrens 
231fa9e4066Sahrens 	return (data);
232fa9e4066Sahrens }
233fa9e4066Sahrens 
234fa9e4066Sahrens /*
235fa9e4066Sahrens  * Display usage message.  If we're inside a command, display only the usage for
236fa9e4066Sahrens  * that command.  Otherwise, iterate over the entire command table and display
237fa9e4066Sahrens  * a complete usage message.
238fa9e4066Sahrens  */
239fa9e4066Sahrens static void
24099653d4eSeschrock usage(boolean_t requested)
241fa9e4066Sahrens {
242fa9e4066Sahrens 	int i;
24399653d4eSeschrock 	boolean_t show_properties = B_FALSE;
244fa9e4066Sahrens 	FILE *fp = requested ? stdout : stderr;
245fa9e4066Sahrens 
246fa9e4066Sahrens 	if (current_command == NULL) {
247fa9e4066Sahrens 
248fa9e4066Sahrens 		(void) fprintf(fp, gettext("usage: zfs command args ...\n"));
249fa9e4066Sahrens 		(void) fprintf(fp,
250fa9e4066Sahrens 		    gettext("where 'command' is one of the following:\n\n"));
251fa9e4066Sahrens 
252fa9e4066Sahrens 		for (i = 0; i < NCOMMAND; i++) {
253fa9e4066Sahrens 			if (command_table[i].name == NULL)
254fa9e4066Sahrens 				(void) fprintf(fp, "\n");
255fa9e4066Sahrens 			else
256fa9e4066Sahrens 				(void) fprintf(fp, "%s",
25765cd9f28Seschrock 				    get_usage(command_table[i].usage));
258fa9e4066Sahrens 		}
259fa9e4066Sahrens 
260fa9e4066Sahrens 		(void) fprintf(fp, gettext("\nEach dataset is of the form: "
261fa9e4066Sahrens 		    "pool/[dataset/]*dataset[@name]\n"));
262fa9e4066Sahrens 	} else {
263fa9e4066Sahrens 		(void) fprintf(fp, gettext("usage:\n"));
26465cd9f28Seschrock 		(void) fprintf(fp, "%s", get_usage(current_command->usage));
265fa9e4066Sahrens 	}
266fa9e4066Sahrens 
2675c21526aSdarrenm 	if (current_command != NULL &&
2685c21526aSdarrenm 	    (strcmp(current_command->name, "set") == 0 ||
269fa9e4066Sahrens 	    strcmp(current_command->name, "get") == 0 ||
270fa9e4066Sahrens 	    strcmp(current_command->name, "inherit") == 0 ||
2715c21526aSdarrenm 	    strcmp(current_command->name, "list") == 0))
27299653d4eSeschrock 		show_properties = B_TRUE;
273fa9e4066Sahrens 
274fa9e4066Sahrens 	if (show_properties) {
275fa9e4066Sahrens 
276fa9e4066Sahrens 		(void) fprintf(fp,
277fa9e4066Sahrens 		    gettext("\nThe following properties are supported:\n"));
278fa9e4066Sahrens 
279fa9e4066Sahrens 		(void) fprintf(fp, "\n\t%-13s  %s  %s   %s\n\n",
280fa9e4066Sahrens 		    "PROPERTY", "EDIT", "INHERIT", "VALUES");
281fa9e4066Sahrens 
282fa9e4066Sahrens 		for (i = 0; i < ZFS_NPROP_VISIBLE; i++) {
283fa9e4066Sahrens 			(void) fprintf(fp, "\t%-13s  ", zfs_prop_to_name(i));
284fa9e4066Sahrens 
285fa9e4066Sahrens 			if (zfs_prop_readonly(i))
286fa9e4066Sahrens 				(void) fprintf(fp, "  NO    ");
287fa9e4066Sahrens 			else
288fa9e4066Sahrens 				(void) fprintf(fp, " YES    ");
289fa9e4066Sahrens 
290fa9e4066Sahrens 			if (zfs_prop_inheritable(i))
291fa9e4066Sahrens 				(void) fprintf(fp, "  YES   ");
292fa9e4066Sahrens 			else
293fa9e4066Sahrens 				(void) fprintf(fp, "   NO   ");
294fa9e4066Sahrens 
295fa9e4066Sahrens 			if (zfs_prop_values(i) == NULL)
296fa9e4066Sahrens 				(void) fprintf(fp, "-\n");
297fa9e4066Sahrens 			else
298fa9e4066Sahrens 				(void) fprintf(fp, "%s\n", zfs_prop_values(i));
299fa9e4066Sahrens 		}
300fa9e4066Sahrens 		(void) fprintf(fp, gettext("\nSizes are specified in bytes "
301fa9e4066Sahrens 		    "with standard units such as K, M, G, etc.\n"));
3025c21526aSdarrenm 	} else {
3035c21526aSdarrenm 		/*
3045c21526aSdarrenm 		 * TRANSLATION NOTE:
3055c21526aSdarrenm 		 * "zfs set|get" must not be localised this is the
3065c21526aSdarrenm 		 * command name and arguments.
3075c21526aSdarrenm 		 */
3085c21526aSdarrenm 		(void) fprintf(fp,
3095c21526aSdarrenm 		    gettext("\nFor the property list, run: zfs set|get\n"));
310fa9e4066Sahrens 	}
311fa9e4066Sahrens 
312fa9e4066Sahrens 	exit(requested ? 0 : 2);
313fa9e4066Sahrens }
314fa9e4066Sahrens 
315fa9e4066Sahrens /*
316fa9e4066Sahrens  * zfs clone <fs, snap, vol> fs
317fa9e4066Sahrens  *
318fa9e4066Sahrens  * Given an existing dataset, create a writable copy whose initial contents
319fa9e4066Sahrens  * are the same as the source.  The newly created dataset maintains a
320fa9e4066Sahrens  * dependency on the original; the original cannot be destroyed so long as
321fa9e4066Sahrens  * the clone exists.
322fa9e4066Sahrens  */
323fa9e4066Sahrens static int
324fa9e4066Sahrens zfs_do_clone(int argc, char **argv)
325fa9e4066Sahrens {
326fa9e4066Sahrens 	zfs_handle_t *zhp;
327fa9e4066Sahrens 	int ret;
328fa9e4066Sahrens 
329fa9e4066Sahrens 	/* check options */
330fa9e4066Sahrens 	if (argc > 1 && argv[1][0] == '-') {
331fa9e4066Sahrens 		(void) fprintf(stderr, gettext("invalid option '%c'\n"),
332fa9e4066Sahrens 		    argv[1][1]);
33399653d4eSeschrock 		usage(B_FALSE);
334fa9e4066Sahrens 	}
335fa9e4066Sahrens 
336fa9e4066Sahrens 	/* check number of arguments */
337fa9e4066Sahrens 	if (argc < 2) {
338fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing source dataset "
339fa9e4066Sahrens 		    "argument\n"));
34099653d4eSeschrock 		usage(B_FALSE);
341fa9e4066Sahrens 	}
342fa9e4066Sahrens 	if (argc < 3) {
343fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing target dataset "
344fa9e4066Sahrens 		    "argument\n"));
34599653d4eSeschrock 		usage(B_FALSE);
346fa9e4066Sahrens 	}
347fa9e4066Sahrens 	if (argc > 3) {
348fa9e4066Sahrens 		(void) fprintf(stderr, gettext("too many arguments\n"));
34999653d4eSeschrock 		usage(B_FALSE);
350fa9e4066Sahrens 	}
351fa9e4066Sahrens 
352fa9e4066Sahrens 	/* open the source dataset */
35399653d4eSeschrock 	if ((zhp = zfs_open(g_zfs, argv[1], ZFS_TYPE_SNAPSHOT)) == NULL)
354fa9e4066Sahrens 		return (1);
355fa9e4066Sahrens 
356fa9e4066Sahrens 	/* pass to libzfs */
357fa9e4066Sahrens 	ret = zfs_clone(zhp, argv[2]);
358fa9e4066Sahrens 
359fa9e4066Sahrens 	/* create the mountpoint if necessary */
360fa9e4066Sahrens 	if (ret == 0) {
36199653d4eSeschrock 		zfs_handle_t *clone = zfs_open(g_zfs, argv[2], ZFS_TYPE_ANY);
362fa9e4066Sahrens 		if (clone != NULL) {
363fa9e4066Sahrens 			if ((ret = zfs_mount(clone, NULL, 0)) == 0)
364fa9e4066Sahrens 				ret = zfs_share(clone);
365fa9e4066Sahrens 			zfs_close(clone);
366fa9e4066Sahrens 		}
367fa9e4066Sahrens 	}
368fa9e4066Sahrens 
369fa9e4066Sahrens 	zfs_close(zhp);
370fa9e4066Sahrens 
371fa9e4066Sahrens 	return (ret == 0 ? 0 : 1);
372fa9e4066Sahrens }
373fa9e4066Sahrens 
374fa9e4066Sahrens /*
375fa9e4066Sahrens  * zfs create fs
3761d452cf5Sahrens  * zfs create [-s] [-b blocksize] -V vol size
377fa9e4066Sahrens  *
378fa9e4066Sahrens  * Create a new dataset.  This command can be used to create filesystems
379fa9e4066Sahrens  * and volumes.  Snapshot creation is handled by 'zfs snapshot'.
380fa9e4066Sahrens  * For volumes, the user must specify a size to be used.
381fa9e4066Sahrens  *
382fa9e4066Sahrens  * The '-s' flag applies only to volumes, and indicates that we should not try
383fa9e4066Sahrens  * to set the reservation for this volume.  By default we set a reservation
384fa9e4066Sahrens  * equal to the size for any volume.
385fa9e4066Sahrens  */
386fa9e4066Sahrens static int
387fa9e4066Sahrens zfs_do_create(int argc, char **argv)
388fa9e4066Sahrens {
389fa9e4066Sahrens 	zfs_type_t type = ZFS_TYPE_FILESYSTEM;
390fa9e4066Sahrens 	zfs_handle_t *zhp;
391fa9e4066Sahrens 	char *size = NULL;
392fa9e4066Sahrens 	char *blocksize = NULL;
393fa9e4066Sahrens 	int c;
39499653d4eSeschrock 	boolean_t noreserve = B_FALSE;
395fa9e4066Sahrens 	int ret;
396fa9e4066Sahrens 
397fa9e4066Sahrens 	/* check options */
398fa9e4066Sahrens 	while ((c = getopt(argc, argv, ":V:b:s")) != -1) {
399fa9e4066Sahrens 		switch (c) {
400fa9e4066Sahrens 		case 'V':
401fa9e4066Sahrens 			type = ZFS_TYPE_VOLUME;
402fa9e4066Sahrens 			size = optarg;
403fa9e4066Sahrens 			break;
404fa9e4066Sahrens 		case 'b':
405fa9e4066Sahrens 			blocksize = optarg;
406fa9e4066Sahrens 			break;
407fa9e4066Sahrens 		case 's':
40899653d4eSeschrock 			noreserve = B_TRUE;
409fa9e4066Sahrens 			break;
410fa9e4066Sahrens 		case ':':
411fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing size "
412fa9e4066Sahrens 			    "argument\n"));
41399653d4eSeschrock 			usage(B_FALSE);
414fa9e4066Sahrens 			break;
415fa9e4066Sahrens 		case '?':
416fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
417fa9e4066Sahrens 			    optopt);
41899653d4eSeschrock 			usage(B_FALSE);
419fa9e4066Sahrens 		}
420fa9e4066Sahrens 	}
421fa9e4066Sahrens 
422fa9e4066Sahrens 	if (noreserve && type != ZFS_TYPE_VOLUME) {
423fa9e4066Sahrens 		(void) fprintf(stderr, gettext("'-s' can only be used when "
424fa9e4066Sahrens 		    "creating a volume\n"));
42599653d4eSeschrock 		usage(B_FALSE);
426fa9e4066Sahrens 	}
427fa9e4066Sahrens 
428fa9e4066Sahrens 	argc -= optind;
429fa9e4066Sahrens 	argv += optind;
430fa9e4066Sahrens 
431fa9e4066Sahrens 	/* check number of arguments */
432fa9e4066Sahrens 	if (argc == 0) {
433fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing %s argument\n"),
434fa9e4066Sahrens 		    zfs_type_to_name(type));
43599653d4eSeschrock 		usage(B_FALSE);
436fa9e4066Sahrens 	}
437fa9e4066Sahrens 	if (argc > 1) {
438fa9e4066Sahrens 		(void) fprintf(stderr, gettext("too many arguments\n"));
43999653d4eSeschrock 		usage(B_FALSE);
440fa9e4066Sahrens 	}
441fa9e4066Sahrens 
442fa9e4066Sahrens 	/* pass to libzfs */
44399653d4eSeschrock 	if (zfs_create(g_zfs, argv[0], type, size, blocksize) != 0)
444fa9e4066Sahrens 		return (1);
445fa9e4066Sahrens 
44699653d4eSeschrock 	if ((zhp = zfs_open(g_zfs, argv[0], ZFS_TYPE_ANY)) == NULL)
447fa9e4066Sahrens 		return (1);
448fa9e4066Sahrens 
449fa9e4066Sahrens 	/*
450fa9e4066Sahrens 	 * Volume handling.  By default, we try to create a reservation of equal
451fa9e4066Sahrens 	 * size for the volume.  If we can't do this, then destroy the dataset
452fa9e4066Sahrens 	 * and report an error.
453fa9e4066Sahrens 	 */
454fa9e4066Sahrens 	if (type == ZFS_TYPE_VOLUME && !noreserve) {
455fa9e4066Sahrens 		if (zfs_prop_set(zhp, ZFS_PROP_RESERVATION, size) != 0) {
456fa9e4066Sahrens 			(void) fprintf(stderr, gettext("use '-s' to create a "
457fa9e4066Sahrens 			    "volume without a matching reservation\n"));
458fa9e4066Sahrens 			(void) zfs_destroy(zhp);
459fa9e4066Sahrens 			return (1);
460fa9e4066Sahrens 		}
461fa9e4066Sahrens 	}
462fa9e4066Sahrens 
463fa9e4066Sahrens 	/*
464fa9e4066Sahrens 	 * Mount and/or share the new filesystem as appropriate.  We provide a
465fa9e4066Sahrens 	 * verbose error message to let the user know that their filesystem was
466fa9e4066Sahrens 	 * in fact created, even if we failed to mount or share it.
467fa9e4066Sahrens 	 */
468fa9e4066Sahrens 	if (zfs_mount(zhp, NULL, 0) != 0) {
469fa9e4066Sahrens 		(void) fprintf(stderr, gettext("filesystem successfully "
470fa9e4066Sahrens 		    "created, but not mounted\n"));
471fa9e4066Sahrens 		ret = 1;
472fa9e4066Sahrens 	} else if (zfs_share(zhp) != 0) {
473fa9e4066Sahrens 		(void) fprintf(stderr, gettext("filesystem successfully "
474fa9e4066Sahrens 		    "created, but not shared\n"));
475fa9e4066Sahrens 		ret = 1;
476fa9e4066Sahrens 	} else {
477fa9e4066Sahrens 		ret = 0;
478fa9e4066Sahrens 	}
479fa9e4066Sahrens 
480fa9e4066Sahrens 	zfs_close(zhp);
481fa9e4066Sahrens 	return (ret);
482fa9e4066Sahrens }
483fa9e4066Sahrens 
484fa9e4066Sahrens /*
485fa9e4066Sahrens  * zfs destroy [-rf] <fs, snap, vol>
486fa9e4066Sahrens  *
487fa9e4066Sahrens  * 	-r	Recursively destroy all children
488fa9e4066Sahrens  * 	-R	Recursively destroy all dependents, including clones
489fa9e4066Sahrens  * 	-f	Force unmounting of any dependents
490fa9e4066Sahrens  *
491fa9e4066Sahrens  * Destroys the given dataset.  By default, it will unmount any filesystems,
492fa9e4066Sahrens  * and refuse to destroy a dataset that has any dependents.  A dependent can
493fa9e4066Sahrens  * either be a child, or a clone of a child.
494fa9e4066Sahrens  */
495fa9e4066Sahrens typedef struct destroy_cbdata {
49699653d4eSeschrock 	boolean_t	cb_first;
497fa9e4066Sahrens 	int		cb_force;
498fa9e4066Sahrens 	int		cb_recurse;
499fa9e4066Sahrens 	int		cb_error;
500fa9e4066Sahrens 	int		cb_needforce;
501fa9e4066Sahrens 	int		cb_doclones;
502fa9e4066Sahrens 	zfs_handle_t	*cb_target;
5031d452cf5Sahrens 	char		*cb_snapname;
504fa9e4066Sahrens } destroy_cbdata_t;
505fa9e4066Sahrens 
506fa9e4066Sahrens /*
507fa9e4066Sahrens  * Check for any dependents based on the '-r' or '-R' flags.
508fa9e4066Sahrens  */
509fa9e4066Sahrens static int
510fa9e4066Sahrens destroy_check_dependent(zfs_handle_t *zhp, void *data)
511fa9e4066Sahrens {
512fa9e4066Sahrens 	destroy_cbdata_t *cbp = data;
513fa9e4066Sahrens 	const char *tname = zfs_get_name(cbp->cb_target);
514fa9e4066Sahrens 	const char *name = zfs_get_name(zhp);
515fa9e4066Sahrens 
516fa9e4066Sahrens 	if (strncmp(tname, name, strlen(tname)) == 0 &&
517fa9e4066Sahrens 	    (name[strlen(tname)] == '/' || name[strlen(tname)] == '@')) {
518fa9e4066Sahrens 		/*
519fa9e4066Sahrens 		 * This is a direct descendant, not a clone somewhere else in
520fa9e4066Sahrens 		 * the hierarchy.
521fa9e4066Sahrens 		 */
522fa9e4066Sahrens 		if (cbp->cb_recurse)
523fa9e4066Sahrens 			goto out;
524fa9e4066Sahrens 
525fa9e4066Sahrens 		if (cbp->cb_first) {
526fa9e4066Sahrens 			(void) fprintf(stderr, gettext("cannot destroy '%s': "
527fa9e4066Sahrens 			    "%s has children\n"),
528fa9e4066Sahrens 			    zfs_get_name(cbp->cb_target),
529fa9e4066Sahrens 			    zfs_type_to_name(zfs_get_type(cbp->cb_target)));
530fa9e4066Sahrens 			(void) fprintf(stderr, gettext("use '-r' to destroy "
531fa9e4066Sahrens 			    "the following datasets:\n"));
53299653d4eSeschrock 			cbp->cb_first = B_FALSE;
533fa9e4066Sahrens 			cbp->cb_error = 1;
534fa9e4066Sahrens 		}
535fa9e4066Sahrens 
536fa9e4066Sahrens 		(void) fprintf(stderr, "%s\n", zfs_get_name(zhp));
537fa9e4066Sahrens 	} else {
538fa9e4066Sahrens 		/*
539fa9e4066Sahrens 		 * This is a clone.  We only want to report this if the '-r'
540fa9e4066Sahrens 		 * wasn't specified, or the target is a snapshot.
541fa9e4066Sahrens 		 */
542fa9e4066Sahrens 		if (!cbp->cb_recurse &&
543fa9e4066Sahrens 		    zfs_get_type(cbp->cb_target) != ZFS_TYPE_SNAPSHOT)
544fa9e4066Sahrens 			goto out;
545fa9e4066Sahrens 
546fa9e4066Sahrens 		if (cbp->cb_first) {
547fa9e4066Sahrens 			(void) fprintf(stderr, gettext("cannot destroy '%s': "
548fa9e4066Sahrens 			    "%s has dependent clones\n"),
549fa9e4066Sahrens 			    zfs_get_name(cbp->cb_target),
550fa9e4066Sahrens 			    zfs_type_to_name(zfs_get_type(cbp->cb_target)));
551fa9e4066Sahrens 			(void) fprintf(stderr, gettext("use '-R' to destroy "
552fa9e4066Sahrens 			    "the following datasets:\n"));
55399653d4eSeschrock 			cbp->cb_first = B_FALSE;
554fa9e4066Sahrens 			cbp->cb_error = 1;
555fa9e4066Sahrens 		}
556fa9e4066Sahrens 
557fa9e4066Sahrens 		(void) fprintf(stderr, "%s\n", zfs_get_name(zhp));
558fa9e4066Sahrens 	}
559fa9e4066Sahrens 
560fa9e4066Sahrens out:
561fa9e4066Sahrens 	zfs_close(zhp);
562fa9e4066Sahrens 	return (0);
563fa9e4066Sahrens }
564fa9e4066Sahrens 
565fa9e4066Sahrens static int
566fa9e4066Sahrens destroy_callback(zfs_handle_t *zhp, void *data)
567fa9e4066Sahrens {
568fa9e4066Sahrens 	destroy_cbdata_t *cbp = data;
569fa9e4066Sahrens 
570fa9e4066Sahrens 	/*
571fa9e4066Sahrens 	 * Ignore pools (which we've already flagged as an error before getting
572fa9e4066Sahrens 	 * here.
573fa9e4066Sahrens 	 */
574fa9e4066Sahrens 	if (strchr(zfs_get_name(zhp), '/') == NULL &&
575fa9e4066Sahrens 	    zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM) {
576fa9e4066Sahrens 		zfs_close(zhp);
577fa9e4066Sahrens 		return (0);
578fa9e4066Sahrens 	}
579fa9e4066Sahrens 
580fa9e4066Sahrens 	/*
581fa9e4066Sahrens 	 * Bail out on the first error.
582fa9e4066Sahrens 	 */
583fa9e4066Sahrens 	if (zfs_unmount(zhp, NULL, cbp->cb_force ? MS_FORCE : 0) != 0 ||
584fa9e4066Sahrens 	    zfs_destroy(zhp) != 0) {
585fa9e4066Sahrens 		zfs_close(zhp);
586fa9e4066Sahrens 		return (-1);
587fa9e4066Sahrens 	}
588fa9e4066Sahrens 
589fa9e4066Sahrens 	zfs_close(zhp);
590fa9e4066Sahrens 	return (0);
591fa9e4066Sahrens }
592fa9e4066Sahrens 
5931d452cf5Sahrens static int
5941d452cf5Sahrens destroy_snap_clones(zfs_handle_t *zhp, void *arg)
5951d452cf5Sahrens {
5961d452cf5Sahrens 	destroy_cbdata_t *cbp = arg;
5971d452cf5Sahrens 	char thissnap[MAXPATHLEN];
5981d452cf5Sahrens 	zfs_handle_t *szhp;
5991d452cf5Sahrens 
6001d452cf5Sahrens 	(void) snprintf(thissnap, sizeof (thissnap),
6011d452cf5Sahrens 	    "%s@%s", zfs_get_name(zhp), cbp->cb_snapname);
6021d452cf5Sahrens 
6031d452cf5Sahrens 	libzfs_print_on_error(g_zfs, B_FALSE);
6041d452cf5Sahrens 	szhp = zfs_open(g_zfs, thissnap, ZFS_TYPE_SNAPSHOT);
6051d452cf5Sahrens 	libzfs_print_on_error(g_zfs, B_TRUE);
6061d452cf5Sahrens 	if (szhp) {
6071d452cf5Sahrens 		/*
6081d452cf5Sahrens 		 * Destroy any clones of this snapshot
6091d452cf5Sahrens 		 */
6101d452cf5Sahrens 		(void) zfs_iter_dependents(szhp, destroy_callback, cbp);
6111d452cf5Sahrens 		zfs_close(szhp);
6121d452cf5Sahrens 	}
6131d452cf5Sahrens 
6141d452cf5Sahrens 	return (zfs_iter_filesystems(zhp, destroy_snap_clones, arg));
6151d452cf5Sahrens }
616fa9e4066Sahrens 
617fa9e4066Sahrens static int
618fa9e4066Sahrens zfs_do_destroy(int argc, char **argv)
619fa9e4066Sahrens {
620fa9e4066Sahrens 	destroy_cbdata_t cb = { 0 };
621fa9e4066Sahrens 	int c;
622fa9e4066Sahrens 	zfs_handle_t *zhp;
6231d452cf5Sahrens 	char *cp;
624fa9e4066Sahrens 
625fa9e4066Sahrens 	/* check options */
626fa9e4066Sahrens 	while ((c = getopt(argc, argv, "frR")) != -1) {
627fa9e4066Sahrens 		switch (c) {
628fa9e4066Sahrens 		case 'f':
629fa9e4066Sahrens 			cb.cb_force = 1;
630fa9e4066Sahrens 			break;
631fa9e4066Sahrens 		case 'r':
632fa9e4066Sahrens 			cb.cb_recurse = 1;
633fa9e4066Sahrens 			break;
634fa9e4066Sahrens 		case 'R':
635fa9e4066Sahrens 			cb.cb_recurse = 1;
636fa9e4066Sahrens 			cb.cb_doclones = 1;
637fa9e4066Sahrens 			break;
638fa9e4066Sahrens 		case '?':
639fa9e4066Sahrens 		default:
640fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
641fa9e4066Sahrens 			    optopt);
64299653d4eSeschrock 			usage(B_FALSE);
643fa9e4066Sahrens 		}
644fa9e4066Sahrens 	}
645fa9e4066Sahrens 
646fa9e4066Sahrens 	argc -= optind;
647fa9e4066Sahrens 	argv += optind;
648fa9e4066Sahrens 
649fa9e4066Sahrens 	/* check number of arguments */
650fa9e4066Sahrens 	if (argc == 0) {
651fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing path argument\n"));
65299653d4eSeschrock 		usage(B_FALSE);
653fa9e4066Sahrens 	}
654fa9e4066Sahrens 	if (argc > 1) {
655fa9e4066Sahrens 		(void) fprintf(stderr, gettext("too many arguments\n"));
65699653d4eSeschrock 		usage(B_FALSE);
657fa9e4066Sahrens 	}
658fa9e4066Sahrens 
6591d452cf5Sahrens 	/*
6601d452cf5Sahrens 	 * If we are doing recursive destroy of a snapshot, then the
6611d452cf5Sahrens 	 * named snapshot may not exist.  Go straight to libzfs.
6621d452cf5Sahrens 	 */
6631d452cf5Sahrens 	if (cb.cb_recurse && (cp = strchr(argv[0], '@'))) {
6641d452cf5Sahrens 		int ret;
6651d452cf5Sahrens 
6661d452cf5Sahrens 		*cp = '\0';
6671d452cf5Sahrens 		if ((zhp = zfs_open(g_zfs, argv[0], ZFS_TYPE_ANY)) == NULL)
6681d452cf5Sahrens 			return (1);
6691d452cf5Sahrens 		*cp = '@';
6701d452cf5Sahrens 		cp++;
6711d452cf5Sahrens 
6721d452cf5Sahrens 		if (cb.cb_doclones) {
6731d452cf5Sahrens 			cb.cb_snapname = cp;
6741d452cf5Sahrens 			(void) destroy_snap_clones(zhp, &cb);
6751d452cf5Sahrens 		}
6761d452cf5Sahrens 
6771d452cf5Sahrens 		ret = zfs_destroy_snaps(zhp, cp);
6781d452cf5Sahrens 		zfs_close(zhp);
6791d452cf5Sahrens 		if (ret) {
6801d452cf5Sahrens 			(void) fprintf(stderr,
6811d452cf5Sahrens 			    gettext("no snapshots destroyed\n"));
6821d452cf5Sahrens 		}
6831d452cf5Sahrens 		return (ret != 0);
6841d452cf5Sahrens 	}
6851d452cf5Sahrens 
6861d452cf5Sahrens 
687fa9e4066Sahrens 	/* Open the given dataset */
68899653d4eSeschrock 	if ((zhp = zfs_open(g_zfs, argv[0], ZFS_TYPE_ANY)) == NULL)
689fa9e4066Sahrens 		return (1);
690fa9e4066Sahrens 
691fa9e4066Sahrens 	cb.cb_target = zhp;
692fa9e4066Sahrens 
693fa9e4066Sahrens 	/*
694fa9e4066Sahrens 	 * Perform an explicit check for pools before going any further.
695fa9e4066Sahrens 	 */
696fa9e4066Sahrens 	if (!cb.cb_recurse && strchr(zfs_get_name(zhp), '/') == NULL &&
697fa9e4066Sahrens 	    zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM) {
698fa9e4066Sahrens 		(void) fprintf(stderr, gettext("cannot destroy '%s': "
699fa9e4066Sahrens 		    "operation does not apply to pools\n"),
700fa9e4066Sahrens 		    zfs_get_name(zhp));
701fa9e4066Sahrens 		(void) fprintf(stderr, gettext("use 'zfs destroy -r "
702fa9e4066Sahrens 		    "%s' to destroy all datasets in the pool\n"),
703fa9e4066Sahrens 		    zfs_get_name(zhp));
704fa9e4066Sahrens 		(void) fprintf(stderr, gettext("use 'zpool destroy %s' "
705fa9e4066Sahrens 		    "to destroy the pool itself\n"), zfs_get_name(zhp));
706fa9e4066Sahrens 		zfs_close(zhp);
707fa9e4066Sahrens 		return (1);
708fa9e4066Sahrens 	}
709fa9e4066Sahrens 
710fa9e4066Sahrens 	/*
711fa9e4066Sahrens 	 * Check for any dependents and/or clones.
712fa9e4066Sahrens 	 */
71399653d4eSeschrock 	cb.cb_first = B_TRUE;
714fa9e4066Sahrens 	if (!cb.cb_doclones)
715fa9e4066Sahrens 		(void) zfs_iter_dependents(zhp, destroy_check_dependent, &cb);
716fa9e4066Sahrens 
717fa9e4066Sahrens 	if (cb.cb_error) {
718fa9e4066Sahrens 		zfs_close(zhp);
719fa9e4066Sahrens 		return (1);
720fa9e4066Sahrens 	}
721fa9e4066Sahrens 
722fa9e4066Sahrens 	/*
723fa9e4066Sahrens 	 * Do the real thing.
724fa9e4066Sahrens 	 */
725fa9e4066Sahrens 	if (zfs_iter_dependents(zhp, destroy_callback, &cb) == 0 &&
726fa9e4066Sahrens 	    destroy_callback(zhp, &cb) == 0)
727fa9e4066Sahrens 		return (0);
728fa9e4066Sahrens 
729fa9e4066Sahrens 	return (1);
730fa9e4066Sahrens }
731fa9e4066Sahrens 
732fa9e4066Sahrens /*
73307ba0419Seschrock  * zfs get [-rHp] [-o field[,field]...] [-s source[,source]...]
73407ba0419Seschrock  * 	< all | property[,property]... > < fs | snap | vol > ...
735fa9e4066Sahrens  *
736fa9e4066Sahrens  *	-r	recurse over any child datasets
737fa9e4066Sahrens  *	-H	scripted mode.  Headers are stripped, and fields are separated
738fa9e4066Sahrens  *		by tabs instead of spaces.
739fa9e4066Sahrens  *	-o	Set of fields to display.  One of "name,property,value,source".
740fa9e4066Sahrens  *		Default is all four.
741fa9e4066Sahrens  *	-s	Set of sources to allow.  One of
742fa9e4066Sahrens  *		"local,default,inherited,temporary,none".  Default is all
743fa9e4066Sahrens  *		five.
744fa9e4066Sahrens  *	-p	Display values in parsable (literal) format.
745fa9e4066Sahrens  *
746fa9e4066Sahrens  *  Prints properties for the given datasets.  The user can control which
747fa9e4066Sahrens  *  columns to display as well as which property types to allow.
748fa9e4066Sahrens  */
749fa9e4066Sahrens typedef struct get_cbdata {
750fa9e4066Sahrens 	int cb_sources;
751fa9e4066Sahrens 	int cb_columns[4];
752fa9e4066Sahrens 	int cb_nprop;
75399653d4eSeschrock 	boolean_t cb_scripted;
75499653d4eSeschrock 	boolean_t cb_literal;
75599653d4eSeschrock 	boolean_t cb_isall;
75699653d4eSeschrock 	zfs_prop_t cb_prop[ZFS_NPROP_ALL];
757fa9e4066Sahrens } get_cbdata_t;
758fa9e4066Sahrens 
759fa9e4066Sahrens #define	GET_COL_NAME		1
760fa9e4066Sahrens #define	GET_COL_PROPERTY	2
761fa9e4066Sahrens #define	GET_COL_VALUE		3
762fa9e4066Sahrens #define	GET_COL_SOURCE		4
763fa9e4066Sahrens 
764fa9e4066Sahrens /*
765fa9e4066Sahrens  * Display a single line of output, according to the settings in the callback
766fa9e4066Sahrens  * structure.
767fa9e4066Sahrens  */
768fa9e4066Sahrens static void
769fa9e4066Sahrens print_one_property(zfs_handle_t *zhp, get_cbdata_t *cbp, zfs_prop_t prop,
770fa9e4066Sahrens     const char *value, zfs_source_t sourcetype, const char *source)
771fa9e4066Sahrens {
772fa9e4066Sahrens 	int i;
773fa9e4066Sahrens 	int width;
774fa9e4066Sahrens 	const char *str;
775fa9e4066Sahrens 	char buf[128];
776fa9e4066Sahrens 
777fa9e4066Sahrens 	/*
778fa9e4066Sahrens 	 * Ignore those source types that the user has chosen to ignore.
779fa9e4066Sahrens 	 */
780fa9e4066Sahrens 	if ((sourcetype & cbp->cb_sources) == 0)
781fa9e4066Sahrens 		return;
782fa9e4066Sahrens 
783fa9e4066Sahrens 	for (i = 0; i < 4; i++) {
784fa9e4066Sahrens 		switch (cbp->cb_columns[i]) {
785fa9e4066Sahrens 		case GET_COL_NAME:
786fa9e4066Sahrens 			width = 15;
787fa9e4066Sahrens 			str = zfs_get_name(zhp);
788fa9e4066Sahrens 			break;
789fa9e4066Sahrens 
790fa9e4066Sahrens 		case GET_COL_PROPERTY:
791fa9e4066Sahrens 			width = 13;
792fa9e4066Sahrens 			str = zfs_prop_to_name(prop);
793fa9e4066Sahrens 			break;
794fa9e4066Sahrens 
795fa9e4066Sahrens 		case GET_COL_VALUE:
796fa9e4066Sahrens 			width = 25;
797fa9e4066Sahrens 			str = value;
798fa9e4066Sahrens 			break;
799fa9e4066Sahrens 
800fa9e4066Sahrens 		case GET_COL_SOURCE:
801fa9e4066Sahrens 			width = 15;
802fa9e4066Sahrens 			switch (sourcetype) {
803fa9e4066Sahrens 			case ZFS_SRC_NONE:
804fa9e4066Sahrens 				str = "-";
805fa9e4066Sahrens 				break;
806fa9e4066Sahrens 
807fa9e4066Sahrens 			case ZFS_SRC_DEFAULT:
808fa9e4066Sahrens 				str = "default";
809fa9e4066Sahrens 				break;
810fa9e4066Sahrens 
811fa9e4066Sahrens 			case ZFS_SRC_LOCAL:
812fa9e4066Sahrens 				str = "local";
813fa9e4066Sahrens 				break;
814fa9e4066Sahrens 
815fa9e4066Sahrens 			case ZFS_SRC_TEMPORARY:
816fa9e4066Sahrens 				str = "temporary";
817fa9e4066Sahrens 				break;
818fa9e4066Sahrens 
819fa9e4066Sahrens 			case ZFS_SRC_INHERITED:
820fa9e4066Sahrens 				(void) snprintf(buf, sizeof (buf),
821fa9e4066Sahrens 				    "inherited from %s", source);
822fa9e4066Sahrens 				str = buf;
823fa9e4066Sahrens 				break;
824fa9e4066Sahrens 			}
825fa9e4066Sahrens 			break;
826fa9e4066Sahrens 
827fa9e4066Sahrens 		default:
828fa9e4066Sahrens 			continue;
829fa9e4066Sahrens 		}
830fa9e4066Sahrens 
831fa9e4066Sahrens 		if (cbp->cb_columns[i + 1] == 0)
832fa9e4066Sahrens 			(void) printf("%s", str);
833fa9e4066Sahrens 		else if (cbp->cb_scripted)
834fa9e4066Sahrens 			(void) printf("%s\t", str);
835fa9e4066Sahrens 		else
836fa9e4066Sahrens 			(void) printf("%-*s  ", width, str);
837fa9e4066Sahrens 
838fa9e4066Sahrens 	}
839fa9e4066Sahrens 
840fa9e4066Sahrens 	(void) printf("\n");
841fa9e4066Sahrens }
842fa9e4066Sahrens 
843fa9e4066Sahrens /*
844fa9e4066Sahrens  * Invoked to display the properties for a single dataset.
845fa9e4066Sahrens  */
846fa9e4066Sahrens static int
847fa9e4066Sahrens get_callback(zfs_handle_t *zhp, void *data)
848fa9e4066Sahrens {
849fa9e4066Sahrens 	char buf[ZFS_MAXPROPLEN];
850fa9e4066Sahrens 	zfs_source_t sourcetype;
851fa9e4066Sahrens 	char source[ZFS_MAXNAMELEN];
852fa9e4066Sahrens 	get_cbdata_t *cbp = data;
853fa9e4066Sahrens 	int i;
854fa9e4066Sahrens 
855fa9e4066Sahrens 	for (i = 0; i < cbp->cb_nprop; i++) {
856fa9e4066Sahrens 		if (zfs_prop_get(zhp, cbp->cb_prop[i], buf,
857fa9e4066Sahrens 		    sizeof (buf), &sourcetype, source, sizeof (source),
858fa9e4066Sahrens 		    cbp->cb_literal) != 0) {
85907ba0419Seschrock 			if (cbp->cb_isall)
86007ba0419Seschrock 				continue;
861fa9e4066Sahrens 			(void) strlcpy(buf, "-", sizeof (buf));
862fa9e4066Sahrens 			sourcetype = ZFS_SRC_NONE;
863fa9e4066Sahrens 		}
864fa9e4066Sahrens 
865fa9e4066Sahrens 		print_one_property(zhp, cbp, cbp->cb_prop[i],
866fa9e4066Sahrens 		    buf, sourcetype, source);
867fa9e4066Sahrens 	}
868fa9e4066Sahrens 
869fa9e4066Sahrens 	return (0);
870fa9e4066Sahrens }
871fa9e4066Sahrens 
872fa9e4066Sahrens static int
873fa9e4066Sahrens zfs_do_get(int argc, char **argv)
874fa9e4066Sahrens {
875fa9e4066Sahrens 	get_cbdata_t cb = { 0 };
87699653d4eSeschrock 	boolean_t recurse = B_FALSE;
877fa9e4066Sahrens 	int c;
87807ba0419Seschrock 	char *value, *fields, *badopt;
879fa9e4066Sahrens 	int i;
88007ba0419Seschrock 	int ret;
881fa9e4066Sahrens 
882fa9e4066Sahrens 	/*
883fa9e4066Sahrens 	 * Set up default columns and sources.
884fa9e4066Sahrens 	 */
885fa9e4066Sahrens 	cb.cb_sources = ZFS_SRC_ALL;
886fa9e4066Sahrens 	cb.cb_columns[0] = GET_COL_NAME;
887fa9e4066Sahrens 	cb.cb_columns[1] = GET_COL_PROPERTY;
888fa9e4066Sahrens 	cb.cb_columns[2] = GET_COL_VALUE;
889fa9e4066Sahrens 	cb.cb_columns[3] = GET_COL_SOURCE;
890fa9e4066Sahrens 
891fa9e4066Sahrens 	/* check options */
892fa9e4066Sahrens 	while ((c = getopt(argc, argv, ":o:s:rHp")) != -1) {
893fa9e4066Sahrens 		switch (c) {
894fa9e4066Sahrens 		case 'p':
89599653d4eSeschrock 			cb.cb_literal = B_TRUE;
896fa9e4066Sahrens 			break;
897fa9e4066Sahrens 		case 'r':
89899653d4eSeschrock 			recurse = B_TRUE;
899fa9e4066Sahrens 			break;
900fa9e4066Sahrens 		case 'H':
90199653d4eSeschrock 			cb.cb_scripted = B_TRUE;
902fa9e4066Sahrens 			break;
903fa9e4066Sahrens 		case ':':
904fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing argument for "
905fa9e4066Sahrens 			    "'%c' option\n"), optopt);
90699653d4eSeschrock 			usage(B_FALSE);
907fa9e4066Sahrens 			break;
908fa9e4066Sahrens 		case 'o':
909fa9e4066Sahrens 			/*
910fa9e4066Sahrens 			 * Process the set of columns to display.  We zero out
911fa9e4066Sahrens 			 * the structure to give us a blank slate.
912fa9e4066Sahrens 			 */
913fa9e4066Sahrens 			bzero(&cb.cb_columns, sizeof (cb.cb_columns));
914fa9e4066Sahrens 			i = 0;
915fa9e4066Sahrens 			while (*optarg != '\0') {
916fa9e4066Sahrens 				static char *col_subopts[] =
917fa9e4066Sahrens 				    { "name", "property", "value", "source",
918fa9e4066Sahrens 				    NULL };
919fa9e4066Sahrens 
920fa9e4066Sahrens 				if (i == 4) {
921fa9e4066Sahrens 					(void) fprintf(stderr, gettext("too "
922fa9e4066Sahrens 					    "many fields given to -o "
923fa9e4066Sahrens 					    "option\n"));
92499653d4eSeschrock 					usage(B_FALSE);
925fa9e4066Sahrens 				}
926fa9e4066Sahrens 
927fa9e4066Sahrens 				switch (getsubopt(&optarg, col_subopts,
928fa9e4066Sahrens 				    &value)) {
929fa9e4066Sahrens 				case 0:
930fa9e4066Sahrens 					cb.cb_columns[i++] = GET_COL_NAME;
931fa9e4066Sahrens 					break;
932fa9e4066Sahrens 				case 1:
933fa9e4066Sahrens 					cb.cb_columns[i++] = GET_COL_PROPERTY;
934fa9e4066Sahrens 					break;
935fa9e4066Sahrens 				case 2:
936fa9e4066Sahrens 					cb.cb_columns[i++] = GET_COL_VALUE;
937fa9e4066Sahrens 					break;
938fa9e4066Sahrens 				case 3:
939fa9e4066Sahrens 					cb.cb_columns[i++] = GET_COL_SOURCE;
940fa9e4066Sahrens 					break;
941fa9e4066Sahrens 				default:
942fa9e4066Sahrens 					(void) fprintf(stderr,
943fa9e4066Sahrens 					    gettext("invalid column name "
944fa9e4066Sahrens 					    "'%s'\n"), value);
94599653d4eSeschrock 					    usage(B_FALSE);
946fa9e4066Sahrens 				}
947fa9e4066Sahrens 			}
948fa9e4066Sahrens 			break;
949fa9e4066Sahrens 
950fa9e4066Sahrens 		case 's':
951fa9e4066Sahrens 			cb.cb_sources = 0;
952fa9e4066Sahrens 			while (*optarg != '\0') {
953fa9e4066Sahrens 				static char *source_subopts[] = {
954fa9e4066Sahrens 					"local", "default", "inherited",
955fa9e4066Sahrens 					"temporary", "none", NULL };
956fa9e4066Sahrens 
957fa9e4066Sahrens 				switch (getsubopt(&optarg, source_subopts,
958fa9e4066Sahrens 				    &value)) {
959fa9e4066Sahrens 				case 0:
960fa9e4066Sahrens 					cb.cb_sources |= ZFS_SRC_LOCAL;
961fa9e4066Sahrens 					break;
962fa9e4066Sahrens 				case 1:
963fa9e4066Sahrens 					cb.cb_sources |= ZFS_SRC_DEFAULT;
964fa9e4066Sahrens 					break;
965fa9e4066Sahrens 				case 2:
966fa9e4066Sahrens 					cb.cb_sources |= ZFS_SRC_INHERITED;
967fa9e4066Sahrens 					break;
968fa9e4066Sahrens 				case 3:
969fa9e4066Sahrens 					cb.cb_sources |= ZFS_SRC_TEMPORARY;
970fa9e4066Sahrens 					break;
971fa9e4066Sahrens 				case 4:
972fa9e4066Sahrens 					cb.cb_sources |= ZFS_SRC_NONE;
973fa9e4066Sahrens 					break;
974fa9e4066Sahrens 				default:
975fa9e4066Sahrens 					(void) fprintf(stderr,
976fa9e4066Sahrens 					    gettext("invalid source "
977fa9e4066Sahrens 					    "'%s'\n"), value);
97899653d4eSeschrock 					    usage(B_FALSE);
979fa9e4066Sahrens 				}
980fa9e4066Sahrens 			}
981fa9e4066Sahrens 			break;
982fa9e4066Sahrens 
983fa9e4066Sahrens 		case '?':
984fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
985fa9e4066Sahrens 			    optopt);
98699653d4eSeschrock 			usage(B_FALSE);
987fa9e4066Sahrens 		}
988fa9e4066Sahrens 	}
989fa9e4066Sahrens 
990fa9e4066Sahrens 	argc -= optind;
991fa9e4066Sahrens 	argv += optind;
992fa9e4066Sahrens 
993fa9e4066Sahrens 	if (argc < 1) {
994fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing property "
995fa9e4066Sahrens 		    "argument\n"));
99699653d4eSeschrock 		usage(B_FALSE);
997fa9e4066Sahrens 	}
998fa9e4066Sahrens 
999fa9e4066Sahrens 	fields = argv[0];
1000fa9e4066Sahrens 
1001fa9e4066Sahrens 	/*
100207ba0419Seschrock 	 * If the user specifies 'all', the behavior of 'zfs get' is slightly
100307ba0419Seschrock 	 * different, because we don't show properties which don't apply to the
100407ba0419Seschrock 	 * given dataset.
1005fa9e4066Sahrens 	 */
100607ba0419Seschrock 	if (strcmp(fields, "all") == 0)
100799653d4eSeschrock 		cb.cb_isall = B_TRUE;
100807ba0419Seschrock 
100907ba0419Seschrock 	if ((ret = zfs_get_proplist(fields, cb.cb_prop, ZFS_NPROP_ALL,
101007ba0419Seschrock 	    &cb.cb_nprop, &badopt)) != 0) {
101107ba0419Seschrock 		if (ret == EINVAL)
101207ba0419Seschrock 			(void) fprintf(stderr, gettext("invalid property "
101307ba0419Seschrock 			    "'%s'\n"), badopt);
101407ba0419Seschrock 		else
101507ba0419Seschrock 			(void) fprintf(stderr, gettext("too many properties "
101607ba0419Seschrock 			    "specified\n"));
101799653d4eSeschrock 		usage(B_FALSE);
1018fa9e4066Sahrens 	}
1019fa9e4066Sahrens 
1020fa9e4066Sahrens 	argc--;
1021fa9e4066Sahrens 	argv++;
1022fa9e4066Sahrens 
1023fa9e4066Sahrens 	/* check for at least one dataset name */
1024fa9e4066Sahrens 	if (argc < 1) {
1025fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing dataset argument\n"));
102699653d4eSeschrock 		usage(B_FALSE);
1027fa9e4066Sahrens 	}
1028fa9e4066Sahrens 
1029fa9e4066Sahrens 	/*
1030fa9e4066Sahrens 	 * Print out any headers
1031fa9e4066Sahrens 	 */
1032fa9e4066Sahrens 	if (!cb.cb_scripted) {
1033fa9e4066Sahrens 		int i;
1034fa9e4066Sahrens 		for (i = 0; i < 4; i++) {
1035fa9e4066Sahrens 			switch (cb.cb_columns[i]) {
1036fa9e4066Sahrens 			case GET_COL_NAME:
1037fa9e4066Sahrens 				(void) printf("%-15s  ", "NAME");
1038fa9e4066Sahrens 				break;
1039fa9e4066Sahrens 			case GET_COL_PROPERTY:
1040fa9e4066Sahrens 				(void) printf("%-13s  ", "PROPERTY");
1041fa9e4066Sahrens 				break;
1042fa9e4066Sahrens 			case GET_COL_VALUE:
1043fa9e4066Sahrens 				(void) printf("%-25s  ", "VALUE");
1044fa9e4066Sahrens 				break;
1045fa9e4066Sahrens 			case GET_COL_SOURCE:
1046fa9e4066Sahrens 				(void) printf("%s", "SOURCE");
1047fa9e4066Sahrens 				break;
1048fa9e4066Sahrens 			}
1049fa9e4066Sahrens 		}
1050fa9e4066Sahrens 		(void) printf("\n");
1051fa9e4066Sahrens 	}
1052fa9e4066Sahrens 
1053fa9e4066Sahrens 	/* run for each object */
1054fa9e4066Sahrens 	return (zfs_for_each(argc, argv, recurse, ZFS_TYPE_ANY,
1055fa9e4066Sahrens 	    get_callback, &cb));
1056fa9e4066Sahrens }
1057fa9e4066Sahrens 
1058fa9e4066Sahrens /*
1059fa9e4066Sahrens  * inherit [-r] <property> <fs|vol> ...
1060fa9e4066Sahrens  *
1061fa9e4066Sahrens  * 	-r	Recurse over all children
1062fa9e4066Sahrens  *
1063fa9e4066Sahrens  * For each dataset specified on the command line, inherit the given property
1064fa9e4066Sahrens  * from its parent.  Inheriting a property at the pool level will cause it to
1065fa9e4066Sahrens  * use the default value.  The '-r' flag will recurse over all children, and is
1066fa9e4066Sahrens  * useful for setting a property on a hierarchy-wide basis, regardless of any
1067fa9e4066Sahrens  * local modifications for each dataset.
1068fa9e4066Sahrens  */
1069fa9e4066Sahrens static int
1070fa9e4066Sahrens inherit_callback(zfs_handle_t *zhp, void *data)
1071fa9e4066Sahrens {
1072fa9e4066Sahrens 	zfs_prop_t prop = (zfs_prop_t)data;
1073fa9e4066Sahrens 
1074fa9e4066Sahrens 	return (zfs_prop_inherit(zhp, prop) != 0);
1075fa9e4066Sahrens }
1076fa9e4066Sahrens 
1077fa9e4066Sahrens static int
1078fa9e4066Sahrens zfs_do_inherit(int argc, char **argv)
1079fa9e4066Sahrens {
108099653d4eSeschrock 	boolean_t recurse = B_FALSE;
1081fa9e4066Sahrens 	int c;
1082fa9e4066Sahrens 	zfs_prop_t prop;
1083fa9e4066Sahrens 	char *propname;
1084fa9e4066Sahrens 
1085fa9e4066Sahrens 	/* check options */
1086fa9e4066Sahrens 	while ((c = getopt(argc, argv, "r")) != -1) {
1087fa9e4066Sahrens 		switch (c) {
1088fa9e4066Sahrens 		case 'r':
108999653d4eSeschrock 			recurse = B_TRUE;
1090fa9e4066Sahrens 			break;
1091fa9e4066Sahrens 		case '?':
1092fa9e4066Sahrens 		default:
1093fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
1094fa9e4066Sahrens 			    optopt);
109599653d4eSeschrock 			usage(B_FALSE);
1096fa9e4066Sahrens 		}
1097fa9e4066Sahrens 	}
1098fa9e4066Sahrens 
1099fa9e4066Sahrens 	argc -= optind;
1100fa9e4066Sahrens 	argv += optind;
1101fa9e4066Sahrens 
1102fa9e4066Sahrens 	/* check number of arguments */
1103fa9e4066Sahrens 	if (argc < 1) {
1104fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing property argument\n"));
110599653d4eSeschrock 		usage(B_FALSE);
1106fa9e4066Sahrens 	}
1107fa9e4066Sahrens 	if (argc < 2) {
1108fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing dataset argument\n"));
110999653d4eSeschrock 		usage(B_FALSE);
1110fa9e4066Sahrens 	}
1111fa9e4066Sahrens 
1112fa9e4066Sahrens 	propname = argv[0];
1113fa9e4066Sahrens 
1114fa9e4066Sahrens 	/*
1115fa9e4066Sahrens 	 * Get and validate the property before iterating over the datasets.  We
1116fa9e4066Sahrens 	 * do this now so as to avoid printing out an error message for each and
1117fa9e4066Sahrens 	 * every dataset.
1118fa9e4066Sahrens 	 */
1119fa9e4066Sahrens 	if ((prop = zfs_name_to_prop(propname)) == ZFS_PROP_INVAL) {
1120fa9e4066Sahrens 		(void) fprintf(stderr, gettext("invalid property '%s'\n"),
1121fa9e4066Sahrens 		    propname);
112299653d4eSeschrock 		usage(B_FALSE);
1123fa9e4066Sahrens 	}
1124fa9e4066Sahrens 	if (zfs_prop_readonly(prop)) {
1125fa9e4066Sahrens 		(void) fprintf(stderr, gettext("%s property is read-only\n"),
1126fa9e4066Sahrens 		    propname);
1127fa9e4066Sahrens 		return (1);
1128fa9e4066Sahrens 	}
1129fa9e4066Sahrens 	if (!zfs_prop_inheritable(prop)) {
1130fa9e4066Sahrens 		(void) fprintf(stderr, gettext("%s property cannot be "
1131fa9e4066Sahrens 		    "inherited\n"), propname);
1132fa9e4066Sahrens 		(void) fprintf(stderr, gettext("use 'zfs set %s=none' to "
1133fa9e4066Sahrens 		    "clear\n"), propname);
1134fa9e4066Sahrens 		return (1);
1135fa9e4066Sahrens 	}
1136fa9e4066Sahrens 
1137fa9e4066Sahrens 	return (zfs_for_each(argc - 1, argv + 1, recurse,
1138fa9e4066Sahrens 	    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME,
1139fa9e4066Sahrens 	    inherit_callback, (void *)prop));
1140fa9e4066Sahrens }
1141fa9e4066Sahrens 
1142fa9e4066Sahrens /*
114307ba0419Seschrock  * list [-rH] [-o property[,property]...] [-t type[,type]...] <dataset> ...
1144fa9e4066Sahrens  *
1145fa9e4066Sahrens  * 	-r	Recurse over all children
1146fa9e4066Sahrens  * 	-H	Scripted mode; elide headers and separate colums by tabs
1147fa9e4066Sahrens  * 	-o	Control which fields to display.
114807ba0419Seschrock  * 	-t	Control which object types to display.
1149fa9e4066Sahrens  *
1150fa9e4066Sahrens  * When given no arguments, lists all filesystems in the system.
1151fa9e4066Sahrens  * Otherwise, list the specified datasets, optionally recursing down them if
1152fa9e4066Sahrens  * '-r' is specified.
1153fa9e4066Sahrens  */
1154fa9e4066Sahrens typedef struct list_cbdata {
115599653d4eSeschrock 	boolean_t	cb_first;
115699653d4eSeschrock 	boolean_t	cb_scripted;
115707ba0419Seschrock 	zfs_prop_t	cb_fields[ZFS_NPROP_ALL];
1158fa9e4066Sahrens 	int		cb_fieldcount;
1159fa9e4066Sahrens } list_cbdata_t;
1160fa9e4066Sahrens 
1161fa9e4066Sahrens /*
1162fa9e4066Sahrens  * Given a list of columns to display, output appropriate headers for each one.
1163fa9e4066Sahrens  */
1164fa9e4066Sahrens static void
116507ba0419Seschrock print_header(zfs_prop_t *fields, size_t count)
1166fa9e4066Sahrens {
1167fa9e4066Sahrens 	int i;
1168fa9e4066Sahrens 
1169fa9e4066Sahrens 	for (i = 0; i < count; i++) {
1170fa9e4066Sahrens 		if (i != 0)
1171fa9e4066Sahrens 			(void) printf("  ");
1172fa9e4066Sahrens 		if (i == count - 1)
1173fa9e4066Sahrens 			(void) printf("%s", zfs_prop_column_name(fields[i]));
1174fa9e4066Sahrens 		else	/* LINTED - format specifier */
1175fa9e4066Sahrens 			(void) printf(zfs_prop_column_format(fields[i]),
1176fa9e4066Sahrens 			    zfs_prop_column_name(fields[i]));
1177fa9e4066Sahrens 	}
1178fa9e4066Sahrens 
1179fa9e4066Sahrens 	(void) printf("\n");
1180fa9e4066Sahrens }
1181fa9e4066Sahrens 
1182fa9e4066Sahrens /*
1183fa9e4066Sahrens  * Given a dataset and a list of fields, print out all the properties according
1184fa9e4066Sahrens  * to the described layout.
1185fa9e4066Sahrens  */
1186fa9e4066Sahrens static void
118707ba0419Seschrock print_dataset(zfs_handle_t *zhp, zfs_prop_t *fields, size_t count, int scripted)
1188fa9e4066Sahrens {
1189fa9e4066Sahrens 	int i;
1190fa9e4066Sahrens 	char property[ZFS_MAXPROPLEN];
1191fa9e4066Sahrens 
1192fa9e4066Sahrens 	for (i = 0; i < count; i++) {
1193fa9e4066Sahrens 		if (i != 0) {
1194fa9e4066Sahrens 			if (scripted)
1195fa9e4066Sahrens 				(void) printf("\t");
1196fa9e4066Sahrens 			else
1197fa9e4066Sahrens 				(void) printf("  ");
1198fa9e4066Sahrens 		}
1199fa9e4066Sahrens 
1200fa9e4066Sahrens 		if (zfs_prop_get(zhp, fields[i], property,
120199653d4eSeschrock 		    sizeof (property), NULL, NULL, 0, B_FALSE) != 0)
1202fa9e4066Sahrens 			(void) strlcpy(property, "-", sizeof (property));
1203fa9e4066Sahrens 
120407ba0419Seschrock 		/*
120507ba0419Seschrock 		 * If this is being called in scripted mode, or if this is the
120607ba0419Seschrock 		 * last column and it is left-justified, don't include a width
120707ba0419Seschrock 		 * format specifier.
120807ba0419Seschrock 		 */
120907ba0419Seschrock 		if (scripted || (i == count - 1 &&
121007ba0419Seschrock 		    strchr(zfs_prop_column_format(fields[i]), '-') != NULL))
1211fa9e4066Sahrens 			(void) printf("%s", property);
1212fa9e4066Sahrens 		else	/* LINTED - format specifier */
1213fa9e4066Sahrens 			(void) printf(zfs_prop_column_format(fields[i]),
1214fa9e4066Sahrens 			    property);
1215fa9e4066Sahrens 	}
1216fa9e4066Sahrens 
1217fa9e4066Sahrens 	(void) printf("\n");
1218fa9e4066Sahrens }
1219fa9e4066Sahrens 
1220fa9e4066Sahrens /*
1221fa9e4066Sahrens  * Generic callback function to list a dataset or snapshot.
1222fa9e4066Sahrens  */
1223fa9e4066Sahrens static int
1224fa9e4066Sahrens list_callback(zfs_handle_t *zhp, void *data)
1225fa9e4066Sahrens {
1226fa9e4066Sahrens 	list_cbdata_t *cbp = data;
1227fa9e4066Sahrens 
1228fa9e4066Sahrens 	if (cbp->cb_first) {
1229fa9e4066Sahrens 		if (!cbp->cb_scripted)
1230fa9e4066Sahrens 			print_header(cbp->cb_fields, cbp->cb_fieldcount);
123199653d4eSeschrock 		cbp->cb_first = B_FALSE;
1232fa9e4066Sahrens 	}
1233fa9e4066Sahrens 
1234fa9e4066Sahrens 	print_dataset(zhp, cbp->cb_fields, cbp->cb_fieldcount,
1235fa9e4066Sahrens 	    cbp->cb_scripted);
1236fa9e4066Sahrens 
1237fa9e4066Sahrens 	return (0);
1238fa9e4066Sahrens }
1239fa9e4066Sahrens 
1240fa9e4066Sahrens static int
1241fa9e4066Sahrens zfs_do_list(int argc, char **argv)
1242fa9e4066Sahrens {
1243fa9e4066Sahrens 	int c;
124499653d4eSeschrock 	boolean_t recurse = B_FALSE;
124599653d4eSeschrock 	boolean_t scripted = B_FALSE;
1246fa9e4066Sahrens 	static char default_fields[] =
1247fa9e4066Sahrens 	    "name,used,available,referenced,mountpoint";
1248fa9e4066Sahrens 	int types = ZFS_TYPE_ANY;
1249fa9e4066Sahrens 	char *fields = NULL;
1250fa9e4066Sahrens 	char *basic_fields = default_fields;
1251fa9e4066Sahrens 	list_cbdata_t cb = { 0 };
1252fa9e4066Sahrens 	char *value;
1253fa9e4066Sahrens 	int ret;
1254fa9e4066Sahrens 	char *type_subopts[] = { "filesystem", "volume", "snapshot", NULL };
125507ba0419Seschrock 	char *badopt;
125607ba0419Seschrock 	int alloffset;
1257fa9e4066Sahrens 
1258fa9e4066Sahrens 	/* check options */
1259fa9e4066Sahrens 	while ((c = getopt(argc, argv, ":o:rt:H")) != -1) {
1260fa9e4066Sahrens 		switch (c) {
1261fa9e4066Sahrens 		case 'o':
1262fa9e4066Sahrens 			fields = optarg;
1263fa9e4066Sahrens 			break;
1264fa9e4066Sahrens 		case 'r':
126599653d4eSeschrock 			recurse = B_TRUE;
1266fa9e4066Sahrens 			break;
1267fa9e4066Sahrens 		case 'H':
126899653d4eSeschrock 			scripted = B_TRUE;
1269fa9e4066Sahrens 			break;
1270fa9e4066Sahrens 		case 't':
1271fa9e4066Sahrens 			types = 0;
1272fa9e4066Sahrens 			while (*optarg != '\0') {
1273fa9e4066Sahrens 				switch (getsubopt(&optarg, type_subopts,
1274fa9e4066Sahrens 				    &value)) {
1275fa9e4066Sahrens 				case 0:
1276fa9e4066Sahrens 					types |= ZFS_TYPE_FILESYSTEM;
1277fa9e4066Sahrens 					break;
1278fa9e4066Sahrens 				case 1:
1279fa9e4066Sahrens 					types |= ZFS_TYPE_VOLUME;
1280fa9e4066Sahrens 					break;
1281fa9e4066Sahrens 				case 2:
1282fa9e4066Sahrens 					types |= ZFS_TYPE_SNAPSHOT;
1283fa9e4066Sahrens 					break;
1284fa9e4066Sahrens 				default:
1285fa9e4066Sahrens 					(void) fprintf(stderr,
1286fa9e4066Sahrens 					    gettext("invalid type '%s'\n"),
1287fa9e4066Sahrens 					    value);
128899653d4eSeschrock 					usage(B_FALSE);
1289fa9e4066Sahrens 				}
1290fa9e4066Sahrens 			}
1291fa9e4066Sahrens 			break;
1292fa9e4066Sahrens 		case ':':
1293fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing argument for "
1294fa9e4066Sahrens 			    "'%c' option\n"), optopt);
129599653d4eSeschrock 			usage(B_FALSE);
1296fa9e4066Sahrens 			break;
1297fa9e4066Sahrens 		case '?':
1298fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
1299fa9e4066Sahrens 			    optopt);
130099653d4eSeschrock 			usage(B_FALSE);
1301fa9e4066Sahrens 		}
1302fa9e4066Sahrens 	}
1303fa9e4066Sahrens 
1304fa9e4066Sahrens 	argc -= optind;
1305fa9e4066Sahrens 	argv += optind;
1306fa9e4066Sahrens 
1307fa9e4066Sahrens 	if (fields == NULL)
1308fa9e4066Sahrens 		fields = basic_fields;
1309fa9e4066Sahrens 
131007ba0419Seschrock 	/*
131107ba0419Seschrock 	 * If the user specifies '-o all', the zfs_get_proplist() doesn't
131207ba0419Seschrock 	 * normally include the name of the dataset.  For 'zfs list', we always
131307ba0419Seschrock 	 * want this property to be first.
131407ba0419Seschrock 	 */
131507ba0419Seschrock 	if (strcmp(fields, "all") == 0) {
131607ba0419Seschrock 		cb.cb_fields[0] = ZFS_PROP_NAME;
131707ba0419Seschrock 		alloffset = 1;
131807ba0419Seschrock 	} else {
131907ba0419Seschrock 		alloffset = 0;
1320fa9e4066Sahrens 	}
1321fa9e4066Sahrens 
132207ba0419Seschrock 	if ((ret = zfs_get_proplist(fields, cb.cb_fields + alloffset,
132307ba0419Seschrock 	    ZFS_NPROP_ALL - alloffset, &cb.cb_fieldcount, &badopt)) != 0) {
132407ba0419Seschrock 		if (ret == EINVAL)
1325fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid property "
132607ba0419Seschrock 			    "'%s'\n"), badopt);
132707ba0419Seschrock 		else
132807ba0419Seschrock 			(void) fprintf(stderr, gettext("too many properties "
132907ba0419Seschrock 			    "specified\n"));
133099653d4eSeschrock 		usage(B_FALSE);
1331fa9e4066Sahrens 	}
1332fa9e4066Sahrens 
133307ba0419Seschrock 	cb.cb_fieldcount += alloffset;
1334fa9e4066Sahrens 	cb.cb_scripted = scripted;
133599653d4eSeschrock 	cb.cb_first = B_TRUE;
1336fa9e4066Sahrens 
1337fa9e4066Sahrens 	ret = zfs_for_each(argc, argv, recurse, types, list_callback, &cb);
1338fa9e4066Sahrens 
133999653d4eSeschrock 	if (ret == 0 && cb.cb_first)
1340fa9e4066Sahrens 		(void) printf(gettext("no datasets available\n"));
1341fa9e4066Sahrens 
1342fa9e4066Sahrens 	return (ret);
1343fa9e4066Sahrens }
1344fa9e4066Sahrens 
1345fa9e4066Sahrens /*
1346fa9e4066Sahrens  * zfs rename <fs | snap | vol> <fs | snap | vol>
1347fa9e4066Sahrens  *
1348fa9e4066Sahrens  * Renames the given dataset to another of the same type.
1349fa9e4066Sahrens  */
1350fa9e4066Sahrens /* ARGSUSED */
1351fa9e4066Sahrens static int
1352fa9e4066Sahrens zfs_do_rename(int argc, char **argv)
1353fa9e4066Sahrens {
1354fa9e4066Sahrens 	zfs_handle_t *zhp;
135599653d4eSeschrock 	int ret;
1356fa9e4066Sahrens 
1357fa9e4066Sahrens 	/* check options */
1358fa9e4066Sahrens 	if (argc > 1 && argv[1][0] == '-') {
1359fa9e4066Sahrens 		(void) fprintf(stderr, gettext("invalid option '%c'\n"),
1360fa9e4066Sahrens 		    argv[1][1]);
136199653d4eSeschrock 		usage(B_FALSE);
1362fa9e4066Sahrens 	}
1363fa9e4066Sahrens 
1364fa9e4066Sahrens 	/* check number of arguments */
1365fa9e4066Sahrens 	if (argc < 2) {
1366fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing source dataset "
1367fa9e4066Sahrens 		    "argument\n"));
136899653d4eSeschrock 		usage(B_FALSE);
1369fa9e4066Sahrens 	}
1370fa9e4066Sahrens 	if (argc < 3) {
1371fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing target dataset "
1372fa9e4066Sahrens 		    "argument\n"));
137399653d4eSeschrock 		usage(B_FALSE);
1374fa9e4066Sahrens 	}
1375fa9e4066Sahrens 	if (argc > 3) {
1376fa9e4066Sahrens 		(void) fprintf(stderr, gettext("too many arguments\n"));
137799653d4eSeschrock 		usage(B_FALSE);
1378fa9e4066Sahrens 	}
1379fa9e4066Sahrens 
138099653d4eSeschrock 	if ((zhp = zfs_open(g_zfs, argv[1], ZFS_TYPE_ANY)) == NULL)
1381fa9e4066Sahrens 		return (1);
1382fa9e4066Sahrens 
138399653d4eSeschrock 	ret = (zfs_rename(zhp, argv[2]) != 0);
1384fa9e4066Sahrens 
138599653d4eSeschrock 	zfs_close(zhp);
138699653d4eSeschrock 	return (ret);
138799653d4eSeschrock }
138899653d4eSeschrock 
138999653d4eSeschrock /*
139099653d4eSeschrock  * zfs promote <fs>
139199653d4eSeschrock  *
139299653d4eSeschrock  * Promotes the given clone fs to be the parent
139399653d4eSeschrock  */
139499653d4eSeschrock /* ARGSUSED */
139599653d4eSeschrock static int
139699653d4eSeschrock zfs_do_promote(int argc, char **argv)
139799653d4eSeschrock {
139899653d4eSeschrock 	zfs_handle_t *zhp;
139999653d4eSeschrock 	int ret;
140099653d4eSeschrock 
140199653d4eSeschrock 	/* check options */
140299653d4eSeschrock 	if (argc > 1 && argv[1][0] == '-') {
140399653d4eSeschrock 		(void) fprintf(stderr, gettext("invalid option '%c'\n"),
140499653d4eSeschrock 		    argv[1][1]);
140599653d4eSeschrock 		usage(B_FALSE);
140699653d4eSeschrock 	}
140799653d4eSeschrock 
140899653d4eSeschrock 	/* check number of arguments */
140999653d4eSeschrock 	if (argc < 2) {
141099653d4eSeschrock 		(void) fprintf(stderr, gettext("missing clone filesystem"
141199653d4eSeschrock 		    "argument\n"));
141299653d4eSeschrock 		usage(B_FALSE);
141399653d4eSeschrock 	}
141499653d4eSeschrock 	if (argc > 2) {
141599653d4eSeschrock 		(void) fprintf(stderr, gettext("too many arguments\n"));
141699653d4eSeschrock 		usage(B_FALSE);
141799653d4eSeschrock 	}
141899653d4eSeschrock 
141999653d4eSeschrock 	zhp = zfs_open(g_zfs, argv[1], ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME);
142099653d4eSeschrock 	if (zhp == NULL)
142199653d4eSeschrock 		return (1);
142299653d4eSeschrock 
142399653d4eSeschrock 	ret = (zfs_promote(zhp) != 0);
142499653d4eSeschrock 
1425fa9e4066Sahrens 	zfs_close(zhp);
1426fa9e4066Sahrens 	return (ret);
1427fa9e4066Sahrens }
1428fa9e4066Sahrens 
1429fa9e4066Sahrens /*
1430fa9e4066Sahrens  * zfs rollback [-rfR] <snapshot>
1431fa9e4066Sahrens  *
1432fa9e4066Sahrens  * 	-r	Delete any intervening snapshots before doing rollback
1433fa9e4066Sahrens  * 	-R	Delete any snapshots and their clones
1434fa9e4066Sahrens  * 	-f	Force unmount filesystems, even if they are in use.
1435fa9e4066Sahrens  *
1436fa9e4066Sahrens  * Given a filesystem, rollback to a specific snapshot, discarding any changes
1437fa9e4066Sahrens  * since then and making it the active dataset.  If more recent snapshots exist,
1438fa9e4066Sahrens  * the command will complain unless the '-r' flag is given.
1439fa9e4066Sahrens  */
1440fa9e4066Sahrens typedef struct rollback_cbdata {
1441fa9e4066Sahrens 	uint64_t	cb_create;
144299653d4eSeschrock 	boolean_t	cb_first;
1443fa9e4066Sahrens 	int		cb_doclones;
1444fa9e4066Sahrens 	char		*cb_target;
1445fa9e4066Sahrens 	int		cb_error;
144699653d4eSeschrock 	boolean_t	cb_recurse;
144799653d4eSeschrock 	boolean_t	cb_dependent;
1448fa9e4066Sahrens } rollback_cbdata_t;
1449fa9e4066Sahrens 
1450fa9e4066Sahrens /*
1451fa9e4066Sahrens  * Report any snapshots more recent than the one specified.  Used when '-r' is
1452fa9e4066Sahrens  * not specified.  We reuse this same callback for the snapshot dependents - if
1453fa9e4066Sahrens  * 'cb_dependent' is set, then this is a dependent and we should report it
1454fa9e4066Sahrens  * without checking the transaction group.
1455fa9e4066Sahrens  */
1456fa9e4066Sahrens static int
1457fa9e4066Sahrens rollback_check(zfs_handle_t *zhp, void *data)
1458fa9e4066Sahrens {
1459fa9e4066Sahrens 	rollback_cbdata_t *cbp = data;
1460fa9e4066Sahrens 
146199653d4eSeschrock 	if (cbp->cb_doclones) {
146299653d4eSeschrock 		zfs_close(zhp);
1463fa9e4066Sahrens 		return (0);
146499653d4eSeschrock 	}
1465fa9e4066Sahrens 
1466fa9e4066Sahrens 	if (!cbp->cb_dependent) {
1467fa9e4066Sahrens 		if (strcmp(zfs_get_name(zhp), cbp->cb_target) != 0 &&
1468b12a1c38Slling 		    zfs_get_type(zhp) == ZFS_TYPE_SNAPSHOT &&
1469fa9e4066Sahrens 		    zfs_prop_get_int(zhp, ZFS_PROP_CREATETXG) >
1470fa9e4066Sahrens 		    cbp->cb_create) {
1471fa9e4066Sahrens 
1472fa9e4066Sahrens 			if (cbp->cb_first && !cbp->cb_recurse) {
1473fa9e4066Sahrens 				(void) fprintf(stderr, gettext("cannot "
1474fa9e4066Sahrens 				    "rollback to '%s': more recent snapshots "
1475fa9e4066Sahrens 				    "exist\n"),
1476fa9e4066Sahrens 				    cbp->cb_target);
1477fa9e4066Sahrens 				(void) fprintf(stderr, gettext("use '-r' to "
1478fa9e4066Sahrens 				    "force deletion of the following "
1479fa9e4066Sahrens 				    "snapshots:\n"));
1480fa9e4066Sahrens 				cbp->cb_first = 0;
1481fa9e4066Sahrens 				cbp->cb_error = 1;
1482fa9e4066Sahrens 			}
1483fa9e4066Sahrens 
1484fa9e4066Sahrens 			if (cbp->cb_recurse) {
148599653d4eSeschrock 				cbp->cb_dependent = B_TRUE;
1486fa9e4066Sahrens 				(void) zfs_iter_dependents(zhp, rollback_check,
1487fa9e4066Sahrens 				    cbp);
148899653d4eSeschrock 				cbp->cb_dependent = B_FALSE;
1489fa9e4066Sahrens 			} else {
1490fa9e4066Sahrens 				(void) fprintf(stderr, "%s\n",
1491fa9e4066Sahrens 				    zfs_get_name(zhp));
1492fa9e4066Sahrens 			}
1493fa9e4066Sahrens 		}
1494fa9e4066Sahrens 	} else {
1495fa9e4066Sahrens 		if (cbp->cb_first && cbp->cb_recurse) {
1496fa9e4066Sahrens 			(void) fprintf(stderr, gettext("cannot rollback to "
1497fa9e4066Sahrens 			    "'%s': clones of previous snapshots exist\n"),
1498fa9e4066Sahrens 			    cbp->cb_target);
1499fa9e4066Sahrens 			(void) fprintf(stderr, gettext("use '-R' to "
1500fa9e4066Sahrens 			    "force deletion of the following clones and "
1501fa9e4066Sahrens 			    "dependents:\n"));
1502fa9e4066Sahrens 			cbp->cb_first = 0;
1503fa9e4066Sahrens 			cbp->cb_error = 1;
1504fa9e4066Sahrens 		}
1505fa9e4066Sahrens 
1506fa9e4066Sahrens 		(void) fprintf(stderr, "%s\n", zfs_get_name(zhp));
1507fa9e4066Sahrens 	}
1508fa9e4066Sahrens 
1509fa9e4066Sahrens 	zfs_close(zhp);
1510fa9e4066Sahrens 	return (0);
1511fa9e4066Sahrens }
1512fa9e4066Sahrens 
1513fa9e4066Sahrens static int
1514fa9e4066Sahrens zfs_do_rollback(int argc, char **argv)
1515fa9e4066Sahrens {
1516fa9e4066Sahrens 	int ret;
1517fa9e4066Sahrens 	int c;
1518fa9e4066Sahrens 	rollback_cbdata_t cb = { 0 };
1519fa9e4066Sahrens 	zfs_handle_t *zhp, *snap;
1520fa9e4066Sahrens 	char parentname[ZFS_MAXNAMELEN];
1521fa9e4066Sahrens 	char *delim;
1522b12a1c38Slling 	int force = 0;
1523fa9e4066Sahrens 
1524fa9e4066Sahrens 	/* check options */
1525fa9e4066Sahrens 	while ((c = getopt(argc, argv, "rfR")) != -1) {
1526fa9e4066Sahrens 		switch (c) {
1527fa9e4066Sahrens 		case 'f':
1528b12a1c38Slling 			force = 1;
1529fa9e4066Sahrens 			break;
1530fa9e4066Sahrens 		case 'r':
1531fa9e4066Sahrens 			cb.cb_recurse = 1;
1532fa9e4066Sahrens 			break;
1533fa9e4066Sahrens 		case 'R':
1534fa9e4066Sahrens 			cb.cb_recurse = 1;
1535fa9e4066Sahrens 			cb.cb_doclones = 1;
1536fa9e4066Sahrens 			break;
1537fa9e4066Sahrens 		case '?':
1538fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
1539fa9e4066Sahrens 			    optopt);
154099653d4eSeschrock 			usage(B_FALSE);
1541fa9e4066Sahrens 		}
1542fa9e4066Sahrens 	}
1543fa9e4066Sahrens 
1544fa9e4066Sahrens 	argc -= optind;
1545fa9e4066Sahrens 	argv += optind;
1546fa9e4066Sahrens 
1547fa9e4066Sahrens 	/* check number of arguments */
1548fa9e4066Sahrens 	if (argc < 1) {
1549fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing dataset argument\n"));
155099653d4eSeschrock 		usage(B_FALSE);
1551fa9e4066Sahrens 	}
1552fa9e4066Sahrens 	if (argc > 1) {
1553fa9e4066Sahrens 		(void) fprintf(stderr, gettext("too many arguments\n"));
155499653d4eSeschrock 		usage(B_FALSE);
1555fa9e4066Sahrens 	}
1556fa9e4066Sahrens 
1557fa9e4066Sahrens 	/* open the snapshot */
155899653d4eSeschrock 	if ((snap = zfs_open(g_zfs, argv[0], ZFS_TYPE_SNAPSHOT)) == NULL)
1559fa9e4066Sahrens 		return (1);
1560fa9e4066Sahrens 
1561b12a1c38Slling 	/* open the parent dataset */
1562b12a1c38Slling 	(void) strlcpy(parentname, argv[0], sizeof (parentname));
1563fa9e4066Sahrens 	verify((delim = strrchr(parentname, '@')) != NULL);
1564fa9e4066Sahrens 	*delim = '\0';
156599653d4eSeschrock 	if ((zhp = zfs_open(g_zfs, parentname, ZFS_TYPE_ANY)) == NULL) {
1566fa9e4066Sahrens 		zfs_close(snap);
1567fa9e4066Sahrens 		return (1);
1568fa9e4066Sahrens 	}
1569fa9e4066Sahrens 
1570fa9e4066Sahrens 	/*
1571fa9e4066Sahrens 	 * Check for more recent snapshots and/or clones based on the presence
1572fa9e4066Sahrens 	 * of '-r' and '-R'.
1573fa9e4066Sahrens 	 */
1574b12a1c38Slling 	cb.cb_target = argv[0];
1575b12a1c38Slling 	cb.cb_create = zfs_prop_get_int(snap, ZFS_PROP_CREATETXG);
157699653d4eSeschrock 	cb.cb_first = B_TRUE;
1577fa9e4066Sahrens 	cb.cb_error = 0;
1578fa9e4066Sahrens 	(void) zfs_iter_children(zhp, rollback_check, &cb);
1579fa9e4066Sahrens 
1580fa9e4066Sahrens 	if ((ret = cb.cb_error) != 0)
1581fa9e4066Sahrens 		goto out;
1582fa9e4066Sahrens 
1583fa9e4066Sahrens 	/*
1584b12a1c38Slling 	 * Rollback parent to the given snapshot.
1585fa9e4066Sahrens 	 */
1586b12a1c38Slling 	ret = zfs_rollback(zhp, snap, force);
1587fa9e4066Sahrens 
1588fa9e4066Sahrens out:
1589fa9e4066Sahrens 	zfs_close(snap);
1590fa9e4066Sahrens 	zfs_close(zhp);
1591fa9e4066Sahrens 
1592fa9e4066Sahrens 	if (ret == 0)
1593fa9e4066Sahrens 		return (0);
1594fa9e4066Sahrens 	else
1595fa9e4066Sahrens 		return (1);
1596fa9e4066Sahrens }
1597fa9e4066Sahrens 
1598fa9e4066Sahrens /*
1599fa9e4066Sahrens  * zfs set property=value { fs | snap | vol } ...
1600fa9e4066Sahrens  *
1601fa9e4066Sahrens  * Sets the given property for all datasets specified on the command line.
1602fa9e4066Sahrens  */
1603fa9e4066Sahrens typedef struct set_cbdata {
1604fa9e4066Sahrens 	char		*cb_propname;
1605fa9e4066Sahrens 	char		*cb_value;
1606fa9e4066Sahrens 	zfs_prop_t	cb_prop;
1607fa9e4066Sahrens } set_cbdata_t;
1608fa9e4066Sahrens 
1609fa9e4066Sahrens static int
1610fa9e4066Sahrens set_callback(zfs_handle_t *zhp, void *data)
1611fa9e4066Sahrens {
1612fa9e4066Sahrens 	set_cbdata_t *cbp = data;
1613fa9e4066Sahrens 	int ret = 1;
1614fa9e4066Sahrens 
1615fa9e4066Sahrens 	/* don't allow setting of properties for snapshots */
1616fa9e4066Sahrens 	if (zfs_get_type(zhp) == ZFS_TYPE_SNAPSHOT) {
1617fa9e4066Sahrens 		(void) fprintf(stderr, gettext("cannot set %s property for "
1618fa9e4066Sahrens 		    "'%s': snapshot properties cannot be modified\n"),
1619fa9e4066Sahrens 		    cbp->cb_propname, zfs_get_name(zhp));
1620fa9e4066Sahrens 		return (1);
1621fa9e4066Sahrens 	}
1622fa9e4066Sahrens 
1623fa9e4066Sahrens 	/*
16245c5460e9Seschrock 	 * If we're changing the volsize, make sure the value is appropriate,
16255c5460e9Seschrock 	 * and set the reservation if this is a non-sparse volume.
1626fa9e4066Sahrens 	 */
1627fa9e4066Sahrens 	if (cbp->cb_prop == ZFS_PROP_VOLSIZE &&
16285c5460e9Seschrock 	    zfs_get_type(zhp) == ZFS_TYPE_VOLUME) {
1629fa9e4066Sahrens 		uint64_t volsize = zfs_prop_get_int(zhp, ZFS_PROP_VOLSIZE);
1630fa9e4066Sahrens 		uint64_t avail = zfs_prop_get_int(zhp, ZFS_PROP_AVAILABLE);
16315c5460e9Seschrock 		uint64_t reservation = zfs_prop_get_int(zhp,
16325c5460e9Seschrock 		    ZFS_PROP_RESERVATION);
16335c5460e9Seschrock 		uint64_t blocksize = zfs_prop_get_int(zhp,
16345c5460e9Seschrock 		    ZFS_PROP_VOLBLOCKSIZE);
1635fa9e4066Sahrens 		uint64_t value;
1636fa9e4066Sahrens 
1637fa9e4066Sahrens 		verify(zfs_nicestrtonum(cbp->cb_value, &value) == 0);
1638fa9e4066Sahrens 
16395c5460e9Seschrock 		if (value % blocksize != 0) {
16405c5460e9Seschrock 			char buf[64];
16415c5460e9Seschrock 
16425c5460e9Seschrock 			zfs_nicenum(blocksize, buf, sizeof (buf));
16435c5460e9Seschrock 			(void) fprintf(stderr, gettext("cannot set %s for "
16445c5460e9Seschrock 			    "'%s': must be a multiple of volume block size "
16455c5460e9Seschrock 			    "(%s)\n"), cbp->cb_propname, zfs_get_name(zhp),
16465c5460e9Seschrock 			    buf);
16475c5460e9Seschrock 			return (1);
16485c5460e9Seschrock 		}
16495c5460e9Seschrock 
16505c5460e9Seschrock 		if (value == 0) {
16515c5460e9Seschrock 			(void) fprintf(stderr, gettext("cannot set %s for "
16525c5460e9Seschrock 			    "'%s': cannot be zero\n"), cbp->cb_propname,
16535c5460e9Seschrock 			    zfs_get_name(zhp));
16545c5460e9Seschrock 			return (1);
16555c5460e9Seschrock 		}
16565c5460e9Seschrock 
16575c5460e9Seschrock 		if (volsize == reservation) {
1658fa9e4066Sahrens 			if (value > volsize && (value - volsize) > avail) {
1659fa9e4066Sahrens 				(void) fprintf(stderr, gettext("cannot set "
1660fa9e4066Sahrens 				    "%s property for '%s': volume size exceeds "
1661fa9e4066Sahrens 				    "amount of available space\n"),
1662fa9e4066Sahrens 				    cbp->cb_propname, zfs_get_name(zhp));
1663fa9e4066Sahrens 				return (1);
1664fa9e4066Sahrens 			}
1665fa9e4066Sahrens 
1666fa9e4066Sahrens 			if (zfs_prop_set(zhp, ZFS_PROP_RESERVATION,
1667fa9e4066Sahrens 			    cbp->cb_value) != 0) {
1668fa9e4066Sahrens 				(void) fprintf(stderr, gettext("volsize and "
1669fa9e4066Sahrens 				    "reservation must remain equal\n"));
1670fa9e4066Sahrens 				return (1);
1671fa9e4066Sahrens 			}
1672fa9e4066Sahrens 		}
16735c5460e9Seschrock 	}
1674fa9e4066Sahrens 
1675fa9e4066Sahrens 	/*
1676fa9e4066Sahrens 	 * Do not allow the reservation to be set above the volume size. We do
1677fa9e4066Sahrens 	 * this here instead of inside libzfs because libzfs violates this rule
1678fa9e4066Sahrens 	 * internally.
1679fa9e4066Sahrens 	 */
1680fa9e4066Sahrens 	if (cbp->cb_prop == ZFS_PROP_RESERVATION &&
1681fa9e4066Sahrens 	    zfs_get_type(zhp) == ZFS_TYPE_VOLUME) {
1682fa9e4066Sahrens 		uint64_t value;
1683fa9e4066Sahrens 		uint64_t volsize;
1684fa9e4066Sahrens 
1685fa9e4066Sahrens 		volsize = zfs_prop_get_int(zhp, ZFS_PROP_VOLSIZE);
1686fa9e4066Sahrens 		if (strcmp(cbp->cb_value, "none") == 0)
1687fa9e4066Sahrens 			value = 0;
1688fa9e4066Sahrens 		else
1689fa9e4066Sahrens 			verify(zfs_nicestrtonum(cbp->cb_value, &value) == 0);
1690fa9e4066Sahrens 
1691fa9e4066Sahrens 		if (value > volsize) {
1692fa9e4066Sahrens 			(void) fprintf(stderr, gettext("cannot set %s "
1693fa9e4066Sahrens 			    "for '%s': size is greater than current "
1694fa9e4066Sahrens 			    "volume size\n"), cbp->cb_propname,
1695fa9e4066Sahrens 			    zfs_get_name(zhp));
1696fa9e4066Sahrens 			return (-1);
1697fa9e4066Sahrens 		}
1698fa9e4066Sahrens 	}
1699fa9e4066Sahrens 
1700efc555ebSnd150628 	if (zfs_prop_set(zhp, cbp->cb_prop, cbp->cb_value) != 0) {
1701efc555ebSnd150628 		switch (libzfs_errno(g_zfs)) {
1702efc555ebSnd150628 		case EZFS_MOUNTFAILED:
1703efc555ebSnd150628 			(void) fprintf(stderr, gettext("property may be set "
1704efc555ebSnd150628 			    "but unable to remount filesystem\n"));
1705efc555ebSnd150628 			break;
1706efc555ebSnd150628 		case EZFS_SHAREFAILED:
1707efc555ebSnd150628 			(void) fprintf(stderr, gettext("property may be set "
1708efc555ebSnd150628 			    "but unable to reshare filesystem\n"));
1709efc555ebSnd150628 			break;
1710efc555ebSnd150628 		}
1711fa9e4066Sahrens 		return (1);
1712efc555ebSnd150628 	}
1713fa9e4066Sahrens 	ret = 0;
1714fa9e4066Sahrens error:
1715fa9e4066Sahrens 	return (ret);
1716fa9e4066Sahrens }
1717fa9e4066Sahrens 
1718fa9e4066Sahrens static int
1719fa9e4066Sahrens zfs_do_set(int argc, char **argv)
1720fa9e4066Sahrens {
1721fa9e4066Sahrens 	set_cbdata_t cb;
1722fa9e4066Sahrens 
1723fa9e4066Sahrens 	/* check for options */
1724fa9e4066Sahrens 	if (argc > 1 && argv[1][0] == '-') {
1725fa9e4066Sahrens 		(void) fprintf(stderr, gettext("invalid option '%c'\n"),
1726fa9e4066Sahrens 		    argv[1][1]);
172799653d4eSeschrock 		usage(B_FALSE);
1728fa9e4066Sahrens 	}
1729fa9e4066Sahrens 
1730fa9e4066Sahrens 	/* check number of arguments */
1731fa9e4066Sahrens 	if (argc < 2) {
1732fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing property=value "
1733fa9e4066Sahrens 		    "argument\n"));
173499653d4eSeschrock 		usage(B_FALSE);
1735fa9e4066Sahrens 	}
1736fa9e4066Sahrens 	if (argc < 3) {
1737fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing dataset name\n"));
173899653d4eSeschrock 		usage(B_FALSE);
1739fa9e4066Sahrens 	}
1740fa9e4066Sahrens 
1741fa9e4066Sahrens 	/* validate property=value argument */
1742fa9e4066Sahrens 	cb.cb_propname = argv[1];
1743fa9e4066Sahrens 	if ((cb.cb_value = strchr(cb.cb_propname, '=')) == NULL) {
1744fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing value in "
1745fa9e4066Sahrens 		    "property=value argument\n"));
174699653d4eSeschrock 		usage(B_FALSE);
1747fa9e4066Sahrens 	}
1748fa9e4066Sahrens 
1749fa9e4066Sahrens 	*cb.cb_value = '\0';
1750fa9e4066Sahrens 	cb.cb_value++;
1751fa9e4066Sahrens 
1752fa9e4066Sahrens 	if (*cb.cb_propname == '\0') {
1753fa9e4066Sahrens 		(void) fprintf(stderr,
1754fa9e4066Sahrens 		    gettext("missing property in property=value argument\n"));
175599653d4eSeschrock 		usage(B_FALSE);
1756fa9e4066Sahrens 	}
1757fa9e4066Sahrens 	if (*cb.cb_value == '\0') {
1758fa9e4066Sahrens 		(void) fprintf(stderr,
1759fa9e4066Sahrens 		    gettext("missing value in property=value argument\n"));
176099653d4eSeschrock 		usage(B_FALSE);
1761fa9e4066Sahrens 	}
1762fa9e4066Sahrens 
1763fa9e4066Sahrens 	/* get the property type */
1764fa9e4066Sahrens 	if ((cb.cb_prop = zfs_name_to_prop(cb.cb_propname)) ==
1765fa9e4066Sahrens 	    ZFS_PROP_INVAL) {
1766fa9e4066Sahrens 		(void) fprintf(stderr,
1767fa9e4066Sahrens 		    gettext("invalid property '%s'\n"), cb.cb_propname);
176899653d4eSeschrock 		usage(B_FALSE);
1769fa9e4066Sahrens 	}
1770fa9e4066Sahrens 
1771fa9e4066Sahrens 	/*
1772fa9e4066Sahrens 	 * Validate that the value is appropriate for this property.  We do this
1773fa9e4066Sahrens 	 * once now so we don't generate multiple errors each time we try to
1774fa9e4066Sahrens 	 * apply it to a dataset.
1775fa9e4066Sahrens 	 */
177699653d4eSeschrock 	if (zfs_prop_validate(g_zfs, cb.cb_prop, cb.cb_value, NULL) != 0)
1777fa9e4066Sahrens 		return (1);
1778fa9e4066Sahrens 
177999653d4eSeschrock 	return (zfs_for_each(argc - 2, argv + 2, B_FALSE,
1780fa9e4066Sahrens 	    ZFS_TYPE_ANY, set_callback, &cb));
1781fa9e4066Sahrens }
1782fa9e4066Sahrens 
1783fa9e4066Sahrens /*
17841d452cf5Sahrens  * zfs snapshot [-r] <fs@snap>
1785fa9e4066Sahrens  *
1786fa9e4066Sahrens  * Creates a snapshot with the given name.  While functionally equivalent to
1787fa9e4066Sahrens  * 'zfs create', it is a separate command to diffferentiate intent.
1788fa9e4066Sahrens  */
1789fa9e4066Sahrens static int
1790fa9e4066Sahrens zfs_do_snapshot(int argc, char **argv)
1791fa9e4066Sahrens {
17921d452cf5Sahrens 	int recursive = B_FALSE;
17931d452cf5Sahrens 	int ret;
17941d452cf5Sahrens 	char c;
17951d452cf5Sahrens 
1796fa9e4066Sahrens 	/* check options */
17971d452cf5Sahrens 	while ((c = getopt(argc, argv, ":r")) != -1) {
17981d452cf5Sahrens 		switch (c) {
17991d452cf5Sahrens 		case 'r':
18001d452cf5Sahrens 			recursive = B_TRUE;
18011d452cf5Sahrens 			break;
18021d452cf5Sahrens 		case '?':
1803fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
18041d452cf5Sahrens 			    optopt);
180599653d4eSeschrock 			usage(B_FALSE);
1806fa9e4066Sahrens 		}
18071d452cf5Sahrens 	}
18081d452cf5Sahrens 
18091d452cf5Sahrens 	argc -= optind;
18101d452cf5Sahrens 	argv += optind;
1811fa9e4066Sahrens 
1812fa9e4066Sahrens 	/* check number of arguments */
18131d452cf5Sahrens 	if (argc < 1) {
1814fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing snapshot argument\n"));
181599653d4eSeschrock 		usage(B_FALSE);
1816fa9e4066Sahrens 	}
18171d452cf5Sahrens 	if (argc > 1) {
1818fa9e4066Sahrens 		(void) fprintf(stderr, gettext("too many arguments\n"));
181999653d4eSeschrock 		usage(B_FALSE);
1820fa9e4066Sahrens 	}
1821fa9e4066Sahrens 
18221d452cf5Sahrens 	ret = zfs_snapshot(g_zfs, argv[0], recursive);
18231d452cf5Sahrens 	if (ret && recursive)
18241d452cf5Sahrens 		(void) fprintf(stderr, gettext("no snapshots were created\n"));
18251d452cf5Sahrens 	return (ret != 0);
18261d452cf5Sahrens 
1827fa9e4066Sahrens }
1828fa9e4066Sahrens 
1829fa9e4066Sahrens /*
1830f2a3c691Sahrens  * zfs send [-i <fs@snap>] <fs@snap>
1831fa9e4066Sahrens  *
1832fa9e4066Sahrens  * Send a backup stream to stdout.
1833fa9e4066Sahrens  */
1834fa9e4066Sahrens static int
1835f2a3c691Sahrens zfs_do_send(int argc, char **argv)
1836fa9e4066Sahrens {
1837fa9e4066Sahrens 	char *fromname = NULL;
1838fa9e4066Sahrens 	zfs_handle_t *zhp_from = NULL, *zhp_to;
1839fa9e4066Sahrens 	int c, err;
1840fa9e4066Sahrens 
1841fa9e4066Sahrens 	/* check options */
1842fa9e4066Sahrens 	while ((c = getopt(argc, argv, ":i:")) != -1) {
1843fa9e4066Sahrens 		switch (c) {
1844fa9e4066Sahrens 		case 'i':
1845fa9e4066Sahrens 			fromname = optarg;
1846fa9e4066Sahrens 			break;
1847fa9e4066Sahrens 		case ':':
1848fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing argument for "
1849fa9e4066Sahrens 			    "'%c' option\n"), optopt);
185099653d4eSeschrock 			usage(B_FALSE);
1851fa9e4066Sahrens 			break;
1852fa9e4066Sahrens 		case '?':
1853fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
1854fa9e4066Sahrens 			    optopt);
185599653d4eSeschrock 			usage(B_FALSE);
1856fa9e4066Sahrens 		}
1857fa9e4066Sahrens 	}
1858fa9e4066Sahrens 
1859fa9e4066Sahrens 	argc -= optind;
1860fa9e4066Sahrens 	argv += optind;
1861fa9e4066Sahrens 
1862fa9e4066Sahrens 	/* check number of arguments */
1863fa9e4066Sahrens 	if (argc < 1) {
1864fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing snapshot argument\n"));
186599653d4eSeschrock 		usage(B_FALSE);
1866fa9e4066Sahrens 	}
1867fa9e4066Sahrens 	if (argc > 1) {
1868fa9e4066Sahrens 		(void) fprintf(stderr, gettext("too many arguments\n"));
186999653d4eSeschrock 		usage(B_FALSE);
1870fa9e4066Sahrens 	}
1871fa9e4066Sahrens 
1872fa9e4066Sahrens 	if (isatty(STDOUT_FILENO)) {
1873fa9e4066Sahrens 		(void) fprintf(stderr,
1874f2a3c691Sahrens 		    gettext("Error: Stream can not be written "
1875fa9e4066Sahrens 			    "to a terminal.\n"
1876fa9e4066Sahrens 			    "You must redirect standard output.\n"));
1877fa9e4066Sahrens 		return (1);
1878fa9e4066Sahrens 	}
1879fa9e4066Sahrens 
1880fa9e4066Sahrens 	if (fromname) {
188199653d4eSeschrock 		if ((zhp_from = zfs_open(g_zfs, fromname,
188299653d4eSeschrock 		    ZFS_TYPE_SNAPSHOT)) == NULL)
1883fa9e4066Sahrens 			return (1);
1884fa9e4066Sahrens 	}
188599653d4eSeschrock 	if ((zhp_to = zfs_open(g_zfs, argv[0], ZFS_TYPE_SNAPSHOT)) == NULL)
1886fa9e4066Sahrens 		return (1);
1887fa9e4066Sahrens 
1888f2a3c691Sahrens 	err = zfs_send(zhp_to, zhp_from);
1889fa9e4066Sahrens 
1890fa9e4066Sahrens 	if (zhp_from)
1891fa9e4066Sahrens 		zfs_close(zhp_from);
1892fa9e4066Sahrens 	zfs_close(zhp_to);
1893fa9e4066Sahrens 
1894fa9e4066Sahrens 	return (err != 0);
1895fa9e4066Sahrens }
1896fa9e4066Sahrens 
1897fa9e4066Sahrens /*
1898f2a3c691Sahrens  * zfs receive <fs@snap>
1899fa9e4066Sahrens  *
1900fa9e4066Sahrens  * Restore a backup stream from stdin.
1901fa9e4066Sahrens  */
1902fa9e4066Sahrens static int
1903f2a3c691Sahrens zfs_do_receive(int argc, char **argv)
1904fa9e4066Sahrens {
1905fa9e4066Sahrens 	int c, err;
190699653d4eSeschrock 	boolean_t isprefix = B_FALSE;
190799653d4eSeschrock 	boolean_t dryrun = B_FALSE;
190899653d4eSeschrock 	boolean_t verbose = B_FALSE;
1909fa9e4066Sahrens 
1910fa9e4066Sahrens 	/* check options */
1911fa9e4066Sahrens 	while ((c = getopt(argc, argv, ":dnv")) != -1) {
1912fa9e4066Sahrens 		switch (c) {
1913fa9e4066Sahrens 		case 'd':
191499653d4eSeschrock 			isprefix = B_TRUE;
1915fa9e4066Sahrens 			break;
1916fa9e4066Sahrens 		case 'n':
191799653d4eSeschrock 			dryrun = B_TRUE;
1918fa9e4066Sahrens 			break;
1919fa9e4066Sahrens 		case 'v':
192099653d4eSeschrock 			verbose = B_TRUE;
1921fa9e4066Sahrens 			break;
1922fa9e4066Sahrens 		case ':':
1923fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing argument for "
1924fa9e4066Sahrens 			    "'%c' option\n"), optopt);
192599653d4eSeschrock 			usage(B_FALSE);
1926fa9e4066Sahrens 			break;
1927fa9e4066Sahrens 		case '?':
1928fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
1929fa9e4066Sahrens 			    optopt);
193099653d4eSeschrock 			usage(B_FALSE);
1931fa9e4066Sahrens 		}
1932fa9e4066Sahrens 	}
1933fa9e4066Sahrens 
1934fa9e4066Sahrens 	argc -= optind;
1935fa9e4066Sahrens 	argv += optind;
1936fa9e4066Sahrens 
1937fa9e4066Sahrens 	/* check number of arguments */
1938fa9e4066Sahrens 	if (argc < 1) {
1939fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing snapshot argument\n"));
194099653d4eSeschrock 		usage(B_FALSE);
1941fa9e4066Sahrens 	}
1942fa9e4066Sahrens 	if (argc > 1) {
1943fa9e4066Sahrens 		(void) fprintf(stderr, gettext("too many arguments\n"));
194499653d4eSeschrock 		usage(B_FALSE);
1945fa9e4066Sahrens 	}
1946fa9e4066Sahrens 
1947fa9e4066Sahrens 	if (isatty(STDIN_FILENO)) {
1948fa9e4066Sahrens 		(void) fprintf(stderr,
1949fa9e4066Sahrens 		    gettext("Error: Backup stream can not be read "
1950fa9e4066Sahrens 			    "from a terminal.\n"
1951fa9e4066Sahrens 			    "You must redirect standard input.\n"));
1952fa9e4066Sahrens 		return (1);
1953fa9e4066Sahrens 	}
1954fa9e4066Sahrens 
195599653d4eSeschrock 	err = zfs_receive(g_zfs, argv[0], isprefix, verbose, dryrun);
1956fa9e4066Sahrens 	return (err != 0);
1957fa9e4066Sahrens }
1958fa9e4066Sahrens 
19597f7322feSeschrock typedef struct get_all_cbdata {
19607f7322feSeschrock 	zfs_handle_t	**cb_handles;
19617f7322feSeschrock 	size_t		cb_alloc;
19627f7322feSeschrock 	size_t		cb_used;
19637f7322feSeschrock } get_all_cbdata_t;
19647f7322feSeschrock 
19657f7322feSeschrock static int
19667f7322feSeschrock get_one_filesystem(zfs_handle_t *zhp, void *data)
19677f7322feSeschrock {
19687f7322feSeschrock 	get_all_cbdata_t *cbp = data;
19697f7322feSeschrock 
19707f7322feSeschrock 	/*
19717f7322feSeschrock 	 * Skip any zvols
19727f7322feSeschrock 	 */
19737f7322feSeschrock 	if (zfs_get_type(zhp) != ZFS_TYPE_FILESYSTEM) {
19747f7322feSeschrock 		zfs_close(zhp);
19757f7322feSeschrock 		return (0);
19767f7322feSeschrock 	}
19777f7322feSeschrock 
19787f7322feSeschrock 	if (cbp->cb_alloc == cbp->cb_used) {
19797f7322feSeschrock 		zfs_handle_t **handles;
19807f7322feSeschrock 
19817f7322feSeschrock 		if (cbp->cb_alloc == 0)
19827f7322feSeschrock 			cbp->cb_alloc = 64;
19837f7322feSeschrock 		else
19847f7322feSeschrock 			cbp->cb_alloc *= 2;
19857f7322feSeschrock 
19867f7322feSeschrock 		handles = safe_malloc(cbp->cb_alloc * sizeof (void *));
19877f7322feSeschrock 
19887f7322feSeschrock 		if (cbp->cb_handles) {
19897f7322feSeschrock 			bcopy(cbp->cb_handles, handles,
19907f7322feSeschrock 			    cbp->cb_used * sizeof (void *));
19917f7322feSeschrock 			free(cbp->cb_handles);
19927f7322feSeschrock 		}
19937f7322feSeschrock 
19947f7322feSeschrock 		cbp->cb_handles = handles;
19957f7322feSeschrock 	}
19967f7322feSeschrock 
19977f7322feSeschrock 	cbp->cb_handles[cbp->cb_used++] = zhp;
19987f7322feSeschrock 
19997f7322feSeschrock 	return (zfs_iter_filesystems(zhp, get_one_filesystem, data));
20007f7322feSeschrock }
20017f7322feSeschrock 
20027f7322feSeschrock static void
20037f7322feSeschrock get_all_filesystems(zfs_handle_t ***fslist, size_t *count)
20047f7322feSeschrock {
20057f7322feSeschrock 	get_all_cbdata_t cb = { 0 };
20067f7322feSeschrock 
200799653d4eSeschrock 	(void) zfs_iter_root(g_zfs, get_one_filesystem, &cb);
20087f7322feSeschrock 
20097f7322feSeschrock 	*fslist = cb.cb_handles;
20107f7322feSeschrock 	*count = cb.cb_used;
20117f7322feSeschrock }
20127f7322feSeschrock 
20137f7322feSeschrock static int
20147f7322feSeschrock mountpoint_compare(const void *a, const void *b)
20157f7322feSeschrock {
20167f7322feSeschrock 	zfs_handle_t **za = (zfs_handle_t **)a;
20177f7322feSeschrock 	zfs_handle_t **zb = (zfs_handle_t **)b;
20187f7322feSeschrock 	char mounta[MAXPATHLEN];
20197f7322feSeschrock 	char mountb[MAXPATHLEN];
20207f7322feSeschrock 
20217f7322feSeschrock 	verify(zfs_prop_get(*za, ZFS_PROP_MOUNTPOINT, mounta,
202299653d4eSeschrock 	    sizeof (mounta), NULL, NULL, 0, B_FALSE) == 0);
20237f7322feSeschrock 	verify(zfs_prop_get(*zb, ZFS_PROP_MOUNTPOINT, mountb,
202499653d4eSeschrock 	    sizeof (mountb), NULL, NULL, 0, B_FALSE) == 0);
20257f7322feSeschrock 
20267f7322feSeschrock 	return (strcmp(mounta, mountb));
20277f7322feSeschrock }
2028fa9e4066Sahrens 
2029fa9e4066Sahrens /*
2030fa9e4066Sahrens  * Generic callback for sharing or mounting filesystems.  Because the code is so
2031fa9e4066Sahrens  * similar, we have a common function with an extra parameter to determine which
2032fa9e4066Sahrens  * mode we are using.
2033fa9e4066Sahrens  */
2034fa9e4066Sahrens #define	OP_SHARE	0x1
2035fa9e4066Sahrens #define	OP_MOUNT	0x2
2036fa9e4066Sahrens 
2037fa9e4066Sahrens typedef struct share_mount_cbdata {
2038fa9e4066Sahrens 	int	cb_type;
2039fa9e4066Sahrens 	int	cb_explicit;
2040fa9e4066Sahrens 	int	cb_flags;
2041fa9e4066Sahrens 	const char *cb_options;
2042fa9e4066Sahrens } share_mount_cbdata_t;
2043fa9e4066Sahrens 
2044fa9e4066Sahrens /*
2045fa9e4066Sahrens  * Share or mount the filesystem.
2046fa9e4066Sahrens  */
2047fa9e4066Sahrens static int
2048fa9e4066Sahrens share_mount_callback(zfs_handle_t *zhp, void *data)
2049fa9e4066Sahrens {
2050fa9e4066Sahrens 	char mountpoint[ZFS_MAXPROPLEN];
2051fa9e4066Sahrens 	char shareopts[ZFS_MAXPROPLEN];
2052fa9e4066Sahrens 	share_mount_cbdata_t *cbp = data;
2053fa9e4066Sahrens 	const char *cmdname = cbp->cb_type == OP_SHARE ? "share" : "mount";
2054fa9e4066Sahrens 	struct mnttab mnt;
2055fa9e4066Sahrens 	uint64_t zoned;
2056fa9e4066Sahrens 
2057fa9e4066Sahrens 	if (cbp->cb_options == NULL)
2058fa9e4066Sahrens 		mnt.mnt_mntopts = "";
2059fa9e4066Sahrens 	else
2060fa9e4066Sahrens 		mnt.mnt_mntopts = (char *)cbp->cb_options;
2061fa9e4066Sahrens 
2062fa9e4066Sahrens 	/*
2063fa9e4066Sahrens 	 * Check to make sure we can mount/share this dataset.  If we are in the
2064fa9e4066Sahrens 	 * global zone and the filesystem is exported to a local zone, or if we
2065fa9e4066Sahrens 	 * are in a local zone and the filesystem is not exported, then it is an
2066fa9e4066Sahrens 	 * error.
2067fa9e4066Sahrens 	 */
2068fa9e4066Sahrens 	zoned = zfs_prop_get_int(zhp, ZFS_PROP_ZONED);
2069fa9e4066Sahrens 
2070fa9e4066Sahrens 	if (zoned && getzoneid() == GLOBAL_ZONEID) {
2071fa9e4066Sahrens 		if (!cbp->cb_explicit)
2072fa9e4066Sahrens 			return (0);
2073fa9e4066Sahrens 
2074fa9e4066Sahrens 		(void) fprintf(stderr, gettext("cannot %s '%s': dataset is "
2075fa9e4066Sahrens 		    "exported to a local zone\n"), cmdname, zfs_get_name(zhp));
2076fa9e4066Sahrens 		return (1);
2077fa9e4066Sahrens 
2078fa9e4066Sahrens 	} else if (!zoned && getzoneid() != GLOBAL_ZONEID) {
2079fa9e4066Sahrens 		if (!cbp->cb_explicit)
2080fa9e4066Sahrens 			return (0);
2081fa9e4066Sahrens 
2082fa9e4066Sahrens 		(void) fprintf(stderr, gettext("cannot %s '%s': permission "
2083fa9e4066Sahrens 		    "denied\n"), cmdname, zfs_get_name(zhp));
2084fa9e4066Sahrens 		return (1);
2085fa9e4066Sahrens 	}
2086fa9e4066Sahrens 
2087fa9e4066Sahrens 	/*
2088fa9e4066Sahrens 	 * Inore any filesystems which don't apply to us.  This includes those
2089fa9e4066Sahrens 	 * with a legacy mountpoint, or those with legacy share options.
2090fa9e4066Sahrens 	 */
2091fa9e4066Sahrens 	verify(zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint,
209299653d4eSeschrock 	    sizeof (mountpoint), NULL, NULL, 0, B_FALSE) == 0);
2093fa9e4066Sahrens 	verify(zfs_prop_get(zhp, ZFS_PROP_SHARENFS, shareopts,
209499653d4eSeschrock 	    sizeof (shareopts), NULL, NULL, 0, B_FALSE) == 0);
2095fa9e4066Sahrens 
2096fa9e4066Sahrens 	if (cbp->cb_type == OP_SHARE) {
2097fa9e4066Sahrens 		if (strcmp(shareopts, "off") == 0) {
2098fa9e4066Sahrens 			if (!cbp->cb_explicit)
2099fa9e4066Sahrens 				return (0);
2100fa9e4066Sahrens 
2101fa9e4066Sahrens 			(void) fprintf(stderr, gettext("cannot share '%s': "
2102fa9e4066Sahrens 			    "legacy share\n"), zfs_get_name(zhp));
2103fa9e4066Sahrens 			(void) fprintf(stderr, gettext("use share(1M) to "
2104fa9e4066Sahrens 			    "share this filesystem\n"));
2105fa9e4066Sahrens 			return (1);
2106fa9e4066Sahrens 		}
2107fa9e4066Sahrens 	}
2108fa9e4066Sahrens 
2109fa9e4066Sahrens 	/*
2110fa9e4066Sahrens 	 * We cannot share or mount legacy filesystems.  If the shareopts is
2111fa9e4066Sahrens 	 * non-legacy but the mountpoint is legacy, we treat it as a legacy
2112fa9e4066Sahrens 	 * share.
2113fa9e4066Sahrens 	 */
2114fa9e4066Sahrens 	if (strcmp(mountpoint, "legacy") == 0) {
2115fa9e4066Sahrens 		if (!cbp->cb_explicit)
2116fa9e4066Sahrens 			return (0);
2117fa9e4066Sahrens 
2118fa9e4066Sahrens 		(void) fprintf(stderr, gettext("cannot %s '%s': "
2119fa9e4066Sahrens 		    "legacy mountpoint\n"), cmdname, zfs_get_name(zhp));
2120fa9e4066Sahrens 		(void) fprintf(stderr, gettext("use %s to "
2121fa9e4066Sahrens 		    "%s this filesystem\n"), cbp->cb_type == OP_SHARE ?
2122fa9e4066Sahrens 		    "share(1M)" : "mount(1M)", cmdname);
2123fa9e4066Sahrens 		return (1);
2124fa9e4066Sahrens 	}
2125fa9e4066Sahrens 
2126fa9e4066Sahrens 	if (strcmp(mountpoint, "none") == 0) {
2127fa9e4066Sahrens 		if (!cbp->cb_explicit)
2128fa9e4066Sahrens 			return (0);
2129fa9e4066Sahrens 
2130fa9e4066Sahrens 		(void) fprintf(stderr, gettext("cannot %s '%s': no "
2131fa9e4066Sahrens 		    "mountpoint set\n"), cmdname, zfs_get_name(zhp));
2132fa9e4066Sahrens 		return (1);
2133fa9e4066Sahrens 	}
2134fa9e4066Sahrens 
2135fa9e4066Sahrens 	/*
2136fa9e4066Sahrens 	 * At this point, we have verified that the mountpoint and/or shareopts
2137fa9e4066Sahrens 	 * are appropriate for auto management.  Determine if the filesystem is
2138fa9e4066Sahrens 	 * currently mounted or shared, and abort if this is an explicit
2139fa9e4066Sahrens 	 * request.
2140fa9e4066Sahrens 	 */
2141fa9e4066Sahrens 	switch (cbp->cb_type) {
2142fa9e4066Sahrens 	case OP_SHARE:
2143fa9e4066Sahrens 		if (zfs_is_shared(zhp, NULL)) {
2144fa9e4066Sahrens 			if (cbp->cb_explicit) {
2145fa9e4066Sahrens 				(void) fprintf(stderr, gettext("cannot share "
2146fa9e4066Sahrens 				    "'%s': filesystem already shared\n"),
2147fa9e4066Sahrens 				    zfs_get_name(zhp));
2148fa9e4066Sahrens 				return (1);
2149fa9e4066Sahrens 			} else {
2150fa9e4066Sahrens 				return (0);
2151fa9e4066Sahrens 			}
2152fa9e4066Sahrens 		}
2153fa9e4066Sahrens 		break;
2154fa9e4066Sahrens 
2155fa9e4066Sahrens 	case OP_MOUNT:
2156fa9e4066Sahrens 		if (!hasmntopt(&mnt, MNTOPT_REMOUNT) &&
2157fa9e4066Sahrens 		    zfs_is_mounted(zhp, NULL)) {
2158fa9e4066Sahrens 			if (cbp->cb_explicit) {
2159fa9e4066Sahrens 				(void) fprintf(stderr, gettext("cannot mount "
2160fa9e4066Sahrens 				    "'%s': filesystem already mounted\n"),
2161fa9e4066Sahrens 				    zfs_get_name(zhp));
2162fa9e4066Sahrens 				return (1);
2163fa9e4066Sahrens 			} else {
2164fa9e4066Sahrens 				return (0);
2165fa9e4066Sahrens 			}
2166fa9e4066Sahrens 		}
2167fa9e4066Sahrens 		break;
2168fa9e4066Sahrens 	}
2169fa9e4066Sahrens 
2170fa9e4066Sahrens 	/*
2171fa9e4066Sahrens 	 * Mount and optionally share the filesystem.
2172fa9e4066Sahrens 	 */
2173fa9e4066Sahrens 	switch (cbp->cb_type) {
2174fa9e4066Sahrens 	case OP_SHARE:
2175fa9e4066Sahrens 		{
2176fa9e4066Sahrens 			if (!zfs_is_mounted(zhp, NULL) &&
2177fa9e4066Sahrens 			    zfs_mount(zhp, NULL, 0) != 0)
2178fa9e4066Sahrens 				return (1);
2179fa9e4066Sahrens 
2180fa9e4066Sahrens 			if (zfs_share(zhp) != 0)
2181fa9e4066Sahrens 				return (1);
2182fa9e4066Sahrens 		}
2183fa9e4066Sahrens 		break;
2184fa9e4066Sahrens 
2185fa9e4066Sahrens 	case OP_MOUNT:
2186fa9e4066Sahrens 		if (zfs_mount(zhp, cbp->cb_options, cbp->cb_flags) != 0)
2187fa9e4066Sahrens 			return (1);
2188fa9e4066Sahrens 		break;
2189fa9e4066Sahrens 	}
2190fa9e4066Sahrens 
2191fa9e4066Sahrens 	return (0);
2192fa9e4066Sahrens }
2193fa9e4066Sahrens 
2194fa9e4066Sahrens static int
2195fa9e4066Sahrens share_or_mount(int type, int argc, char **argv)
2196fa9e4066Sahrens {
2197fa9e4066Sahrens 	int do_all = 0;
2198fa9e4066Sahrens 	int c, ret;
2199fa9e4066Sahrens 	share_mount_cbdata_t cb = { 0 };
2200fa9e4066Sahrens 
2201fa9e4066Sahrens 	cb.cb_type = type;
2202fa9e4066Sahrens 
2203fa9e4066Sahrens 	/* check options */
2204fa9e4066Sahrens 	while ((c = getopt(argc, argv, type == OP_MOUNT ? ":ao:O" : "a"))
2205fa9e4066Sahrens 	    != -1) {
2206fa9e4066Sahrens 		switch (c) {
2207fa9e4066Sahrens 		case 'a':
2208fa9e4066Sahrens 			do_all = 1;
2209fa9e4066Sahrens 			break;
2210fa9e4066Sahrens 		case 'o':
2211fa9e4066Sahrens 			cb.cb_options = optarg;
2212fa9e4066Sahrens 			break;
2213fa9e4066Sahrens 		case 'O':
2214fa9e4066Sahrens 			cb.cb_flags |= MS_OVERLAY;
2215fa9e4066Sahrens 			break;
2216fa9e4066Sahrens 		case ':':
2217fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing argument for "
2218fa9e4066Sahrens 			    "'%c' option\n"), optopt);
221999653d4eSeschrock 			usage(B_FALSE);
2220fa9e4066Sahrens 			break;
2221fa9e4066Sahrens 		case '?':
2222fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
2223fa9e4066Sahrens 			    optopt);
222499653d4eSeschrock 			usage(B_FALSE);
2225fa9e4066Sahrens 		}
2226fa9e4066Sahrens 	}
2227fa9e4066Sahrens 
2228fa9e4066Sahrens 	argc -= optind;
2229fa9e4066Sahrens 	argv += optind;
2230fa9e4066Sahrens 
2231fa9e4066Sahrens 	/* check number of arguments */
2232fa9e4066Sahrens 	if (do_all) {
22337f7322feSeschrock 		zfs_handle_t **fslist = NULL;
22347f7322feSeschrock 		size_t i, count = 0;
22357f7322feSeschrock 
2236fa9e4066Sahrens 		if (argc != 0) {
2237fa9e4066Sahrens 			(void) fprintf(stderr, gettext("too many arguments\n"));
223899653d4eSeschrock 			usage(B_FALSE);
2239fa9e4066Sahrens 		}
2240fa9e4066Sahrens 
22417f7322feSeschrock 		get_all_filesystems(&fslist, &count);
22427f7322feSeschrock 
22437f7322feSeschrock 		if (count == 0)
22447f7322feSeschrock 			return (0);
22457f7322feSeschrock 
22467f7322feSeschrock 		qsort(fslist, count, sizeof (void *), mountpoint_compare);
22477f7322feSeschrock 
22487f7322feSeschrock 		for (i = 0; i < count; i++) {
2249*55b04f29Slling 			if (share_mount_callback(fslist[i], &cb) != 0)
2250*55b04f29Slling 				ret = 1;
22517f7322feSeschrock 		}
22527f7322feSeschrock 
22537f7322feSeschrock 		for (i = 0; i < count; i++)
22547f7322feSeschrock 			zfs_close(fslist[i]);
22557f7322feSeschrock 
22567f7322feSeschrock 		free(fslist);
2257fa9e4066Sahrens 	} else if (argc == 0) {
2258fa9e4066Sahrens 		struct mnttab entry;
2259fa9e4066Sahrens 
2260fa9e4066Sahrens 		if (type == OP_SHARE) {
2261fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing filesystem "
2262fa9e4066Sahrens 			    "argument\n"));
226399653d4eSeschrock 			usage(B_FALSE);
2264fa9e4066Sahrens 		}
2265fa9e4066Sahrens 
2266fa9e4066Sahrens 		/*
2267fa9e4066Sahrens 		 * When mount is given no arguments, go through /etc/mnttab and
2268fa9e4066Sahrens 		 * display any active ZFS mounts.  We hide any snapshots, since
2269fa9e4066Sahrens 		 * they are controlled automatically.
2270fa9e4066Sahrens 		 */
2271fa9e4066Sahrens 		rewind(mnttab_file);
2272fa9e4066Sahrens 		while (getmntent(mnttab_file, &entry) == 0) {
2273fa9e4066Sahrens 			if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0 ||
2274fa9e4066Sahrens 			    strchr(entry.mnt_special, '@') != NULL)
2275fa9e4066Sahrens 				continue;
2276fa9e4066Sahrens 
2277fa9e4066Sahrens 			(void) printf("%-30s  %s\n", entry.mnt_special,
2278fa9e4066Sahrens 			    entry.mnt_mountp);
2279fa9e4066Sahrens 		}
2280fa9e4066Sahrens 
2281fa9e4066Sahrens 		ret = 0;
2282fa9e4066Sahrens 	} else {
2283fa9e4066Sahrens 		zfs_handle_t *zhp;
2284fa9e4066Sahrens 
2285fa9e4066Sahrens 		if (argc > 1) {
2286fa9e4066Sahrens 			(void) fprintf(stderr,
2287fa9e4066Sahrens 			    gettext("too many arguments\n"));
228899653d4eSeschrock 			usage(B_FALSE);
2289fa9e4066Sahrens 		}
2290fa9e4066Sahrens 
229199653d4eSeschrock 		if ((zhp = zfs_open(g_zfs, argv[0],
229299653d4eSeschrock 		    ZFS_TYPE_FILESYSTEM)) == NULL)
2293fa9e4066Sahrens 			ret = 1;
2294fa9e4066Sahrens 		else {
229599653d4eSeschrock 			cb.cb_explicit = B_TRUE;
2296fa9e4066Sahrens 			ret = share_mount_callback(zhp, &cb);
2297fa9e4066Sahrens 			zfs_close(zhp);
2298fa9e4066Sahrens 		}
2299fa9e4066Sahrens 	}
2300fa9e4066Sahrens 
2301fa9e4066Sahrens 	return (ret);
2302fa9e4066Sahrens }
2303fa9e4066Sahrens 
2304fa9e4066Sahrens /*
2305fa9e4066Sahrens  * zfs mount -a
2306fa9e4066Sahrens  * zfs mount filesystem
2307fa9e4066Sahrens  *
2308fa9e4066Sahrens  * Mount all filesystems, or mount the given filesystem.
2309fa9e4066Sahrens  */
2310fa9e4066Sahrens static int
2311fa9e4066Sahrens zfs_do_mount(int argc, char **argv)
2312fa9e4066Sahrens {
2313fa9e4066Sahrens 	return (share_or_mount(OP_MOUNT, argc, argv));
2314fa9e4066Sahrens }
2315fa9e4066Sahrens 
2316fa9e4066Sahrens /*
2317fa9e4066Sahrens  * zfs share -a
2318fa9e4066Sahrens  * zfs share filesystem
2319fa9e4066Sahrens  *
2320fa9e4066Sahrens  * Share all filesystems, or share the given filesystem.
2321fa9e4066Sahrens  */
2322fa9e4066Sahrens static int
2323fa9e4066Sahrens zfs_do_share(int argc, char **argv)
2324fa9e4066Sahrens {
2325fa9e4066Sahrens 	return (share_or_mount(OP_SHARE, argc, argv));
2326fa9e4066Sahrens }
2327fa9e4066Sahrens 
2328fa9e4066Sahrens typedef struct unshare_unmount_node {
2329fa9e4066Sahrens 	zfs_handle_t	*un_zhp;
2330fa9e4066Sahrens 	char		*un_mountp;
2331fa9e4066Sahrens 	uu_avl_node_t	un_avlnode;
2332fa9e4066Sahrens } unshare_unmount_node_t;
2333fa9e4066Sahrens 
2334fa9e4066Sahrens /* ARGSUSED */
2335fa9e4066Sahrens static int
2336fa9e4066Sahrens unshare_unmount_compare(const void *larg, const void *rarg, void *unused)
2337fa9e4066Sahrens {
2338fa9e4066Sahrens 	const unshare_unmount_node_t *l = larg;
2339fa9e4066Sahrens 	const unshare_unmount_node_t *r = rarg;
2340fa9e4066Sahrens 
2341fa9e4066Sahrens 	return (strcmp(l->un_mountp, r->un_mountp));
2342fa9e4066Sahrens }
2343fa9e4066Sahrens 
2344fa9e4066Sahrens /*
2345fa9e4066Sahrens  * Convenience routine used by zfs_do_umount() and manual_unmount().  Given an
2346fa9e4066Sahrens  * absolute path, find the entry /etc/mnttab, verify that its a ZFS filesystem,
2347fa9e4066Sahrens  * and unmount it appropriately.
2348fa9e4066Sahrens  */
2349fa9e4066Sahrens static int
235099653d4eSeschrock unshare_unmount_path(int type, char *path, int flags, boolean_t is_manual)
2351fa9e4066Sahrens {
2352fa9e4066Sahrens 	zfs_handle_t *zhp;
2353fa9e4066Sahrens 	int ret;
2354fa9e4066Sahrens 	struct stat64 statbuf;
2355fa9e4066Sahrens 	struct extmnttab entry;
2356fa9e4066Sahrens 	const char *cmdname = (type == OP_SHARE) ? "unshare" : "unmount";
2357fa9e4066Sahrens 	char property[ZFS_MAXPROPLEN];
2358fa9e4066Sahrens 
2359fa9e4066Sahrens 	/*
2360fa9e4066Sahrens 	 * Search for the path in /etc/mnttab.  Rather than looking for the
2361fa9e4066Sahrens 	 * specific path, which can be fooled by non-standard paths (i.e. ".."
2362fa9e4066Sahrens 	 * or "//"), we stat() the path and search for the corresponding
2363fa9e4066Sahrens 	 * (major,minor) device pair.
2364fa9e4066Sahrens 	 */
2365fa9e4066Sahrens 	if (stat64(path, &statbuf) != 0) {
2366fa9e4066Sahrens 		(void) fprintf(stderr, gettext("cannot %s '%s': %s\n"),
2367fa9e4066Sahrens 		    cmdname, path, strerror(errno));
2368fa9e4066Sahrens 		return (1);
2369fa9e4066Sahrens 	}
2370fa9e4066Sahrens 
2371fa9e4066Sahrens 	/*
2372fa9e4066Sahrens 	 * Search for the given (major,minor) pair in the mount table.
2373fa9e4066Sahrens 	 */
2374fa9e4066Sahrens 	rewind(mnttab_file);
2375fa9e4066Sahrens 	while ((ret = getextmntent(mnttab_file, &entry, 0)) == 0) {
2376fa9e4066Sahrens 		if (entry.mnt_major == major(statbuf.st_dev) &&
2377fa9e4066Sahrens 		    entry.mnt_minor == minor(statbuf.st_dev))
2378fa9e4066Sahrens 			break;
2379fa9e4066Sahrens 	}
2380fa9e4066Sahrens 	if (ret != 0) {
2381fa9e4066Sahrens 		(void) fprintf(stderr, gettext("cannot %s '%s': not "
2382fa9e4066Sahrens 		    "currently mounted\n"), cmdname, path);
2383fa9e4066Sahrens 		return (1);
2384fa9e4066Sahrens 	}
2385fa9e4066Sahrens 
2386fa9e4066Sahrens 	if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0) {
2387fa9e4066Sahrens 		(void) fprintf(stderr, gettext("cannot %s '%s': not a ZFS "
2388fa9e4066Sahrens 		    "filesystem\n"), cmdname, path);
2389fa9e4066Sahrens 		return (1);
2390fa9e4066Sahrens 	}
2391fa9e4066Sahrens 
239299653d4eSeschrock 	if ((zhp = zfs_open(g_zfs, entry.mnt_special,
239399653d4eSeschrock 	    ZFS_TYPE_FILESYSTEM)) == NULL)
2394fa9e4066Sahrens 		return (1);
2395fa9e4066Sahrens 
2396fa9e4066Sahrens 	verify(zfs_prop_get(zhp, type == OP_SHARE ?
2397fa9e4066Sahrens 		ZFS_PROP_SHARENFS : ZFS_PROP_MOUNTPOINT, property,
239899653d4eSeschrock 		sizeof (property), NULL, NULL, 0, B_FALSE) == 0);
2399fa9e4066Sahrens 
2400fa9e4066Sahrens 	if (type == OP_SHARE) {
2401fa9e4066Sahrens 		if (strcmp(property, "off") == 0) {
2402fa9e4066Sahrens 			(void) fprintf(stderr, gettext("cannot unshare "
2403fa9e4066Sahrens 			    "'%s': legacy share\n"), path);
2404fa9e4066Sahrens 			(void) fprintf(stderr, gettext("use "
2405fa9e4066Sahrens 			    "unshare(1M) to unshare this filesystem\n"));
2406fa9e4066Sahrens 			ret = 1;
2407fa9e4066Sahrens 		} else if (!zfs_is_shared(zhp, NULL)) {
2408fa9e4066Sahrens 			(void) fprintf(stderr, gettext("cannot unshare '%s': "
2409fa9e4066Sahrens 			    "not currently shared\n"), path);
2410fa9e4066Sahrens 			ret = 1;
2411fa9e4066Sahrens 		} else {
2412fa9e4066Sahrens 			ret = zfs_unshareall(zhp);
2413fa9e4066Sahrens 		}
2414fa9e4066Sahrens 	} else {
24156b90ca48Slling 		if (is_manual) {
24166b90ca48Slling 			ret = zfs_unmount(zhp, NULL, flags);
2417c0ea9bc7Slling 		} else if (strcmp(property, "legacy") == 0) {
2418fa9e4066Sahrens 			(void) fprintf(stderr, gettext("cannot unmount "
2419fa9e4066Sahrens 			    "'%s': legacy mountpoint\n"),
2420fa9e4066Sahrens 			    zfs_get_name(zhp));
2421fa9e4066Sahrens 			(void) fprintf(stderr, gettext("use umount(1M) "
2422fa9e4066Sahrens 			    "to unmount this filesystem\n"));
2423fa9e4066Sahrens 			ret = 1;
2424fa9e4066Sahrens 		} else {
2425fa9e4066Sahrens 			ret = zfs_unmountall(zhp, flags);
2426fa9e4066Sahrens 		}
2427fa9e4066Sahrens 	}
2428fa9e4066Sahrens 
2429fa9e4066Sahrens 	zfs_close(zhp);
2430fa9e4066Sahrens 
2431fa9e4066Sahrens 	return (ret != 0);
2432fa9e4066Sahrens }
2433fa9e4066Sahrens 
2434fa9e4066Sahrens /*
2435fa9e4066Sahrens  * Generic callback for unsharing or unmounting a filesystem.
2436fa9e4066Sahrens  */
2437fa9e4066Sahrens static int
2438fa9e4066Sahrens unshare_unmount(int type, int argc, char **argv)
2439fa9e4066Sahrens {
2440fa9e4066Sahrens 	int do_all = 0;
2441fa9e4066Sahrens 	int flags = 0;
2442fa9e4066Sahrens 	int ret = 0;
2443fa9e4066Sahrens 	int c;
2444fa9e4066Sahrens 	zfs_handle_t *zhp;
2445fa9e4066Sahrens 	char property[ZFS_MAXPROPLEN];
2446fa9e4066Sahrens 
2447fa9e4066Sahrens 	/* check options */
2448fa9e4066Sahrens 	while ((c = getopt(argc, argv, type == OP_SHARE ? "a" : "af")) != -1) {
2449fa9e4066Sahrens 		switch (c) {
2450fa9e4066Sahrens 		case 'a':
2451fa9e4066Sahrens 			do_all = 1;
2452fa9e4066Sahrens 			break;
2453fa9e4066Sahrens 		case 'f':
2454fa9e4066Sahrens 			flags = MS_FORCE;
2455fa9e4066Sahrens 			break;
2456fa9e4066Sahrens 		case '?':
2457fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
2458fa9e4066Sahrens 			    optopt);
245999653d4eSeschrock 			usage(B_FALSE);
2460fa9e4066Sahrens 		}
2461fa9e4066Sahrens 	}
2462fa9e4066Sahrens 
2463fa9e4066Sahrens 	argc -= optind;
2464fa9e4066Sahrens 	argv += optind;
2465fa9e4066Sahrens 
2466fa9e4066Sahrens 	/* ensure correct number of arguments */
2467fa9e4066Sahrens 	if (do_all) {
2468fa9e4066Sahrens 		if (argc != 0) {
2469fa9e4066Sahrens 			(void) fprintf(stderr, gettext("too many arguments\n"));
247099653d4eSeschrock 			usage(B_FALSE);
2471fa9e4066Sahrens 		}
2472fa9e4066Sahrens 	} else if (argc != 1) {
2473fa9e4066Sahrens 		if (argc == 0)
2474fa9e4066Sahrens 			(void) fprintf(stderr,
2475fa9e4066Sahrens 			    gettext("missing filesystem argument\n"));
2476fa9e4066Sahrens 		else
2477fa9e4066Sahrens 			(void) fprintf(stderr,
2478fa9e4066Sahrens 			    gettext("too many arguments\n"));
247999653d4eSeschrock 		usage(B_FALSE);
2480fa9e4066Sahrens 	}
2481fa9e4066Sahrens 
2482fa9e4066Sahrens 	if (do_all) {
2483fa9e4066Sahrens 		/*
2484fa9e4066Sahrens 		 * We could make use of zfs_for_each() to walk all datasets in
2485fa9e4066Sahrens 		 * the system, but this would be very inefficient, especially
2486fa9e4066Sahrens 		 * since we would have to linearly search /etc/mnttab for each
2487fa9e4066Sahrens 		 * one.  Instead, do one pass through /etc/mnttab looking for
2488fa9e4066Sahrens 		 * zfs entries and call zfs_unmount() for each one.
2489fa9e4066Sahrens 		 *
2490fa9e4066Sahrens 		 * Things get a little tricky if the administrator has created
2491fa9e4066Sahrens 		 * mountpoints beneath other ZFS filesystems.  In this case, we
2492fa9e4066Sahrens 		 * have to unmount the deepest filesystems first.  To accomplish
2493fa9e4066Sahrens 		 * this, we place all the mountpoints in an AVL tree sorted by
2494fa9e4066Sahrens 		 * the special type (dataset name), and walk the result in
2495fa9e4066Sahrens 		 * reverse to make sure to get any snapshots first.
2496fa9e4066Sahrens 		 */
2497fa9e4066Sahrens 		struct mnttab entry;
2498fa9e4066Sahrens 		uu_avl_pool_t *pool;
2499fa9e4066Sahrens 		uu_avl_t *tree;
2500fa9e4066Sahrens 		unshare_unmount_node_t *node;
2501fa9e4066Sahrens 		uu_avl_index_t idx;
2502fa9e4066Sahrens 		uu_avl_walk_t *walk;
2503fa9e4066Sahrens 
2504fa9e4066Sahrens 		if ((pool = uu_avl_pool_create("unmount_pool",
2505fa9e4066Sahrens 		    sizeof (unshare_unmount_node_t),
2506fa9e4066Sahrens 		    offsetof(unshare_unmount_node_t, un_avlnode),
2507fa9e4066Sahrens 		    unshare_unmount_compare,
2508fa9e4066Sahrens 		    UU_DEFAULT)) == NULL) {
2509fa9e4066Sahrens 			(void) fprintf(stderr, gettext("internal error: "
2510fa9e4066Sahrens 			    "out of memory\n"));
2511fa9e4066Sahrens 			exit(1);
2512fa9e4066Sahrens 		}
2513fa9e4066Sahrens 
2514fa9e4066Sahrens 		if ((tree = uu_avl_create(pool, NULL, UU_DEFAULT)) == NULL) {
2515fa9e4066Sahrens 			(void) fprintf(stderr, gettext("internal error: "
2516fa9e4066Sahrens 			    "out of memory\n"));
2517fa9e4066Sahrens 			exit(1);
2518fa9e4066Sahrens 		}
2519fa9e4066Sahrens 
2520fa9e4066Sahrens 		rewind(mnttab_file);
2521fa9e4066Sahrens 		while (getmntent(mnttab_file, &entry) == 0) {
2522fa9e4066Sahrens 
2523fa9e4066Sahrens 			/* ignore non-ZFS entries */
2524fa9e4066Sahrens 			if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0)
2525fa9e4066Sahrens 				continue;
2526fa9e4066Sahrens 
2527fa9e4066Sahrens 			/* ignore snapshots */
2528fa9e4066Sahrens 			if (strchr(entry.mnt_special, '@') != NULL)
2529fa9e4066Sahrens 				continue;
2530fa9e4066Sahrens 
253199653d4eSeschrock 			if ((zhp = zfs_open(g_zfs, entry.mnt_special,
2532fa9e4066Sahrens 			    ZFS_TYPE_FILESYSTEM)) == NULL) {
2533fa9e4066Sahrens 				ret = 1;
2534fa9e4066Sahrens 				continue;
2535fa9e4066Sahrens 			}
2536fa9e4066Sahrens 
2537fa9e4066Sahrens 			verify(zfs_prop_get(zhp, type == OP_SHARE ?
2538fa9e4066Sahrens 			    ZFS_PROP_SHARENFS : ZFS_PROP_MOUNTPOINT,
2539fa9e4066Sahrens 			    property, sizeof (property), NULL, NULL,
254099653d4eSeschrock 			    0, B_FALSE) == 0);
2541fa9e4066Sahrens 
2542fa9e4066Sahrens 			/* Ignore legacy mounts and shares */
2543fa9e4066Sahrens 			if ((type == OP_SHARE &&
2544fa9e4066Sahrens 			    strcmp(property, "off") == 0) ||
2545fa9e4066Sahrens 			    (type == OP_MOUNT &&
2546fa9e4066Sahrens 			    strcmp(property, "legacy") == 0)) {
2547fa9e4066Sahrens 				zfs_close(zhp);
2548fa9e4066Sahrens 				continue;
2549fa9e4066Sahrens 			}
2550fa9e4066Sahrens 
2551fa9e4066Sahrens 			node = safe_malloc(sizeof (unshare_unmount_node_t));
2552fa9e4066Sahrens 			node->un_zhp = zhp;
2553fa9e4066Sahrens 
2554fa9e4066Sahrens 			if ((node->un_mountp = strdup(entry.mnt_mountp)) ==
2555fa9e4066Sahrens 			    NULL) {
2556fa9e4066Sahrens 				(void) fprintf(stderr, gettext("internal error:"
2557fa9e4066Sahrens 				    " out of memory\n"));
2558fa9e4066Sahrens 				exit(1);
2559fa9e4066Sahrens 			}
2560fa9e4066Sahrens 
2561fa9e4066Sahrens 			uu_avl_node_init(node, &node->un_avlnode, pool);
2562fa9e4066Sahrens 
2563fa9e4066Sahrens 			if (uu_avl_find(tree, node, NULL, &idx) == NULL) {
2564fa9e4066Sahrens 				uu_avl_insert(tree, node, idx);
2565fa9e4066Sahrens 			} else {
2566fa9e4066Sahrens 				zfs_close(node->un_zhp);
2567fa9e4066Sahrens 				free(node->un_mountp);
2568fa9e4066Sahrens 				free(node);
2569fa9e4066Sahrens 			}
2570fa9e4066Sahrens 		}
2571fa9e4066Sahrens 
2572fa9e4066Sahrens 		/*
2573fa9e4066Sahrens 		 * Walk the AVL tree in reverse, unmounting each filesystem and
2574fa9e4066Sahrens 		 * removing it from the AVL tree in the process.
2575fa9e4066Sahrens 		 */
2576fa9e4066Sahrens 		if ((walk = uu_avl_walk_start(tree,
2577fa9e4066Sahrens 		    UU_WALK_REVERSE | UU_WALK_ROBUST)) == NULL) {
2578fa9e4066Sahrens 			(void) fprintf(stderr,
2579fa9e4066Sahrens 			    gettext("internal error: out of memory"));
2580fa9e4066Sahrens 			exit(1);
2581fa9e4066Sahrens 		}
2582fa9e4066Sahrens 
2583fa9e4066Sahrens 		while ((node = uu_avl_walk_next(walk)) != NULL) {
2584fa9e4066Sahrens 			uu_avl_remove(tree, node);
2585fa9e4066Sahrens 
2586fa9e4066Sahrens 			switch (type) {
2587fa9e4066Sahrens 			case OP_SHARE:
2588fa9e4066Sahrens 				if (zfs_unshare(node->un_zhp,
2589fa9e4066Sahrens 				    node->un_mountp) != 0)
2590fa9e4066Sahrens 					ret = 1;
2591fa9e4066Sahrens 				break;
2592fa9e4066Sahrens 
2593fa9e4066Sahrens 			case OP_MOUNT:
2594fa9e4066Sahrens 				if (zfs_unmount(node->un_zhp,
2595fa9e4066Sahrens 				    node->un_mountp, flags) != 0)
2596fa9e4066Sahrens 					ret = 1;
2597fa9e4066Sahrens 				break;
2598fa9e4066Sahrens 			}
2599fa9e4066Sahrens 
2600fa9e4066Sahrens 			zfs_close(node->un_zhp);
2601fa9e4066Sahrens 			free(node->un_mountp);
2602fa9e4066Sahrens 			free(node);
2603fa9e4066Sahrens 		}
2604fa9e4066Sahrens 
2605fa9e4066Sahrens 		uu_avl_walk_end(walk);
2606fa9e4066Sahrens 		uu_avl_destroy(tree);
2607fa9e4066Sahrens 		uu_avl_pool_destroy(pool);
2608fa9e4066Sahrens 	} else {
2609fa9e4066Sahrens 		/*
2610fa9e4066Sahrens 		 * We have an argument, but it may be a full path or a ZFS
2611fa9e4066Sahrens 		 * filesystem.  Pass full paths off to unmount_path() (shared by
2612fa9e4066Sahrens 		 * manual_unmount), otherwise open the filesystem and pass to
2613fa9e4066Sahrens 		 * zfs_unmount().
2614fa9e4066Sahrens 		 */
2615fa9e4066Sahrens 		if (argv[0][0] == '/')
2616fa9e4066Sahrens 			return (unshare_unmount_path(type, argv[0],
261799653d4eSeschrock 				flags, B_FALSE));
2618fa9e4066Sahrens 
261999653d4eSeschrock 		if ((zhp = zfs_open(g_zfs, argv[0],
262099653d4eSeschrock 		    ZFS_TYPE_FILESYSTEM)) == NULL)
2621fa9e4066Sahrens 			return (1);
2622fa9e4066Sahrens 
2623fa9e4066Sahrens 		verify(zfs_prop_get(zhp, type == OP_SHARE ?
2624fa9e4066Sahrens 		    ZFS_PROP_SHARENFS : ZFS_PROP_MOUNTPOINT, property,
262599653d4eSeschrock 		    sizeof (property), NULL, NULL, 0, B_FALSE) == 0);
2626fa9e4066Sahrens 
2627fa9e4066Sahrens 		switch (type) {
2628fa9e4066Sahrens 		case OP_SHARE:
2629fa9e4066Sahrens 			if (strcmp(property, "off") == 0) {
2630fa9e4066Sahrens 				(void) fprintf(stderr, gettext("cannot unshare "
2631fa9e4066Sahrens 				    "'%s': legacy share\n"), zfs_get_name(zhp));
2632fa9e4066Sahrens 				(void) fprintf(stderr, gettext("use unshare(1M)"
2633fa9e4066Sahrens 				    " to unshare this filesystem\n"));
2634fa9e4066Sahrens 				ret = 1;
2635fa9e4066Sahrens 			} else if (!zfs_is_shared(zhp, NULL)) {
2636fa9e4066Sahrens 				(void) fprintf(stderr, gettext("cannot unshare "
2637fa9e4066Sahrens 				    "'%s': not currently shared\n"),
2638fa9e4066Sahrens 				    zfs_get_name(zhp));
2639fa9e4066Sahrens 				ret = 1;
2640fa9e4066Sahrens 			} else if (zfs_unshareall(zhp) != 0) {
2641fa9e4066Sahrens 				ret = 1;
2642fa9e4066Sahrens 			}
2643fa9e4066Sahrens 			break;
2644fa9e4066Sahrens 
2645fa9e4066Sahrens 		case OP_MOUNT:
2646fa9e4066Sahrens 			if (strcmp(property, "legacy") == 0) {
2647fa9e4066Sahrens 				(void) fprintf(stderr, gettext("cannot unmount "
2648fa9e4066Sahrens 				    "'%s': legacy mountpoint\n"),
2649fa9e4066Sahrens 				    zfs_get_name(zhp));
2650fa9e4066Sahrens 				(void) fprintf(stderr, gettext("use umount(1M) "
2651fa9e4066Sahrens 				    "to unmount this filesystem\n"));
2652fa9e4066Sahrens 				ret = 1;
2653fa9e4066Sahrens 			} else if (!zfs_is_mounted(zhp, NULL)) {
2654fa9e4066Sahrens 				(void) fprintf(stderr, gettext("cannot unmount "
2655fa9e4066Sahrens 				    "'%s': not currently mounted\n"),
2656fa9e4066Sahrens 				    zfs_get_name(zhp));
2657fa9e4066Sahrens 				ret = 1;
2658fa9e4066Sahrens 			} else if (zfs_unmountall(zhp, flags) != 0) {
2659fa9e4066Sahrens 				ret = 1;
2660fa9e4066Sahrens 			}
2661fa9e4066Sahrens 		}
2662fa9e4066Sahrens 
2663fa9e4066Sahrens 		zfs_close(zhp);
2664fa9e4066Sahrens 	}
2665fa9e4066Sahrens 
2666fa9e4066Sahrens 	return (ret);
2667fa9e4066Sahrens }
2668fa9e4066Sahrens 
2669fa9e4066Sahrens /*
2670fa9e4066Sahrens  * zfs unmount -a
2671fa9e4066Sahrens  * zfs unmount filesystem
2672fa9e4066Sahrens  *
2673fa9e4066Sahrens  * Unmount all filesystems, or a specific ZFS filesystem.
2674fa9e4066Sahrens  */
2675fa9e4066Sahrens static int
2676fa9e4066Sahrens zfs_do_unmount(int argc, char **argv)
2677fa9e4066Sahrens {
2678fa9e4066Sahrens 	return (unshare_unmount(OP_MOUNT, argc, argv));
2679fa9e4066Sahrens }
2680fa9e4066Sahrens 
2681fa9e4066Sahrens /*
2682fa9e4066Sahrens  * zfs unshare -a
2683fa9e4066Sahrens  * zfs unshare filesystem
2684fa9e4066Sahrens  *
2685fa9e4066Sahrens  * Unshare all filesystems, or a specific ZFS filesystem.
2686fa9e4066Sahrens  */
2687fa9e4066Sahrens static int
2688fa9e4066Sahrens zfs_do_unshare(int argc, char **argv)
2689fa9e4066Sahrens {
2690fa9e4066Sahrens 	return (unshare_unmount(OP_SHARE, argc, argv));
2691fa9e4066Sahrens }
2692fa9e4066Sahrens 
2693fa9e4066Sahrens /*
2694fa9e4066Sahrens  * Called when invoked as /etc/fs/zfs/mount.  Do the mount if the mountpoint is
2695fa9e4066Sahrens  * 'legacy'.  Otherwise, complain that use should be using 'zfs mount'.
2696fa9e4066Sahrens  */
2697fa9e4066Sahrens static int
2698fa9e4066Sahrens manual_mount(int argc, char **argv)
2699fa9e4066Sahrens {
2700fa9e4066Sahrens 	zfs_handle_t *zhp;
2701fa9e4066Sahrens 	char mountpoint[ZFS_MAXPROPLEN];
2702fa9e4066Sahrens 	char mntopts[MNT_LINE_MAX] = { '\0' };
2703fa9e4066Sahrens 	int ret;
2704fa9e4066Sahrens 	int c;
2705fa9e4066Sahrens 	int flags = 0;
2706fa9e4066Sahrens 	char *dataset, *path;
2707fa9e4066Sahrens 
2708fa9e4066Sahrens 	/* check options */
2709ea8dc4b6Seschrock 	while ((c = getopt(argc, argv, ":mo:O")) != -1) {
2710fa9e4066Sahrens 		switch (c) {
2711fa9e4066Sahrens 		case 'o':
2712fa9e4066Sahrens 			(void) strlcpy(mntopts, optarg, sizeof (mntopts));
2713fa9e4066Sahrens 			break;
2714fa9e4066Sahrens 		case 'O':
2715fa9e4066Sahrens 			flags |= MS_OVERLAY;
2716fa9e4066Sahrens 			break;
2717ea8dc4b6Seschrock 		case 'm':
2718ea8dc4b6Seschrock 			flags |= MS_NOMNTTAB;
2719ea8dc4b6Seschrock 			break;
2720fa9e4066Sahrens 		case ':':
2721fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing argument for "
2722fa9e4066Sahrens 			    "'%c' option\n"), optopt);
272399653d4eSeschrock 			usage(B_FALSE);
2724fa9e4066Sahrens 			break;
2725fa9e4066Sahrens 		case '?':
2726fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
2727fa9e4066Sahrens 			    optopt);
2728fa9e4066Sahrens 			(void) fprintf(stderr, gettext("usage: mount [-o opts] "
2729fa9e4066Sahrens 			    "<path>\n"));
2730fa9e4066Sahrens 			return (2);
2731fa9e4066Sahrens 		}
2732fa9e4066Sahrens 	}
2733fa9e4066Sahrens 
2734fa9e4066Sahrens 	argc -= optind;
2735fa9e4066Sahrens 	argv += optind;
2736fa9e4066Sahrens 
2737fa9e4066Sahrens 	/* check that we only have two arguments */
2738fa9e4066Sahrens 	if (argc != 2) {
2739fa9e4066Sahrens 		if (argc == 0)
2740fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing dataset "
2741fa9e4066Sahrens 			    "argument\n"));
2742fa9e4066Sahrens 		else if (argc == 1)
2743fa9e4066Sahrens 			(void) fprintf(stderr,
2744fa9e4066Sahrens 			    gettext("missing mountpoint argument\n"));
2745fa9e4066Sahrens 		else
2746fa9e4066Sahrens 			(void) fprintf(stderr, gettext("too many arguments\n"));
2747fa9e4066Sahrens 		(void) fprintf(stderr, "usage: mount <dataset> <mountpoint>\n");
2748fa9e4066Sahrens 		return (2);
2749fa9e4066Sahrens 	}
2750fa9e4066Sahrens 
2751fa9e4066Sahrens 	dataset = argv[0];
2752fa9e4066Sahrens 	path = argv[1];
2753fa9e4066Sahrens 
2754fa9e4066Sahrens 	/* try to open the dataset */
275599653d4eSeschrock 	if ((zhp = zfs_open(g_zfs, dataset, ZFS_TYPE_FILESYSTEM)) == NULL)
2756fa9e4066Sahrens 		return (1);
2757fa9e4066Sahrens 
2758fa9e4066Sahrens 	(void) zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint,
275999653d4eSeschrock 	    sizeof (mountpoint), NULL, NULL, 0, B_FALSE);
2760fa9e4066Sahrens 
2761fa9e4066Sahrens 	/* check for legacy mountpoint and complain appropriately */
2762fa9e4066Sahrens 	ret = 0;
2763fa9e4066Sahrens 	if (strcmp(mountpoint, ZFS_MOUNTPOINT_LEGACY) == 0) {
2764fa9e4066Sahrens 		if (mount(dataset, path, MS_OPTIONSTR | flags, MNTTYPE_ZFS,
2765fa9e4066Sahrens 		    NULL, 0, mntopts, sizeof (mntopts)) != 0) {
2766fa9e4066Sahrens 			(void) fprintf(stderr, gettext("mount failed: %s\n"),
2767fa9e4066Sahrens 			    strerror(errno));
2768fa9e4066Sahrens 			ret = 1;
2769fa9e4066Sahrens 		}
2770fa9e4066Sahrens 	} else {
2771fa9e4066Sahrens 		(void) fprintf(stderr, gettext("filesystem '%s' cannot be "
2772fa9e4066Sahrens 		    "mounted using 'mount -F zfs'\n"), dataset);
2773fa9e4066Sahrens 		(void) fprintf(stderr, gettext("Use 'zfs set mountpoint=%s' "
2774fa9e4066Sahrens 		    "instead.\n"), path);
2775fa9e4066Sahrens 		(void) fprintf(stderr, gettext("If you must use 'mount -F zfs' "
2776fa9e4066Sahrens 		    "or /etc/vfstab, use 'zfs set mountpoint=legacy'.\n"));
2777fa9e4066Sahrens 		(void) fprintf(stderr, gettext("See zfs(1M) for more "
2778fa9e4066Sahrens 		    "information.\n"));
2779fa9e4066Sahrens 		ret = 1;
2780fa9e4066Sahrens 	}
2781fa9e4066Sahrens 
2782fa9e4066Sahrens 	return (ret);
2783fa9e4066Sahrens }
2784fa9e4066Sahrens 
2785fa9e4066Sahrens /*
2786fa9e4066Sahrens  * Called when invoked as /etc/fs/zfs/umount.  Unlike a manual mount, we allow
2787fa9e4066Sahrens  * unmounts of non-legacy filesystems, as this is the dominant administrative
2788fa9e4066Sahrens  * interface.
2789fa9e4066Sahrens  */
2790fa9e4066Sahrens static int
2791fa9e4066Sahrens manual_unmount(int argc, char **argv)
2792fa9e4066Sahrens {
2793fa9e4066Sahrens 	int flags = 0;
2794fa9e4066Sahrens 	int c;
2795fa9e4066Sahrens 
2796fa9e4066Sahrens 	/* check options */
2797fa9e4066Sahrens 	while ((c = getopt(argc, argv, "f")) != -1) {
2798fa9e4066Sahrens 		switch (c) {
2799fa9e4066Sahrens 		case 'f':
2800fa9e4066Sahrens 			flags = MS_FORCE;
2801fa9e4066Sahrens 			break;
2802fa9e4066Sahrens 		case '?':
2803fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
2804fa9e4066Sahrens 			    optopt);
2805fa9e4066Sahrens 			(void) fprintf(stderr, gettext("usage: unmount [-f] "
2806fa9e4066Sahrens 			    "<path>\n"));
2807fa9e4066Sahrens 			return (2);
2808fa9e4066Sahrens 		}
2809fa9e4066Sahrens 	}
2810fa9e4066Sahrens 
2811fa9e4066Sahrens 	argc -= optind;
2812fa9e4066Sahrens 	argv += optind;
2813fa9e4066Sahrens 
2814fa9e4066Sahrens 	/* check arguments */
2815fa9e4066Sahrens 	if (argc != 1) {
2816fa9e4066Sahrens 		if (argc == 0)
2817fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing path "
2818fa9e4066Sahrens 			    "argument\n"));
2819fa9e4066Sahrens 		else
2820fa9e4066Sahrens 			(void) fprintf(stderr, gettext("too many arguments\n"));
2821fa9e4066Sahrens 		(void) fprintf(stderr, gettext("usage: unmount [-f] <path>\n"));
2822fa9e4066Sahrens 		return (2);
2823fa9e4066Sahrens 	}
2824fa9e4066Sahrens 
282599653d4eSeschrock 	return (unshare_unmount_path(OP_MOUNT, argv[0], flags, B_TRUE));
2826fa9e4066Sahrens }
2827fa9e4066Sahrens 
2828fa9e4066Sahrens static int
2829fa9e4066Sahrens volcheck(zpool_handle_t *zhp, void *data)
2830fa9e4066Sahrens {
2831fa9e4066Sahrens 	int isinit = (int)data;
2832fa9e4066Sahrens 
2833fa9e4066Sahrens 	if (isinit)
2834fa9e4066Sahrens 		return (zpool_create_zvol_links(zhp));
2835fa9e4066Sahrens 	else
2836fa9e4066Sahrens 		return (zpool_remove_zvol_links(zhp));
2837fa9e4066Sahrens }
2838fa9e4066Sahrens 
2839fa9e4066Sahrens /*
2840fa9e4066Sahrens  * Iterate over all pools in the system and either create or destroy /dev/zvol
2841fa9e4066Sahrens  * links, depending on the value of 'isinit'.
2842fa9e4066Sahrens  */
2843fa9e4066Sahrens static int
284499653d4eSeschrock do_volcheck(boolean_t isinit)
2845fa9e4066Sahrens {
284699653d4eSeschrock 	return (zpool_iter(g_zfs, volcheck, (void *)isinit) ? 1 : 0);
2847fa9e4066Sahrens }
2848fa9e4066Sahrens 
2849fa9e4066Sahrens int
2850fa9e4066Sahrens main(int argc, char **argv)
2851fa9e4066Sahrens {
2852fa9e4066Sahrens 	int ret;
2853fa9e4066Sahrens 	int i;
2854fa9e4066Sahrens 	char *progname;
2855fa9e4066Sahrens 	char *cmdname;
2856fa9e4066Sahrens 
2857fa9e4066Sahrens 	(void) setlocale(LC_ALL, "");
2858fa9e4066Sahrens 	(void) textdomain(TEXT_DOMAIN);
2859fa9e4066Sahrens 
2860fa9e4066Sahrens 	opterr = 0;
2861fa9e4066Sahrens 
286299653d4eSeschrock 	if ((g_zfs = libzfs_init()) == NULL) {
286399653d4eSeschrock 		(void) fprintf(stderr, gettext("internal error: failed to "
286499653d4eSeschrock 		    "initialize ZFS library\n"));
286599653d4eSeschrock 		return (1);
286699653d4eSeschrock 	}
286799653d4eSeschrock 
286899653d4eSeschrock 	libzfs_print_on_error(g_zfs, B_TRUE);
286999653d4eSeschrock 
2870fa9e4066Sahrens 	if ((mnttab_file = fopen(MNTTAB, "r")) == NULL) {
2871fa9e4066Sahrens 		(void) fprintf(stderr, gettext("internal error: unable to "
2872fa9e4066Sahrens 		    "open %s\n"), MNTTAB);
2873fa9e4066Sahrens 		return (1);
2874fa9e4066Sahrens 	}
2875fa9e4066Sahrens 
2876fa9e4066Sahrens 	/*
2877fa9e4066Sahrens 	 * This command also doubles as the /etc/fs mount and unmount program.
2878fa9e4066Sahrens 	 * Determine if we should take this behavior based on argv[0].
2879fa9e4066Sahrens 	 */
2880fa9e4066Sahrens 	progname = basename(argv[0]);
2881fa9e4066Sahrens 	if (strcmp(progname, "mount") == 0) {
2882fa9e4066Sahrens 		ret = manual_mount(argc, argv);
2883fa9e4066Sahrens 	} else if (strcmp(progname, "umount") == 0) {
2884fa9e4066Sahrens 		ret = manual_unmount(argc, argv);
2885fa9e4066Sahrens 	} else {
2886fa9e4066Sahrens 		/*
2887fa9e4066Sahrens 		 * Make sure the user has specified some command.
2888fa9e4066Sahrens 		 */
2889fa9e4066Sahrens 		if (argc < 2) {
2890fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing command\n"));
289199653d4eSeschrock 			usage(B_FALSE);
2892fa9e4066Sahrens 		}
2893fa9e4066Sahrens 
2894fa9e4066Sahrens 		cmdname = argv[1];
2895fa9e4066Sahrens 
2896fa9e4066Sahrens 		/*
2897fa9e4066Sahrens 		 * The 'umount' command is an alias for 'unmount'
2898fa9e4066Sahrens 		 */
2899fa9e4066Sahrens 		if (strcmp(cmdname, "umount") == 0)
2900fa9e4066Sahrens 			cmdname = "unmount";
2901fa9e4066Sahrens 
2902fa9e4066Sahrens 		/*
2903f2a3c691Sahrens 		 * The 'recv' command is an alias for 'receive'
2904f2a3c691Sahrens 		 */
2905f2a3c691Sahrens 		if (strcmp(cmdname, "recv") == 0)
2906f2a3c691Sahrens 			cmdname = "receive";
2907f2a3c691Sahrens 
2908f2a3c691Sahrens 		/*
2909fa9e4066Sahrens 		 * Special case '-?'
2910fa9e4066Sahrens 		 */
2911fa9e4066Sahrens 		if (strcmp(cmdname, "-?") == 0)
291299653d4eSeschrock 			usage(B_TRUE);
2913fa9e4066Sahrens 
2914fa9e4066Sahrens 		/*
2915fa9e4066Sahrens 		 * 'volinit' and 'volfini' do not appear in the usage message,
2916fa9e4066Sahrens 		 * so we have to special case them here.
2917fa9e4066Sahrens 		 */
2918fa9e4066Sahrens 		if (strcmp(cmdname, "volinit") == 0)
291999653d4eSeschrock 			return (do_volcheck(B_TRUE));
2920fa9e4066Sahrens 		else if (strcmp(cmdname, "volfini") == 0)
292199653d4eSeschrock 			return (do_volcheck(B_FALSE));
2922fa9e4066Sahrens 
2923fa9e4066Sahrens 		/*
2924fa9e4066Sahrens 		 * Run the appropriate command.
2925fa9e4066Sahrens 		 */
2926fa9e4066Sahrens 		for (i = 0; i < NCOMMAND; i++) {
2927fa9e4066Sahrens 			if (command_table[i].name == NULL)
2928fa9e4066Sahrens 				continue;
2929fa9e4066Sahrens 
2930fa9e4066Sahrens 			if (strcmp(cmdname, command_table[i].name) == 0) {
2931fa9e4066Sahrens 				current_command = &command_table[i];
2932fa9e4066Sahrens 				ret = command_table[i].func(argc - 1, argv + 1);
2933fa9e4066Sahrens 				break;
2934fa9e4066Sahrens 			}
2935fa9e4066Sahrens 		}
2936fa9e4066Sahrens 
2937fa9e4066Sahrens 		if (i == NCOMMAND) {
2938fa9e4066Sahrens 			(void) fprintf(stderr, gettext("unrecognized "
2939fa9e4066Sahrens 			    "command '%s'\n"), cmdname);
294099653d4eSeschrock 			usage(B_FALSE);
2941fa9e4066Sahrens 		}
2942fa9e4066Sahrens 	}
2943fa9e4066Sahrens 
2944fa9e4066Sahrens 	(void) fclose(mnttab_file);
2945fa9e4066Sahrens 
294699653d4eSeschrock 	libzfs_fini(g_zfs);
294799653d4eSeschrock 
2948fa9e4066Sahrens 	/*
2949fa9e4066Sahrens 	 * The 'ZFS_ABORT' environment variable causes us to dump core on exit
2950fa9e4066Sahrens 	 * for the purposes of running ::findleaks.
2951fa9e4066Sahrens 	 */
2952fa9e4066Sahrens 	if (getenv("ZFS_ABORT") != NULL) {
2953fa9e4066Sahrens 		(void) printf("dumping core by request\n");
2954fa9e4066Sahrens 		abort();
2955fa9e4066Sahrens 	}
2956fa9e4066Sahrens 
2957fa9e4066Sahrens 	return (ret);
2958fa9e4066Sahrens }
2959