xref: /titanic_50/usr/src/cmd/zfs/zfs_main.c (revision 65cd9f2809a015b46790a9c5c2ef992d56177624)
1fa9e4066Sahrens /*
2fa9e4066Sahrens  * CDDL HEADER START
3fa9e4066Sahrens  *
4fa9e4066Sahrens  * The contents of this file are subject to the terms of the
5fa9e4066Sahrens  * Common Development and Distribution License, Version 1.0 only
6fa9e4066Sahrens  * (the "License").  You may not use this file except in compliance
7fa9e4066Sahrens  * with the License.
8fa9e4066Sahrens  *
9fa9e4066Sahrens  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10fa9e4066Sahrens  * or http://www.opensolaris.org/os/licensing.
11fa9e4066Sahrens  * See the License for the specific language governing permissions
12fa9e4066Sahrens  * and limitations under the License.
13fa9e4066Sahrens  *
14fa9e4066Sahrens  * When distributing Covered Code, include this CDDL HEADER in each
15fa9e4066Sahrens  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16fa9e4066Sahrens  * If applicable, add the following below this CDDL HEADER, with the
17fa9e4066Sahrens  * fields enclosed by brackets "[]" replaced with your own identifying
18fa9e4066Sahrens  * information: Portions Copyright [yyyy] [name of copyright owner]
19fa9e4066Sahrens  *
20fa9e4066Sahrens  * CDDL HEADER END
21fa9e4066Sahrens  */
22fa9e4066Sahrens /*
236b90ca48Slling  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
24fa9e4066Sahrens  * Use is subject to license terms.
25fa9e4066Sahrens  */
26fa9e4066Sahrens 
27fa9e4066Sahrens #pragma ident	"%Z%%M%	%I%	%E% SMI"
28fa9e4066Sahrens 
29fa9e4066Sahrens #include <assert.h>
30fa9e4066Sahrens #include <errno.h>
31fa9e4066Sahrens #include <libgen.h>
32fa9e4066Sahrens #include <libintl.h>
33fa9e4066Sahrens #include <libuutil.h>
34fa9e4066Sahrens #include <locale.h>
35fa9e4066Sahrens #include <stddef.h>
36fa9e4066Sahrens #include <stdio.h>
37fa9e4066Sahrens #include <stdlib.h>
38fa9e4066Sahrens #include <strings.h>
39fa9e4066Sahrens #include <unistd.h>
40fa9e4066Sahrens #include <fcntl.h>
41fa9e4066Sahrens #include <zone.h>
42fa9e4066Sahrens #include <sys/mkdev.h>
43fa9e4066Sahrens #include <sys/mntent.h>
44fa9e4066Sahrens #include <sys/mnttab.h>
45fa9e4066Sahrens #include <sys/mount.h>
46fa9e4066Sahrens #include <sys/stat.h>
47fa9e4066Sahrens 
48fa9e4066Sahrens #include <libzfs.h>
49fa9e4066Sahrens 
50fa9e4066Sahrens #include "zfs_iter.h"
51fa9e4066Sahrens 
52fa9e4066Sahrens static FILE *mnttab_file;
53fa9e4066Sahrens 
54fa9e4066Sahrens static int zfs_do_clone(int argc, char **argv);
55fa9e4066Sahrens static int zfs_do_create(int argc, char **argv);
56fa9e4066Sahrens static int zfs_do_destroy(int argc, char **argv);
57fa9e4066Sahrens static int zfs_do_get(int argc, char **argv);
58fa9e4066Sahrens static int zfs_do_inherit(int argc, char **argv);
59fa9e4066Sahrens static int zfs_do_list(int argc, char **argv);
60fa9e4066Sahrens static int zfs_do_mount(int argc, char **argv);
61fa9e4066Sahrens static int zfs_do_rename(int argc, char **argv);
62fa9e4066Sahrens static int zfs_do_rollback(int argc, char **argv);
63fa9e4066Sahrens static int zfs_do_set(int argc, char **argv);
64fa9e4066Sahrens static int zfs_do_snapshot(int argc, char **argv);
65fa9e4066Sahrens static int zfs_do_unmount(int argc, char **argv);
66fa9e4066Sahrens static int zfs_do_share(int argc, char **argv);
67fa9e4066Sahrens static int zfs_do_unshare(int argc, char **argv);
68fa9e4066Sahrens static int zfs_do_backup(int argc, char **argv);
69fa9e4066Sahrens static int zfs_do_restore(int argc, char **argv);
70fa9e4066Sahrens 
71fa9e4066Sahrens /*
72fa9e4066Sahrens  * These libumem hooks provide a reasonable set of defaults for the allocator's
73fa9e4066Sahrens  * debugging facilities.
74fa9e4066Sahrens  */
75fa9e4066Sahrens const char *
76fa9e4066Sahrens _umem_debug_init()
77fa9e4066Sahrens {
78fa9e4066Sahrens 	return ("default,verbose"); /* $UMEM_DEBUG setting */
79fa9e4066Sahrens }
80fa9e4066Sahrens 
81fa9e4066Sahrens const char *
82fa9e4066Sahrens _umem_logging_init(void)
83fa9e4066Sahrens {
84fa9e4066Sahrens 	return ("fail,contents"); /* $UMEM_LOGGING setting */
85fa9e4066Sahrens }
86fa9e4066Sahrens 
87*65cd9f28Seschrock typedef enum {
88*65cd9f28Seschrock 	HELP_BACKUP,
89*65cd9f28Seschrock 	HELP_CLONE,
90*65cd9f28Seschrock 	HELP_CREATE,
91*65cd9f28Seschrock 	HELP_DESTROY,
92*65cd9f28Seschrock 	HELP_GET,
93*65cd9f28Seschrock 	HELP_INHERIT,
94*65cd9f28Seschrock 	HELP_LIST,
95*65cd9f28Seschrock 	HELP_MOUNT,
96*65cd9f28Seschrock 	HELP_RENAME,
97*65cd9f28Seschrock 	HELP_RESTORE,
98*65cd9f28Seschrock 	HELP_ROLLBACK,
99*65cd9f28Seschrock 	HELP_SET,
100*65cd9f28Seschrock 	HELP_SHARE,
101*65cd9f28Seschrock 	HELP_SNAPSHOT,
102*65cd9f28Seschrock 	HELP_UNMOUNT,
103*65cd9f28Seschrock 	HELP_UNSHARE
104*65cd9f28Seschrock } zfs_help_t;
105*65cd9f28Seschrock 
106fa9e4066Sahrens typedef struct zfs_command {
107fa9e4066Sahrens 	const char	*name;
108fa9e4066Sahrens 	int		(*func)(int argc, char **argv);
109*65cd9f28Seschrock 	zfs_help_t	usage;
110fa9e4066Sahrens } zfs_command_t;
111fa9e4066Sahrens 
112fa9e4066Sahrens /*
113fa9e4066Sahrens  * Master command table.  Each ZFS command has a name, associated function, and
114*65cd9f28Seschrock  * usage message.  Unfortunately, the usage messages need to be
115*65cd9f28Seschrock  * iternationalized, so we have to have a function to return the usage message
116*65cd9f28Seschrock  * based on a command index.
117*65cd9f28Seschrock  *
118*65cd9f28Seschrock  * These commands are organized according to how they are displayed in the usage
119*65cd9f28Seschrock  * message.  An empty command (one with a NULL name) indicates an empty line in
120*65cd9f28Seschrock  * the generic usage message.
121fa9e4066Sahrens  */
122fa9e4066Sahrens static zfs_command_t command_table[] = {
123*65cd9f28Seschrock 	{ "create",	zfs_do_create,		HELP_CREATE		},
124*65cd9f28Seschrock 	{ "destroy",	zfs_do_destroy,		HELP_DESTROY		},
125fa9e4066Sahrens 	{ NULL },
126*65cd9f28Seschrock 	{ "snapshot",	zfs_do_snapshot,	HELP_SNAPSHOT		},
127*65cd9f28Seschrock 	{ "rollback",	zfs_do_rollback,	HELP_ROLLBACK		},
128*65cd9f28Seschrock 	{ "clone",	zfs_do_clone,		HELP_CLONE		},
129*65cd9f28Seschrock 	{ "rename",	zfs_do_rename,		HELP_RENAME		},
130fa9e4066Sahrens 	{ NULL },
131*65cd9f28Seschrock 	{ "list",	zfs_do_list,		HELP_LIST		},
132fa9e4066Sahrens 	{ NULL },
133*65cd9f28Seschrock 	{ "set",	zfs_do_set,		HELP_SET		},
134*65cd9f28Seschrock 	{ "get", 	zfs_do_get,		HELP_GET		},
135*65cd9f28Seschrock 	{ "inherit",	zfs_do_inherit,		HELP_INHERIT		},
136fa9e4066Sahrens 	{ NULL },
137*65cd9f28Seschrock 	{ "mount",	zfs_do_mount,		HELP_MOUNT		},
138fa9e4066Sahrens 	{ NULL },
139*65cd9f28Seschrock 	{ "unmount",	zfs_do_unmount,		HELP_UNMOUNT		},
140fa9e4066Sahrens 	{ NULL },
141*65cd9f28Seschrock 	{ "share",	zfs_do_share,		HELP_SHARE		},
142fa9e4066Sahrens 	{ NULL },
143*65cd9f28Seschrock 	{ "unshare",	zfs_do_unshare,		HELP_UNSHARE		},
144fa9e4066Sahrens 	{ NULL },
145*65cd9f28Seschrock 	{ "backup",	zfs_do_backup,		HELP_BACKUP		},
146*65cd9f28Seschrock 	{ "restore",	zfs_do_restore,		HELP_RESTORE		},
147fa9e4066Sahrens };
148fa9e4066Sahrens 
149fa9e4066Sahrens #define	NCOMMAND	(sizeof (command_table) / sizeof (command_table[0]))
150fa9e4066Sahrens 
151fa9e4066Sahrens zfs_command_t *current_command;
152fa9e4066Sahrens 
153*65cd9f28Seschrock static const char *
154*65cd9f28Seschrock get_usage(zfs_help_t idx)
155*65cd9f28Seschrock {
156*65cd9f28Seschrock 	switch (idx) {
157*65cd9f28Seschrock 	case HELP_BACKUP:
158*65cd9f28Seschrock 		return (gettext("\tbackup [-i <snapshot>] <snapshot>\n"));
159*65cd9f28Seschrock 	case HELP_CLONE:
160*65cd9f28Seschrock 		return (gettext("\tclone <snapshot> <filesystem|volume>\n"));
161*65cd9f28Seschrock 	case HELP_CREATE:
162*65cd9f28Seschrock 		return (gettext("\tcreate <filesystem>\n"
163*65cd9f28Seschrock 		    "\tcreate [-s] [-b blocksize] -V <size> <volume>\n"));
164*65cd9f28Seschrock 	case HELP_DESTROY:
165*65cd9f28Seschrock 		return (gettext("\tdestroy [-rRf] "
166*65cd9f28Seschrock 		    "<filesystem|volume|snapshot>\n"));
167*65cd9f28Seschrock 	case HELP_GET:
168*65cd9f28Seschrock 		return (gettext("\tget [-rHp] [-o field[,field]...] "
169*65cd9f28Seschrock 		    "[-s source[,source]...]\n"
170*65cd9f28Seschrock 		    "\t    <all | property[,property]...> "
171*65cd9f28Seschrock 		    "<filesystem|volume|snapshot> ...\n"));
172*65cd9f28Seschrock 	case HELP_INHERIT:
173*65cd9f28Seschrock 		return (gettext("\tinherit [-r] <property> "
174*65cd9f28Seschrock 		    "<filesystem|volume> ...\n"));
175*65cd9f28Seschrock 	case HELP_LIST:
176*65cd9f28Seschrock 		return (gettext("\tlist [-rH] [-o property[,property]...] "
177*65cd9f28Seschrock 		    "[-t type[,type]...]\n"
178*65cd9f28Seschrock 		    "\t    [filesystem|volume|snapshot] ...\n"));
179*65cd9f28Seschrock 	case HELP_MOUNT:
180*65cd9f28Seschrock 		return (gettext("\tmount\n"
181*65cd9f28Seschrock 		    "\tmount [-o opts] [-O] -a\n"
182*65cd9f28Seschrock 		    "\tmount [-o opts] [-O] <filesystem>\n"));
183*65cd9f28Seschrock 	case HELP_RENAME:
184*65cd9f28Seschrock 		return (gettext("\trename <filesystem|volume|snapshot> "
185*65cd9f28Seschrock 		    "<filesystem|volume|snapshot>\n"));
186*65cd9f28Seschrock 	case HELP_RESTORE:
187*65cd9f28Seschrock 		return (gettext("\trestore [-vn] <filesystem|volume|snapshot>\n"
188*65cd9f28Seschrock 		    "\trestore [-vn] -d <filesystem>\n"));
189*65cd9f28Seschrock 	case HELP_ROLLBACK:
190*65cd9f28Seschrock 		return (gettext("\trollback [-rRf] <snapshot>\n"));
191*65cd9f28Seschrock 	case HELP_SET:
192*65cd9f28Seschrock 		return (gettext("\tset <property=value> "
193*65cd9f28Seschrock 		    "<filesystem|volume> ...\n"));
194*65cd9f28Seschrock 	case HELP_SHARE:
195*65cd9f28Seschrock 		return (gettext("\tshare -a\n"
196*65cd9f28Seschrock 		    "\tshare <filesystem>\n"));
197*65cd9f28Seschrock 	case HELP_SNAPSHOT:
198*65cd9f28Seschrock 		return (gettext("\tsnapshot <filesystem@name|volume@name>\n"));
199*65cd9f28Seschrock 	case HELP_UNMOUNT:
200*65cd9f28Seschrock 		return (gettext("\tunmount [-f] -a\n"
201*65cd9f28Seschrock 		    "\tunmount [-f] <filesystem|mountpoint>\n"));
202*65cd9f28Seschrock 	case HELP_UNSHARE:
203*65cd9f28Seschrock 		return (gettext("\tunshare [-f] -a\n"
204*65cd9f28Seschrock 		    "\tunshare [-f] <filesystem|mountpoint>\n"));
205*65cd9f28Seschrock 	}
206*65cd9f28Seschrock 
207*65cd9f28Seschrock 	abort();
208*65cd9f28Seschrock 	/* NOTREACHED */
209*65cd9f28Seschrock }
210*65cd9f28Seschrock 
211fa9e4066Sahrens /*
212fa9e4066Sahrens  * Utility function to guarantee malloc() success.
213fa9e4066Sahrens  */
214fa9e4066Sahrens void *
215fa9e4066Sahrens safe_malloc(size_t size)
216fa9e4066Sahrens {
217fa9e4066Sahrens 	void *data;
218fa9e4066Sahrens 
219fa9e4066Sahrens 	if ((data = calloc(1, size)) == NULL) {
220fa9e4066Sahrens 		(void) fprintf(stderr, "internal error: out of memory\n");
221fa9e4066Sahrens 		exit(1);
222fa9e4066Sahrens 	}
223fa9e4066Sahrens 
224fa9e4066Sahrens 	return (data);
225fa9e4066Sahrens }
226fa9e4066Sahrens 
227fa9e4066Sahrens /*
228fa9e4066Sahrens  * Display usage message.  If we're inside a command, display only the usage for
229fa9e4066Sahrens  * that command.  Otherwise, iterate over the entire command table and display
230fa9e4066Sahrens  * a complete usage message.
231fa9e4066Sahrens  */
232fa9e4066Sahrens static void
233fa9e4066Sahrens usage(int requested)
234fa9e4066Sahrens {
235fa9e4066Sahrens 	int i;
236fa9e4066Sahrens 	int show_properties = FALSE;
237fa9e4066Sahrens 	FILE *fp = requested ? stdout : stderr;
238fa9e4066Sahrens 
239fa9e4066Sahrens 	if (current_command == NULL) {
240fa9e4066Sahrens 
241fa9e4066Sahrens 		(void) fprintf(fp, gettext("usage: zfs command args ...\n"));
242fa9e4066Sahrens 		(void) fprintf(fp,
243fa9e4066Sahrens 		    gettext("where 'command' is one of the following:\n\n"));
244fa9e4066Sahrens 
245fa9e4066Sahrens 		for (i = 0; i < NCOMMAND; i++) {
246fa9e4066Sahrens 			if (command_table[i].name == NULL)
247fa9e4066Sahrens 				(void) fprintf(fp, "\n");
248fa9e4066Sahrens 			else
249fa9e4066Sahrens 				(void) fprintf(fp, "%s",
250*65cd9f28Seschrock 				    get_usage(command_table[i].usage));
251fa9e4066Sahrens 		}
252fa9e4066Sahrens 
253fa9e4066Sahrens 		(void) fprintf(fp, gettext("\nEach dataset is of the form: "
254fa9e4066Sahrens 		    "pool/[dataset/]*dataset[@name]\n"));
255fa9e4066Sahrens 	} else {
256fa9e4066Sahrens 		(void) fprintf(fp, gettext("usage:\n"));
257*65cd9f28Seschrock 		(void) fprintf(fp, "%s", get_usage(current_command->usage));
258fa9e4066Sahrens 	}
259fa9e4066Sahrens 
260fa9e4066Sahrens 	if (current_command == NULL ||
261fa9e4066Sahrens 	    strcmp(current_command->name, "set") == 0 ||
262fa9e4066Sahrens 	    strcmp(current_command->name, "get") == 0 ||
263fa9e4066Sahrens 	    strcmp(current_command->name, "inherit") == 0 ||
264fa9e4066Sahrens 	    strcmp(current_command->name, "list") == 0)
265fa9e4066Sahrens 		show_properties = TRUE;
266fa9e4066Sahrens 
267fa9e4066Sahrens 	if (show_properties) {
268fa9e4066Sahrens 
269fa9e4066Sahrens 		(void) fprintf(fp,
270fa9e4066Sahrens 		    gettext("\nThe following properties are supported:\n"));
271fa9e4066Sahrens 
272fa9e4066Sahrens 		(void) fprintf(fp, "\n\t%-13s  %s  %s   %s\n\n",
273fa9e4066Sahrens 		    "PROPERTY", "EDIT", "INHERIT", "VALUES");
274fa9e4066Sahrens 
275fa9e4066Sahrens 		for (i = 0; i < ZFS_NPROP_VISIBLE; i++) {
276fa9e4066Sahrens 			(void) fprintf(fp, "\t%-13s  ", zfs_prop_to_name(i));
277fa9e4066Sahrens 
278fa9e4066Sahrens 			if (zfs_prop_readonly(i))
279fa9e4066Sahrens 				(void) fprintf(fp, "  NO    ");
280fa9e4066Sahrens 			else
281fa9e4066Sahrens 				(void) fprintf(fp, " YES    ");
282fa9e4066Sahrens 
283fa9e4066Sahrens 			if (zfs_prop_inheritable(i))
284fa9e4066Sahrens 				(void) fprintf(fp, "  YES   ");
285fa9e4066Sahrens 			else
286fa9e4066Sahrens 				(void) fprintf(fp, "   NO   ");
287fa9e4066Sahrens 
288fa9e4066Sahrens 			if (zfs_prop_values(i) == NULL)
289fa9e4066Sahrens 				(void) fprintf(fp, "-\n");
290fa9e4066Sahrens 			else
291fa9e4066Sahrens 				(void) fprintf(fp, "%s\n", zfs_prop_values(i));
292fa9e4066Sahrens 		}
293fa9e4066Sahrens 		(void) fprintf(fp, gettext("\nSizes are specified in bytes "
294fa9e4066Sahrens 		    "with standard units such as K, M, G, etc.\n"));
295fa9e4066Sahrens 	}
296fa9e4066Sahrens 
297fa9e4066Sahrens 	exit(requested ? 0 : 2);
298fa9e4066Sahrens }
299fa9e4066Sahrens 
300fa9e4066Sahrens /*
301fa9e4066Sahrens  * zfs clone <fs, snap, vol> fs
302fa9e4066Sahrens  *
303fa9e4066Sahrens  * Given an existing dataset, create a writable copy whose initial contents
304fa9e4066Sahrens  * are the same as the source.  The newly created dataset maintains a
305fa9e4066Sahrens  * dependency on the original; the original cannot be destroyed so long as
306fa9e4066Sahrens  * the clone exists.
307fa9e4066Sahrens  */
308fa9e4066Sahrens static int
309fa9e4066Sahrens zfs_do_clone(int argc, char **argv)
310fa9e4066Sahrens {
311fa9e4066Sahrens 	zfs_handle_t *zhp;
312fa9e4066Sahrens 	int ret;
313fa9e4066Sahrens 
314fa9e4066Sahrens 	/* check options */
315fa9e4066Sahrens 	if (argc > 1 && argv[1][0] == '-') {
316fa9e4066Sahrens 		(void) fprintf(stderr, gettext("invalid option '%c'\n"),
317fa9e4066Sahrens 		    argv[1][1]);
318fa9e4066Sahrens 		usage(FALSE);
319fa9e4066Sahrens 	}
320fa9e4066Sahrens 
321fa9e4066Sahrens 	/* check number of arguments */
322fa9e4066Sahrens 	if (argc < 2) {
323fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing source dataset "
324fa9e4066Sahrens 		    "argument\n"));
325fa9e4066Sahrens 		usage(FALSE);
326fa9e4066Sahrens 	}
327fa9e4066Sahrens 	if (argc < 3) {
328fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing target dataset "
329fa9e4066Sahrens 		    "argument\n"));
330fa9e4066Sahrens 		usage(FALSE);
331fa9e4066Sahrens 	}
332fa9e4066Sahrens 	if (argc > 3) {
333fa9e4066Sahrens 		(void) fprintf(stderr, gettext("too many arguments\n"));
334fa9e4066Sahrens 		usage(FALSE);
335fa9e4066Sahrens 	}
336fa9e4066Sahrens 
337fa9e4066Sahrens 	/* open the source dataset */
338fa9e4066Sahrens 	if ((zhp = zfs_open(argv[1], ZFS_TYPE_SNAPSHOT)) == NULL)
339fa9e4066Sahrens 		return (1);
340fa9e4066Sahrens 
341fa9e4066Sahrens 	/* pass to libzfs */
342fa9e4066Sahrens 	ret = zfs_clone(zhp, argv[2]);
343fa9e4066Sahrens 
344fa9e4066Sahrens 	/* create the mountpoint if necessary */
345fa9e4066Sahrens 	if (ret == 0) {
346fa9e4066Sahrens 		zfs_handle_t *clone = zfs_open(argv[2], ZFS_TYPE_ANY);
347fa9e4066Sahrens 		if (clone != NULL) {
348fa9e4066Sahrens 			if ((ret = zfs_mount(clone, NULL, 0)) == 0)
349fa9e4066Sahrens 				ret = zfs_share(clone);
350fa9e4066Sahrens 			zfs_close(clone);
351fa9e4066Sahrens 		}
352fa9e4066Sahrens 	}
353fa9e4066Sahrens 
354fa9e4066Sahrens 	zfs_close(zhp);
355fa9e4066Sahrens 
356fa9e4066Sahrens 	return (ret == 0 ? 0 : 1);
357fa9e4066Sahrens }
358fa9e4066Sahrens 
359fa9e4066Sahrens /*
360fa9e4066Sahrens  * zfs create fs
361fa9e4066Sahrens  * zfs create [-s] -V vol size
362fa9e4066Sahrens  *
363fa9e4066Sahrens  * Create a new dataset.  This command can be used to create filesystems
364fa9e4066Sahrens  * and volumes.  Snapshot creation is handled by 'zfs snapshot'.
365fa9e4066Sahrens  * For volumes, the user must specify a size to be used.
366fa9e4066Sahrens  *
367fa9e4066Sahrens  * The '-s' flag applies only to volumes, and indicates that we should not try
368fa9e4066Sahrens  * to set the reservation for this volume.  By default we set a reservation
369fa9e4066Sahrens  * equal to the size for any volume.
370fa9e4066Sahrens  */
371fa9e4066Sahrens static int
372fa9e4066Sahrens zfs_do_create(int argc, char **argv)
373fa9e4066Sahrens {
374fa9e4066Sahrens 	zfs_type_t type = ZFS_TYPE_FILESYSTEM;
375fa9e4066Sahrens 	zfs_handle_t *zhp;
376fa9e4066Sahrens 	char *size = NULL;
377fa9e4066Sahrens 	char *blocksize = NULL;
378fa9e4066Sahrens 	int c;
379fa9e4066Sahrens 	int noreserve = FALSE;
380fa9e4066Sahrens 	int ret;
381fa9e4066Sahrens 
382fa9e4066Sahrens 	/* check options */
383fa9e4066Sahrens 	while ((c = getopt(argc, argv, ":V:b:s")) != -1) {
384fa9e4066Sahrens 		switch (c) {
385fa9e4066Sahrens 		case 'V':
386fa9e4066Sahrens 			type = ZFS_TYPE_VOLUME;
387fa9e4066Sahrens 			size = optarg;
388fa9e4066Sahrens 			break;
389fa9e4066Sahrens 		case 'b':
390fa9e4066Sahrens 			blocksize = optarg;
391fa9e4066Sahrens 			break;
392fa9e4066Sahrens 		case 's':
393fa9e4066Sahrens 			noreserve = TRUE;
394fa9e4066Sahrens 			break;
395fa9e4066Sahrens 		case ':':
396fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing size "
397fa9e4066Sahrens 			    "argument\n"));
398fa9e4066Sahrens 			usage(FALSE);
399fa9e4066Sahrens 			break;
400fa9e4066Sahrens 		case '?':
401fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
402fa9e4066Sahrens 			    optopt);
403fa9e4066Sahrens 			usage(FALSE);
404fa9e4066Sahrens 		}
405fa9e4066Sahrens 	}
406fa9e4066Sahrens 
407fa9e4066Sahrens 	if (noreserve && type != ZFS_TYPE_VOLUME) {
408fa9e4066Sahrens 		(void) fprintf(stderr, gettext("'-s' can only be used when "
409fa9e4066Sahrens 		    "creating a volume\n"));
410fa9e4066Sahrens 		usage(FALSE);
411fa9e4066Sahrens 	}
412fa9e4066Sahrens 
413fa9e4066Sahrens 	argc -= optind;
414fa9e4066Sahrens 	argv += optind;
415fa9e4066Sahrens 
416fa9e4066Sahrens 	/* check number of arguments */
417fa9e4066Sahrens 	if (argc == 0) {
418fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing %s argument\n"),
419fa9e4066Sahrens 		    zfs_type_to_name(type));
420fa9e4066Sahrens 		usage(FALSE);
421fa9e4066Sahrens 	}
422fa9e4066Sahrens 	if (argc > 1) {
423fa9e4066Sahrens 		(void) fprintf(stderr, gettext("too many arguments\n"));
424fa9e4066Sahrens 		usage(FALSE);
425fa9e4066Sahrens 	}
426fa9e4066Sahrens 
427fa9e4066Sahrens 	/* pass to libzfs */
428fa9e4066Sahrens 	if (zfs_create(argv[0], type, size, blocksize) != 0)
429fa9e4066Sahrens 		return (1);
430fa9e4066Sahrens 
431fa9e4066Sahrens 	if ((zhp = zfs_open(argv[0], ZFS_TYPE_ANY)) == NULL)
432fa9e4066Sahrens 		return (1);
433fa9e4066Sahrens 
434fa9e4066Sahrens 	/*
435fa9e4066Sahrens 	 * Volume handling.  By default, we try to create a reservation of equal
436fa9e4066Sahrens 	 * size for the volume.  If we can't do this, then destroy the dataset
437fa9e4066Sahrens 	 * and report an error.
438fa9e4066Sahrens 	 */
439fa9e4066Sahrens 	if (type == ZFS_TYPE_VOLUME && !noreserve) {
440fa9e4066Sahrens 		if (zfs_prop_set(zhp, ZFS_PROP_RESERVATION, size) != 0) {
441fa9e4066Sahrens 			(void) fprintf(stderr, gettext("use '-s' to create a "
442fa9e4066Sahrens 			    "volume without a matching reservation\n"));
443fa9e4066Sahrens 			(void) zfs_destroy(zhp);
444fa9e4066Sahrens 			return (1);
445fa9e4066Sahrens 		}
446fa9e4066Sahrens 	}
447fa9e4066Sahrens 
448fa9e4066Sahrens 	/*
449fa9e4066Sahrens 	 * Mount and/or share the new filesystem as appropriate.  We provide a
450fa9e4066Sahrens 	 * verbose error message to let the user know that their filesystem was
451fa9e4066Sahrens 	 * in fact created, even if we failed to mount or share it.
452fa9e4066Sahrens 	 */
453fa9e4066Sahrens 	if (zfs_mount(zhp, NULL, 0) != 0) {
454fa9e4066Sahrens 		(void) fprintf(stderr, gettext("filesystem successfully "
455fa9e4066Sahrens 		    "created, but not mounted\n"));
456fa9e4066Sahrens 		ret = 1;
457fa9e4066Sahrens 	} else if (zfs_share(zhp) != 0) {
458fa9e4066Sahrens 		(void) fprintf(stderr, gettext("filesystem successfully "
459fa9e4066Sahrens 		    "created, but not shared\n"));
460fa9e4066Sahrens 		ret = 1;
461fa9e4066Sahrens 	} else {
462fa9e4066Sahrens 		ret = 0;
463fa9e4066Sahrens 	}
464fa9e4066Sahrens 
465fa9e4066Sahrens 	zfs_close(zhp);
466fa9e4066Sahrens 	return (ret);
467fa9e4066Sahrens }
468fa9e4066Sahrens 
469fa9e4066Sahrens /*
470fa9e4066Sahrens  * zfs destroy [-rf] <fs, snap, vol>
471fa9e4066Sahrens  *
472fa9e4066Sahrens  * 	-r	Recursively destroy all children
473fa9e4066Sahrens  * 	-R	Recursively destroy all dependents, including clones
474fa9e4066Sahrens  * 	-f	Force unmounting of any dependents
475fa9e4066Sahrens  *
476fa9e4066Sahrens  * Destroys the given dataset.  By default, it will unmount any filesystems,
477fa9e4066Sahrens  * and refuse to destroy a dataset that has any dependents.  A dependent can
478fa9e4066Sahrens  * either be a child, or a clone of a child.
479fa9e4066Sahrens  */
480fa9e4066Sahrens typedef struct destroy_cbdata {
481fa9e4066Sahrens 	int		cb_first;
482fa9e4066Sahrens 	int		cb_force;
483fa9e4066Sahrens 	int		cb_recurse;
484fa9e4066Sahrens 	int		cb_error;
485fa9e4066Sahrens 	int		cb_needforce;
486fa9e4066Sahrens 	int		cb_doclones;
487fa9e4066Sahrens 	zfs_handle_t	*cb_target;
488fa9e4066Sahrens } destroy_cbdata_t;
489fa9e4066Sahrens 
490fa9e4066Sahrens /*
491fa9e4066Sahrens  * Check for any dependents based on the '-r' or '-R' flags.
492fa9e4066Sahrens  */
493fa9e4066Sahrens static int
494fa9e4066Sahrens destroy_check_dependent(zfs_handle_t *zhp, void *data)
495fa9e4066Sahrens {
496fa9e4066Sahrens 	destroy_cbdata_t *cbp = data;
497fa9e4066Sahrens 	const char *tname = zfs_get_name(cbp->cb_target);
498fa9e4066Sahrens 	const char *name = zfs_get_name(zhp);
499fa9e4066Sahrens 
500fa9e4066Sahrens 	if (strncmp(tname, name, strlen(tname)) == 0 &&
501fa9e4066Sahrens 	    (name[strlen(tname)] == '/' || name[strlen(tname)] == '@')) {
502fa9e4066Sahrens 		/*
503fa9e4066Sahrens 		 * This is a direct descendant, not a clone somewhere else in
504fa9e4066Sahrens 		 * the hierarchy.
505fa9e4066Sahrens 		 */
506fa9e4066Sahrens 		if (cbp->cb_recurse)
507fa9e4066Sahrens 			goto out;
508fa9e4066Sahrens 
509fa9e4066Sahrens 		if (cbp->cb_first) {
510fa9e4066Sahrens 			(void) fprintf(stderr, gettext("cannot destroy '%s': "
511fa9e4066Sahrens 			    "%s has children\n"),
512fa9e4066Sahrens 			    zfs_get_name(cbp->cb_target),
513fa9e4066Sahrens 			    zfs_type_to_name(zfs_get_type(cbp->cb_target)));
514fa9e4066Sahrens 			(void) fprintf(stderr, gettext("use '-r' to destroy "
515fa9e4066Sahrens 			    "the following datasets:\n"));
516fa9e4066Sahrens 			cbp->cb_first = 0;
517fa9e4066Sahrens 			cbp->cb_error = 1;
518fa9e4066Sahrens 		}
519fa9e4066Sahrens 
520fa9e4066Sahrens 		(void) fprintf(stderr, "%s\n", zfs_get_name(zhp));
521fa9e4066Sahrens 	} else {
522fa9e4066Sahrens 		/*
523fa9e4066Sahrens 		 * This is a clone.  We only want to report this if the '-r'
524fa9e4066Sahrens 		 * wasn't specified, or the target is a snapshot.
525fa9e4066Sahrens 		 */
526fa9e4066Sahrens 		if (!cbp->cb_recurse &&
527fa9e4066Sahrens 		    zfs_get_type(cbp->cb_target) != ZFS_TYPE_SNAPSHOT)
528fa9e4066Sahrens 			goto out;
529fa9e4066Sahrens 
530fa9e4066Sahrens 		if (cbp->cb_first) {
531fa9e4066Sahrens 			(void) fprintf(stderr, gettext("cannot destroy '%s': "
532fa9e4066Sahrens 			    "%s has dependent clones\n"),
533fa9e4066Sahrens 			    zfs_get_name(cbp->cb_target),
534fa9e4066Sahrens 			    zfs_type_to_name(zfs_get_type(cbp->cb_target)));
535fa9e4066Sahrens 			(void) fprintf(stderr, gettext("use '-R' to destroy "
536fa9e4066Sahrens 			    "the following datasets:\n"));
537fa9e4066Sahrens 			cbp->cb_first = 0;
538fa9e4066Sahrens 			cbp->cb_error = 1;
539fa9e4066Sahrens 		}
540fa9e4066Sahrens 
541fa9e4066Sahrens 		(void) fprintf(stderr, "%s\n", zfs_get_name(zhp));
542fa9e4066Sahrens 	}
543fa9e4066Sahrens 
544fa9e4066Sahrens out:
545fa9e4066Sahrens 	zfs_close(zhp);
546fa9e4066Sahrens 	return (0);
547fa9e4066Sahrens }
548fa9e4066Sahrens 
549fa9e4066Sahrens static int
550fa9e4066Sahrens destroy_callback(zfs_handle_t *zhp, void *data)
551fa9e4066Sahrens {
552fa9e4066Sahrens 	destroy_cbdata_t *cbp = data;
553fa9e4066Sahrens 
554fa9e4066Sahrens 	/*
555fa9e4066Sahrens 	 * Ignore pools (which we've already flagged as an error before getting
556fa9e4066Sahrens 	 * here.
557fa9e4066Sahrens 	 */
558fa9e4066Sahrens 	if (strchr(zfs_get_name(zhp), '/') == NULL &&
559fa9e4066Sahrens 	    zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM) {
560fa9e4066Sahrens 		zfs_close(zhp);
561fa9e4066Sahrens 		return (0);
562fa9e4066Sahrens 	}
563fa9e4066Sahrens 
564fa9e4066Sahrens 	/*
565fa9e4066Sahrens 	 * Bail out on the first error.
566fa9e4066Sahrens 	 */
567fa9e4066Sahrens 	if (zfs_unmount(zhp, NULL, cbp->cb_force ? MS_FORCE : 0) != 0 ||
568fa9e4066Sahrens 	    zfs_destroy(zhp) != 0) {
569fa9e4066Sahrens 		zfs_close(zhp);
570fa9e4066Sahrens 		return (-1);
571fa9e4066Sahrens 	}
572fa9e4066Sahrens 
573fa9e4066Sahrens 	zfs_close(zhp);
574fa9e4066Sahrens 	return (0);
575fa9e4066Sahrens }
576fa9e4066Sahrens 
577fa9e4066Sahrens 
578fa9e4066Sahrens static int
579fa9e4066Sahrens zfs_do_destroy(int argc, char **argv)
580fa9e4066Sahrens {
581fa9e4066Sahrens 	destroy_cbdata_t cb = { 0 };
582fa9e4066Sahrens 	int c;
583fa9e4066Sahrens 	zfs_handle_t *zhp;
584fa9e4066Sahrens 
585fa9e4066Sahrens 	/* check options */
586fa9e4066Sahrens 	while ((c = getopt(argc, argv, "frR")) != -1) {
587fa9e4066Sahrens 		switch (c) {
588fa9e4066Sahrens 		case 'f':
589fa9e4066Sahrens 			cb.cb_force = 1;
590fa9e4066Sahrens 			break;
591fa9e4066Sahrens 		case 'r':
592fa9e4066Sahrens 			cb.cb_recurse = 1;
593fa9e4066Sahrens 			break;
594fa9e4066Sahrens 		case 'R':
595fa9e4066Sahrens 			cb.cb_recurse = 1;
596fa9e4066Sahrens 			cb.cb_doclones = 1;
597fa9e4066Sahrens 			break;
598fa9e4066Sahrens 		case '?':
599fa9e4066Sahrens 		default:
600fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
601fa9e4066Sahrens 			    optopt);
602fa9e4066Sahrens 			usage(FALSE);
603fa9e4066Sahrens 		}
604fa9e4066Sahrens 	}
605fa9e4066Sahrens 
606fa9e4066Sahrens 	argc -= optind;
607fa9e4066Sahrens 	argv += optind;
608fa9e4066Sahrens 
609fa9e4066Sahrens 	/* check number of arguments */
610fa9e4066Sahrens 	if (argc == 0) {
611fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing path argument\n"));
612fa9e4066Sahrens 		usage(FALSE);
613fa9e4066Sahrens 	}
614fa9e4066Sahrens 	if (argc > 1) {
615fa9e4066Sahrens 		(void) fprintf(stderr, gettext("too many arguments\n"));
616fa9e4066Sahrens 		usage(FALSE);
617fa9e4066Sahrens 	}
618fa9e4066Sahrens 
619fa9e4066Sahrens 	/* Open the given dataset */
620fa9e4066Sahrens 	if ((zhp = zfs_open(argv[0], ZFS_TYPE_ANY)) == NULL)
621fa9e4066Sahrens 		return (1);
622fa9e4066Sahrens 
623fa9e4066Sahrens 	cb.cb_target = zhp;
624fa9e4066Sahrens 
625fa9e4066Sahrens 	/*
626fa9e4066Sahrens 	 * Perform an explicit check for pools before going any further.
627fa9e4066Sahrens 	 */
628fa9e4066Sahrens 	if (!cb.cb_recurse && strchr(zfs_get_name(zhp), '/') == NULL &&
629fa9e4066Sahrens 	    zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM) {
630fa9e4066Sahrens 		(void) fprintf(stderr, gettext("cannot destroy '%s': "
631fa9e4066Sahrens 		    "operation does not apply to pools\n"),
632fa9e4066Sahrens 		    zfs_get_name(zhp));
633fa9e4066Sahrens 		(void) fprintf(stderr, gettext("use 'zfs destroy -r "
634fa9e4066Sahrens 		    "%s' to destroy all datasets in the pool\n"),
635fa9e4066Sahrens 		    zfs_get_name(zhp));
636fa9e4066Sahrens 		(void) fprintf(stderr, gettext("use 'zpool destroy %s' "
637fa9e4066Sahrens 		    "to destroy the pool itself\n"), zfs_get_name(zhp));
638fa9e4066Sahrens 		zfs_close(zhp);
639fa9e4066Sahrens 		return (1);
640fa9e4066Sahrens 	}
641fa9e4066Sahrens 
642fa9e4066Sahrens 
643fa9e4066Sahrens 	/*
644fa9e4066Sahrens 	 * Check for any dependents and/or clones.
645fa9e4066Sahrens 	 */
646fa9e4066Sahrens 	cb.cb_first = 1;
647fa9e4066Sahrens 	if (!cb.cb_doclones)
648fa9e4066Sahrens 		(void) zfs_iter_dependents(zhp, destroy_check_dependent, &cb);
649fa9e4066Sahrens 
650fa9e4066Sahrens 	if (cb.cb_error) {
651fa9e4066Sahrens 		zfs_close(zhp);
652fa9e4066Sahrens 		return (1);
653fa9e4066Sahrens 	}
654fa9e4066Sahrens 
655fa9e4066Sahrens 	/*
656fa9e4066Sahrens 	 * Do the real thing.
657fa9e4066Sahrens 	 */
658fa9e4066Sahrens 	if (zfs_iter_dependents(zhp, destroy_callback, &cb) == 0 &&
659fa9e4066Sahrens 	    destroy_callback(zhp, &cb) == 0)
660fa9e4066Sahrens 		return (0);
661fa9e4066Sahrens 
662fa9e4066Sahrens 	return (1);
663fa9e4066Sahrens }
664fa9e4066Sahrens 
665fa9e4066Sahrens /*
66607ba0419Seschrock  * zfs get [-rHp] [-o field[,field]...] [-s source[,source]...]
66707ba0419Seschrock  * 	< all | property[,property]... > < fs | snap | vol > ...
668fa9e4066Sahrens  *
669fa9e4066Sahrens  *	-r	recurse over any child datasets
670fa9e4066Sahrens  *	-H	scripted mode.  Headers are stripped, and fields are separated
671fa9e4066Sahrens  *		by tabs instead of spaces.
672fa9e4066Sahrens  *	-o	Set of fields to display.  One of "name,property,value,source".
673fa9e4066Sahrens  *		Default is all four.
674fa9e4066Sahrens  *	-s	Set of sources to allow.  One of
675fa9e4066Sahrens  *		"local,default,inherited,temporary,none".  Default is all
676fa9e4066Sahrens  *		five.
677fa9e4066Sahrens  *	-p	Display values in parsable (literal) format.
678fa9e4066Sahrens  *
679fa9e4066Sahrens  *  Prints properties for the given datasets.  The user can control which
680fa9e4066Sahrens  *  columns to display as well as which property types to allow.
681fa9e4066Sahrens  */
682fa9e4066Sahrens typedef struct get_cbdata {
683fa9e4066Sahrens 	int cb_scripted;
684fa9e4066Sahrens 	int cb_sources;
685fa9e4066Sahrens 	int cb_literal;
686fa9e4066Sahrens 	int cb_columns[4];
687fa9e4066Sahrens 	zfs_prop_t cb_prop[ZFS_NPROP_ALL];
688fa9e4066Sahrens 	int cb_nprop;
68907ba0419Seschrock 	int cb_isall;
690fa9e4066Sahrens } get_cbdata_t;
691fa9e4066Sahrens 
692fa9e4066Sahrens #define	GET_COL_NAME		1
693fa9e4066Sahrens #define	GET_COL_PROPERTY	2
694fa9e4066Sahrens #define	GET_COL_VALUE		3
695fa9e4066Sahrens #define	GET_COL_SOURCE		4
696fa9e4066Sahrens 
697fa9e4066Sahrens /*
698fa9e4066Sahrens  * Display a single line of output, according to the settings in the callback
699fa9e4066Sahrens  * structure.
700fa9e4066Sahrens  */
701fa9e4066Sahrens static void
702fa9e4066Sahrens print_one_property(zfs_handle_t *zhp, get_cbdata_t *cbp, zfs_prop_t prop,
703fa9e4066Sahrens     const char *value, zfs_source_t sourcetype, const char *source)
704fa9e4066Sahrens {
705fa9e4066Sahrens 	int i;
706fa9e4066Sahrens 	int width;
707fa9e4066Sahrens 	const char *str;
708fa9e4066Sahrens 	char buf[128];
709fa9e4066Sahrens 
710fa9e4066Sahrens 	/*
711fa9e4066Sahrens 	 * Ignore those source types that the user has chosen to ignore.
712fa9e4066Sahrens 	 */
713fa9e4066Sahrens 	if ((sourcetype & cbp->cb_sources) == 0)
714fa9e4066Sahrens 		return;
715fa9e4066Sahrens 
716fa9e4066Sahrens 	for (i = 0; i < 4; i++) {
717fa9e4066Sahrens 		switch (cbp->cb_columns[i]) {
718fa9e4066Sahrens 		case GET_COL_NAME:
719fa9e4066Sahrens 			width = 15;
720fa9e4066Sahrens 			str = zfs_get_name(zhp);
721fa9e4066Sahrens 			break;
722fa9e4066Sahrens 
723fa9e4066Sahrens 		case GET_COL_PROPERTY:
724fa9e4066Sahrens 			width = 13;
725fa9e4066Sahrens 			str = zfs_prop_to_name(prop);
726fa9e4066Sahrens 			break;
727fa9e4066Sahrens 
728fa9e4066Sahrens 		case GET_COL_VALUE:
729fa9e4066Sahrens 			width = 25;
730fa9e4066Sahrens 			str = value;
731fa9e4066Sahrens 			break;
732fa9e4066Sahrens 
733fa9e4066Sahrens 		case GET_COL_SOURCE:
734fa9e4066Sahrens 			width = 15;
735fa9e4066Sahrens 			switch (sourcetype) {
736fa9e4066Sahrens 			case ZFS_SRC_NONE:
737fa9e4066Sahrens 				str = "-";
738fa9e4066Sahrens 				break;
739fa9e4066Sahrens 
740fa9e4066Sahrens 			case ZFS_SRC_DEFAULT:
741fa9e4066Sahrens 				str = "default";
742fa9e4066Sahrens 				break;
743fa9e4066Sahrens 
744fa9e4066Sahrens 			case ZFS_SRC_LOCAL:
745fa9e4066Sahrens 				str = "local";
746fa9e4066Sahrens 				break;
747fa9e4066Sahrens 
748fa9e4066Sahrens 			case ZFS_SRC_TEMPORARY:
749fa9e4066Sahrens 				str = "temporary";
750fa9e4066Sahrens 				break;
751fa9e4066Sahrens 
752fa9e4066Sahrens 			case ZFS_SRC_INHERITED:
753fa9e4066Sahrens 				(void) snprintf(buf, sizeof (buf),
754fa9e4066Sahrens 				    "inherited from %s", source);
755fa9e4066Sahrens 				str = buf;
756fa9e4066Sahrens 				break;
757fa9e4066Sahrens 			}
758fa9e4066Sahrens 			break;
759fa9e4066Sahrens 
760fa9e4066Sahrens 		default:
761fa9e4066Sahrens 			continue;
762fa9e4066Sahrens 		}
763fa9e4066Sahrens 
764fa9e4066Sahrens 		if (cbp->cb_columns[i + 1] == 0)
765fa9e4066Sahrens 			(void) printf("%s", str);
766fa9e4066Sahrens 		else if (cbp->cb_scripted)
767fa9e4066Sahrens 			(void) printf("%s\t", str);
768fa9e4066Sahrens 		else
769fa9e4066Sahrens 			(void) printf("%-*s  ", width, str);
770fa9e4066Sahrens 
771fa9e4066Sahrens 	}
772fa9e4066Sahrens 
773fa9e4066Sahrens 	(void) printf("\n");
774fa9e4066Sahrens }
775fa9e4066Sahrens 
776fa9e4066Sahrens /*
777fa9e4066Sahrens  * Invoked to display the properties for a single dataset.
778fa9e4066Sahrens  */
779fa9e4066Sahrens static int
780fa9e4066Sahrens get_callback(zfs_handle_t *zhp, void *data)
781fa9e4066Sahrens {
782fa9e4066Sahrens 	char buf[ZFS_MAXPROPLEN];
783fa9e4066Sahrens 	zfs_source_t sourcetype;
784fa9e4066Sahrens 	char source[ZFS_MAXNAMELEN];
785fa9e4066Sahrens 	get_cbdata_t *cbp = data;
786fa9e4066Sahrens 	int i;
787fa9e4066Sahrens 
788fa9e4066Sahrens 	for (i = 0; i < cbp->cb_nprop; i++) {
789fa9e4066Sahrens 		if (zfs_prop_get(zhp, cbp->cb_prop[i], buf,
790fa9e4066Sahrens 		    sizeof (buf), &sourcetype, source, sizeof (source),
791fa9e4066Sahrens 		    cbp->cb_literal) != 0) {
79207ba0419Seschrock 			if (cbp->cb_isall)
79307ba0419Seschrock 				continue;
794fa9e4066Sahrens 			(void) strlcpy(buf, "-", sizeof (buf));
795fa9e4066Sahrens 			sourcetype = ZFS_SRC_NONE;
796fa9e4066Sahrens 		}
797fa9e4066Sahrens 
798fa9e4066Sahrens 		print_one_property(zhp, cbp, cbp->cb_prop[i],
799fa9e4066Sahrens 		    buf, sourcetype, source);
800fa9e4066Sahrens 	}
801fa9e4066Sahrens 
802fa9e4066Sahrens 	return (0);
803fa9e4066Sahrens }
804fa9e4066Sahrens 
805fa9e4066Sahrens static int
806fa9e4066Sahrens zfs_do_get(int argc, char **argv)
807fa9e4066Sahrens {
808fa9e4066Sahrens 	get_cbdata_t cb = { 0 };
809fa9e4066Sahrens 	int recurse = 0;
810fa9e4066Sahrens 	int c;
81107ba0419Seschrock 	char *value, *fields, *badopt;
812fa9e4066Sahrens 	int i;
81307ba0419Seschrock 	int ret;
814fa9e4066Sahrens 
815fa9e4066Sahrens 	/*
816fa9e4066Sahrens 	 * Set up default columns and sources.
817fa9e4066Sahrens 	 */
818fa9e4066Sahrens 	cb.cb_sources = ZFS_SRC_ALL;
819fa9e4066Sahrens 	cb.cb_columns[0] = GET_COL_NAME;
820fa9e4066Sahrens 	cb.cb_columns[1] = GET_COL_PROPERTY;
821fa9e4066Sahrens 	cb.cb_columns[2] = GET_COL_VALUE;
822fa9e4066Sahrens 	cb.cb_columns[3] = GET_COL_SOURCE;
823fa9e4066Sahrens 
824fa9e4066Sahrens 	/* check options */
825fa9e4066Sahrens 	while ((c = getopt(argc, argv, ":o:s:rHp")) != -1) {
826fa9e4066Sahrens 		switch (c) {
827fa9e4066Sahrens 		case 'p':
828fa9e4066Sahrens 			cb.cb_literal = TRUE;
829fa9e4066Sahrens 			break;
830fa9e4066Sahrens 		case 'r':
831fa9e4066Sahrens 			recurse = TRUE;
832fa9e4066Sahrens 			break;
833fa9e4066Sahrens 		case 'H':
834fa9e4066Sahrens 			cb.cb_scripted = TRUE;
835fa9e4066Sahrens 			break;
836fa9e4066Sahrens 		case ':':
837fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing argument for "
838fa9e4066Sahrens 			    "'%c' option\n"), optopt);
839fa9e4066Sahrens 			usage(FALSE);
840fa9e4066Sahrens 			break;
841fa9e4066Sahrens 		case 'o':
842fa9e4066Sahrens 			/*
843fa9e4066Sahrens 			 * Process the set of columns to display.  We zero out
844fa9e4066Sahrens 			 * the structure to give us a blank slate.
845fa9e4066Sahrens 			 */
846fa9e4066Sahrens 			bzero(&cb.cb_columns, sizeof (cb.cb_columns));
847fa9e4066Sahrens 			i = 0;
848fa9e4066Sahrens 			while (*optarg != '\0') {
849fa9e4066Sahrens 				static char *col_subopts[] =
850fa9e4066Sahrens 				    { "name", "property", "value", "source",
851fa9e4066Sahrens 				    NULL };
852fa9e4066Sahrens 
853fa9e4066Sahrens 				if (i == 4) {
854fa9e4066Sahrens 					(void) fprintf(stderr, gettext("too "
855fa9e4066Sahrens 					    "many fields given to -o "
856fa9e4066Sahrens 					    "option\n"));
857fa9e4066Sahrens 					usage(FALSE);
858fa9e4066Sahrens 				}
859fa9e4066Sahrens 
860fa9e4066Sahrens 				switch (getsubopt(&optarg, col_subopts,
861fa9e4066Sahrens 				    &value)) {
862fa9e4066Sahrens 				case 0:
863fa9e4066Sahrens 					cb.cb_columns[i++] = GET_COL_NAME;
864fa9e4066Sahrens 					break;
865fa9e4066Sahrens 				case 1:
866fa9e4066Sahrens 					cb.cb_columns[i++] = GET_COL_PROPERTY;
867fa9e4066Sahrens 					break;
868fa9e4066Sahrens 				case 2:
869fa9e4066Sahrens 					cb.cb_columns[i++] = GET_COL_VALUE;
870fa9e4066Sahrens 					break;
871fa9e4066Sahrens 				case 3:
872fa9e4066Sahrens 					cb.cb_columns[i++] = GET_COL_SOURCE;
873fa9e4066Sahrens 					break;
874fa9e4066Sahrens 				default:
875fa9e4066Sahrens 					(void) fprintf(stderr,
876fa9e4066Sahrens 					    gettext("invalid column name "
877fa9e4066Sahrens 					    "'%s'\n"), value);
878fa9e4066Sahrens 					    usage(FALSE);
879fa9e4066Sahrens 				}
880fa9e4066Sahrens 			}
881fa9e4066Sahrens 			break;
882fa9e4066Sahrens 
883fa9e4066Sahrens 		case 's':
884fa9e4066Sahrens 			cb.cb_sources = 0;
885fa9e4066Sahrens 			while (*optarg != '\0') {
886fa9e4066Sahrens 				static char *source_subopts[] = {
887fa9e4066Sahrens 					"local", "default", "inherited",
888fa9e4066Sahrens 					"temporary", "none", NULL };
889fa9e4066Sahrens 
890fa9e4066Sahrens 				switch (getsubopt(&optarg, source_subopts,
891fa9e4066Sahrens 				    &value)) {
892fa9e4066Sahrens 				case 0:
893fa9e4066Sahrens 					cb.cb_sources |= ZFS_SRC_LOCAL;
894fa9e4066Sahrens 					break;
895fa9e4066Sahrens 				case 1:
896fa9e4066Sahrens 					cb.cb_sources |= ZFS_SRC_DEFAULT;
897fa9e4066Sahrens 					break;
898fa9e4066Sahrens 				case 2:
899fa9e4066Sahrens 					cb.cb_sources |= ZFS_SRC_INHERITED;
900fa9e4066Sahrens 					break;
901fa9e4066Sahrens 				case 3:
902fa9e4066Sahrens 					cb.cb_sources |= ZFS_SRC_TEMPORARY;
903fa9e4066Sahrens 					break;
904fa9e4066Sahrens 				case 4:
905fa9e4066Sahrens 					cb.cb_sources |= ZFS_SRC_NONE;
906fa9e4066Sahrens 					break;
907fa9e4066Sahrens 				default:
908fa9e4066Sahrens 					(void) fprintf(stderr,
909fa9e4066Sahrens 					    gettext("invalid source "
910fa9e4066Sahrens 					    "'%s'\n"), value);
911fa9e4066Sahrens 					    usage(FALSE);
912fa9e4066Sahrens 				}
913fa9e4066Sahrens 			}
914fa9e4066Sahrens 			break;
915fa9e4066Sahrens 
916fa9e4066Sahrens 		case '?':
917fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
918fa9e4066Sahrens 			    optopt);
919fa9e4066Sahrens 			usage(FALSE);
920fa9e4066Sahrens 		}
921fa9e4066Sahrens 	}
922fa9e4066Sahrens 
923fa9e4066Sahrens 	argc -= optind;
924fa9e4066Sahrens 	argv += optind;
925fa9e4066Sahrens 
926fa9e4066Sahrens 	if (argc < 1) {
927fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing property "
928fa9e4066Sahrens 		    "argument\n"));
929fa9e4066Sahrens 		usage(FALSE);
930fa9e4066Sahrens 	}
931fa9e4066Sahrens 
932fa9e4066Sahrens 	fields = argv[0];
933fa9e4066Sahrens 
934fa9e4066Sahrens 	/*
93507ba0419Seschrock 	 * If the user specifies 'all', the behavior of 'zfs get' is slightly
93607ba0419Seschrock 	 * different, because we don't show properties which don't apply to the
93707ba0419Seschrock 	 * given dataset.
938fa9e4066Sahrens 	 */
93907ba0419Seschrock 	if (strcmp(fields, "all") == 0)
94007ba0419Seschrock 		cb.cb_isall = TRUE;
94107ba0419Seschrock 
94207ba0419Seschrock 	if ((ret = zfs_get_proplist(fields, cb.cb_prop, ZFS_NPROP_ALL,
94307ba0419Seschrock 	    &cb.cb_nprop, &badopt)) != 0) {
94407ba0419Seschrock 		if (ret == EINVAL)
94507ba0419Seschrock 			(void) fprintf(stderr, gettext("invalid property "
94607ba0419Seschrock 			    "'%s'\n"), badopt);
94707ba0419Seschrock 		else
94807ba0419Seschrock 			(void) fprintf(stderr, gettext("too many properties "
94907ba0419Seschrock 			    "specified\n"));
950fa9e4066Sahrens 		usage(FALSE);
951fa9e4066Sahrens 	}
952fa9e4066Sahrens 
953fa9e4066Sahrens 	argc--;
954fa9e4066Sahrens 	argv++;
955fa9e4066Sahrens 
956fa9e4066Sahrens 	/* check for at least one dataset name */
957fa9e4066Sahrens 	if (argc < 1) {
958fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing dataset argument\n"));
959fa9e4066Sahrens 		usage(FALSE);
960fa9e4066Sahrens 	}
961fa9e4066Sahrens 
962fa9e4066Sahrens 	/*
963fa9e4066Sahrens 	 * Print out any headers
964fa9e4066Sahrens 	 */
965fa9e4066Sahrens 	if (!cb.cb_scripted) {
966fa9e4066Sahrens 		int i;
967fa9e4066Sahrens 		for (i = 0; i < 4; i++) {
968fa9e4066Sahrens 			switch (cb.cb_columns[i]) {
969fa9e4066Sahrens 			case GET_COL_NAME:
970fa9e4066Sahrens 				(void) printf("%-15s  ", "NAME");
971fa9e4066Sahrens 				break;
972fa9e4066Sahrens 			case GET_COL_PROPERTY:
973fa9e4066Sahrens 				(void) printf("%-13s  ", "PROPERTY");
974fa9e4066Sahrens 				break;
975fa9e4066Sahrens 			case GET_COL_VALUE:
976fa9e4066Sahrens 				(void) printf("%-25s  ", "VALUE");
977fa9e4066Sahrens 				break;
978fa9e4066Sahrens 			case GET_COL_SOURCE:
979fa9e4066Sahrens 				(void) printf("%s", "SOURCE");
980fa9e4066Sahrens 				break;
981fa9e4066Sahrens 			}
982fa9e4066Sahrens 		}
983fa9e4066Sahrens 		(void) printf("\n");
984fa9e4066Sahrens 	}
985fa9e4066Sahrens 
986fa9e4066Sahrens 	/* run for each object */
987fa9e4066Sahrens 	return (zfs_for_each(argc, argv, recurse, ZFS_TYPE_ANY,
988fa9e4066Sahrens 	    get_callback, &cb));
989fa9e4066Sahrens }
990fa9e4066Sahrens 
991fa9e4066Sahrens /*
992fa9e4066Sahrens  * inherit [-r] <property> <fs|vol> ...
993fa9e4066Sahrens  *
994fa9e4066Sahrens  * 	-r	Recurse over all children
995fa9e4066Sahrens  *
996fa9e4066Sahrens  * For each dataset specified on the command line, inherit the given property
997fa9e4066Sahrens  * from its parent.  Inheriting a property at the pool level will cause it to
998fa9e4066Sahrens  * use the default value.  The '-r' flag will recurse over all children, and is
999fa9e4066Sahrens  * useful for setting a property on a hierarchy-wide basis, regardless of any
1000fa9e4066Sahrens  * local modifications for each dataset.
1001fa9e4066Sahrens  */
1002fa9e4066Sahrens static int
1003fa9e4066Sahrens inherit_callback(zfs_handle_t *zhp, void *data)
1004fa9e4066Sahrens {
1005fa9e4066Sahrens 	zfs_prop_t prop = (zfs_prop_t)data;
1006fa9e4066Sahrens 
1007fa9e4066Sahrens 	return (zfs_prop_inherit(zhp, prop) != 0);
1008fa9e4066Sahrens }
1009fa9e4066Sahrens 
1010fa9e4066Sahrens static int
1011fa9e4066Sahrens zfs_do_inherit(int argc, char **argv)
1012fa9e4066Sahrens {
1013fa9e4066Sahrens 	int recurse = 0;
1014fa9e4066Sahrens 	int c;
1015fa9e4066Sahrens 	zfs_prop_t prop;
1016fa9e4066Sahrens 	char *propname;
1017fa9e4066Sahrens 
1018fa9e4066Sahrens 	/* check options */
1019fa9e4066Sahrens 	while ((c = getopt(argc, argv, "r")) != -1) {
1020fa9e4066Sahrens 		switch (c) {
1021fa9e4066Sahrens 		case 'r':
1022fa9e4066Sahrens 			recurse = TRUE;
1023fa9e4066Sahrens 			break;
1024fa9e4066Sahrens 		case '?':
1025fa9e4066Sahrens 		default:
1026fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
1027fa9e4066Sahrens 			    optopt);
1028fa9e4066Sahrens 			usage(FALSE);
1029fa9e4066Sahrens 		}
1030fa9e4066Sahrens 	}
1031fa9e4066Sahrens 
1032fa9e4066Sahrens 	argc -= optind;
1033fa9e4066Sahrens 	argv += optind;
1034fa9e4066Sahrens 
1035fa9e4066Sahrens 	/* check number of arguments */
1036fa9e4066Sahrens 	if (argc < 1) {
1037fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing property argument\n"));
1038fa9e4066Sahrens 		usage(FALSE);
1039fa9e4066Sahrens 	}
1040fa9e4066Sahrens 	if (argc < 2) {
1041fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing dataset argument\n"));
1042fa9e4066Sahrens 		usage(FALSE);
1043fa9e4066Sahrens 	}
1044fa9e4066Sahrens 
1045fa9e4066Sahrens 	propname = argv[0];
1046fa9e4066Sahrens 
1047fa9e4066Sahrens 	/*
1048fa9e4066Sahrens 	 * Get and validate the property before iterating over the datasets.  We
1049fa9e4066Sahrens 	 * do this now so as to avoid printing out an error message for each and
1050fa9e4066Sahrens 	 * every dataset.
1051fa9e4066Sahrens 	 */
1052fa9e4066Sahrens 	if ((prop = zfs_name_to_prop(propname)) == ZFS_PROP_INVAL) {
1053fa9e4066Sahrens 		(void) fprintf(stderr, gettext("invalid property '%s'\n"),
1054fa9e4066Sahrens 		    propname);
1055fa9e4066Sahrens 		usage(FALSE);
1056fa9e4066Sahrens 	}
1057fa9e4066Sahrens 	if (zfs_prop_readonly(prop)) {
1058fa9e4066Sahrens 		(void) fprintf(stderr, gettext("%s property is read-only\n"),
1059fa9e4066Sahrens 		    propname);
1060fa9e4066Sahrens 		return (1);
1061fa9e4066Sahrens 	}
1062fa9e4066Sahrens 	if (!zfs_prop_inheritable(prop)) {
1063fa9e4066Sahrens 		(void) fprintf(stderr, gettext("%s property cannot be "
1064fa9e4066Sahrens 		    "inherited\n"), propname);
1065fa9e4066Sahrens 		(void) fprintf(stderr, gettext("use 'zfs set %s=none' to "
1066fa9e4066Sahrens 		    "clear\n"), propname);
1067fa9e4066Sahrens 		return (1);
1068fa9e4066Sahrens 	}
1069fa9e4066Sahrens 
1070fa9e4066Sahrens 	return (zfs_for_each(argc - 1, argv + 1, recurse,
1071fa9e4066Sahrens 	    ZFS_TYPE_FILESYSTEM | ZFS_TYPE_VOLUME,
1072fa9e4066Sahrens 	    inherit_callback, (void *)prop));
1073fa9e4066Sahrens }
1074fa9e4066Sahrens 
1075fa9e4066Sahrens /*
107607ba0419Seschrock  * list [-rH] [-o property[,property]...] [-t type[,type]...] <dataset> ...
1077fa9e4066Sahrens  *
1078fa9e4066Sahrens  * 	-r	Recurse over all children
1079fa9e4066Sahrens  * 	-H	Scripted mode; elide headers and separate colums by tabs
1080fa9e4066Sahrens  * 	-o	Control which fields to display.
108107ba0419Seschrock  * 	-t	Control which object types to display.
1082fa9e4066Sahrens  *
1083fa9e4066Sahrens  * When given no arguments, lists all filesystems in the system.
1084fa9e4066Sahrens  * Otherwise, list the specified datasets, optionally recursing down them if
1085fa9e4066Sahrens  * '-r' is specified.
1086fa9e4066Sahrens  */
1087fa9e4066Sahrens typedef struct list_cbdata {
1088fa9e4066Sahrens 	int		cb_first;
1089fa9e4066Sahrens 	int		cb_scripted;
109007ba0419Seschrock 	zfs_prop_t	cb_fields[ZFS_NPROP_ALL];
1091fa9e4066Sahrens 	int		cb_fieldcount;
1092fa9e4066Sahrens } list_cbdata_t;
1093fa9e4066Sahrens 
1094fa9e4066Sahrens /*
1095fa9e4066Sahrens  * Given a list of columns to display, output appropriate headers for each one.
1096fa9e4066Sahrens  */
1097fa9e4066Sahrens static void
109807ba0419Seschrock print_header(zfs_prop_t *fields, size_t count)
1099fa9e4066Sahrens {
1100fa9e4066Sahrens 	int i;
1101fa9e4066Sahrens 
1102fa9e4066Sahrens 	for (i = 0; i < count; i++) {
1103fa9e4066Sahrens 		if (i != 0)
1104fa9e4066Sahrens 			(void) printf("  ");
1105fa9e4066Sahrens 		if (i == count - 1)
1106fa9e4066Sahrens 			(void) printf("%s", zfs_prop_column_name(fields[i]));
1107fa9e4066Sahrens 		else	/* LINTED - format specifier */
1108fa9e4066Sahrens 			(void) printf(zfs_prop_column_format(fields[i]),
1109fa9e4066Sahrens 			    zfs_prop_column_name(fields[i]));
1110fa9e4066Sahrens 	}
1111fa9e4066Sahrens 
1112fa9e4066Sahrens 	(void) printf("\n");
1113fa9e4066Sahrens }
1114fa9e4066Sahrens 
1115fa9e4066Sahrens /*
1116fa9e4066Sahrens  * Given a dataset and a list of fields, print out all the properties according
1117fa9e4066Sahrens  * to the described layout.
1118fa9e4066Sahrens  */
1119fa9e4066Sahrens static void
112007ba0419Seschrock print_dataset(zfs_handle_t *zhp, zfs_prop_t *fields, size_t count, int scripted)
1121fa9e4066Sahrens {
1122fa9e4066Sahrens 	int i;
1123fa9e4066Sahrens 	char property[ZFS_MAXPROPLEN];
1124fa9e4066Sahrens 
1125fa9e4066Sahrens 	for (i = 0; i < count; i++) {
1126fa9e4066Sahrens 		if (i != 0) {
1127fa9e4066Sahrens 			if (scripted)
1128fa9e4066Sahrens 				(void) printf("\t");
1129fa9e4066Sahrens 			else
1130fa9e4066Sahrens 				(void) printf("  ");
1131fa9e4066Sahrens 		}
1132fa9e4066Sahrens 
1133fa9e4066Sahrens 		if (zfs_prop_get(zhp, fields[i], property,
1134fa9e4066Sahrens 		    sizeof (property), NULL, NULL, 0, FALSE) != 0)
1135fa9e4066Sahrens 			(void) strlcpy(property, "-", sizeof (property));
1136fa9e4066Sahrens 
113707ba0419Seschrock 		/*
113807ba0419Seschrock 		 * If this is being called in scripted mode, or if this is the
113907ba0419Seschrock 		 * last column and it is left-justified, don't include a width
114007ba0419Seschrock 		 * format specifier.
114107ba0419Seschrock 		 */
114207ba0419Seschrock 		if (scripted || (i == count - 1 &&
114307ba0419Seschrock 		    strchr(zfs_prop_column_format(fields[i]), '-') != NULL))
1144fa9e4066Sahrens 			(void) printf("%s", property);
1145fa9e4066Sahrens 		else	/* LINTED - format specifier */
1146fa9e4066Sahrens 			(void) printf(zfs_prop_column_format(fields[i]),
1147fa9e4066Sahrens 			    property);
1148fa9e4066Sahrens 	}
1149fa9e4066Sahrens 
1150fa9e4066Sahrens 	(void) printf("\n");
1151fa9e4066Sahrens }
1152fa9e4066Sahrens 
1153fa9e4066Sahrens /*
1154fa9e4066Sahrens  * Generic callback function to list a dataset or snapshot.
1155fa9e4066Sahrens  */
1156fa9e4066Sahrens static int
1157fa9e4066Sahrens list_callback(zfs_handle_t *zhp, void *data)
1158fa9e4066Sahrens {
1159fa9e4066Sahrens 	list_cbdata_t *cbp = data;
1160fa9e4066Sahrens 
1161fa9e4066Sahrens 	if (cbp->cb_first) {
1162fa9e4066Sahrens 		if (!cbp->cb_scripted)
1163fa9e4066Sahrens 			print_header(cbp->cb_fields, cbp->cb_fieldcount);
1164fa9e4066Sahrens 		cbp->cb_first = FALSE;
1165fa9e4066Sahrens 	}
1166fa9e4066Sahrens 
1167fa9e4066Sahrens 	print_dataset(zhp, cbp->cb_fields, cbp->cb_fieldcount,
1168fa9e4066Sahrens 	    cbp->cb_scripted);
1169fa9e4066Sahrens 
1170fa9e4066Sahrens 	return (0);
1171fa9e4066Sahrens }
1172fa9e4066Sahrens 
1173fa9e4066Sahrens static int
1174fa9e4066Sahrens zfs_do_list(int argc, char **argv)
1175fa9e4066Sahrens {
1176fa9e4066Sahrens 	int c;
1177fa9e4066Sahrens 	int recurse = 0;
1178fa9e4066Sahrens 	int scripted = FALSE;
1179fa9e4066Sahrens 	static char default_fields[] =
1180fa9e4066Sahrens 	    "name,used,available,referenced,mountpoint";
1181fa9e4066Sahrens 	int types = ZFS_TYPE_ANY;
1182fa9e4066Sahrens 	char *fields = NULL;
1183fa9e4066Sahrens 	char *basic_fields = default_fields;
1184fa9e4066Sahrens 	list_cbdata_t cb = { 0 };
1185fa9e4066Sahrens 	char *value;
1186fa9e4066Sahrens 	int ret;
1187fa9e4066Sahrens 	char *type_subopts[] = { "filesystem", "volume", "snapshot", NULL };
118807ba0419Seschrock 	char *badopt;
118907ba0419Seschrock 	int alloffset;
1190fa9e4066Sahrens 
1191fa9e4066Sahrens 	/* check options */
1192fa9e4066Sahrens 	while ((c = getopt(argc, argv, ":o:rt:H")) != -1) {
1193fa9e4066Sahrens 		switch (c) {
1194fa9e4066Sahrens 		case 'o':
1195fa9e4066Sahrens 			fields = optarg;
1196fa9e4066Sahrens 			break;
1197fa9e4066Sahrens 		case 'r':
1198fa9e4066Sahrens 			recurse = TRUE;
1199fa9e4066Sahrens 			break;
1200fa9e4066Sahrens 		case 'H':
1201fa9e4066Sahrens 			scripted = TRUE;
1202fa9e4066Sahrens 			break;
1203fa9e4066Sahrens 		case 't':
1204fa9e4066Sahrens 			types = 0;
1205fa9e4066Sahrens 			while (*optarg != '\0') {
1206fa9e4066Sahrens 				switch (getsubopt(&optarg, type_subopts,
1207fa9e4066Sahrens 				    &value)) {
1208fa9e4066Sahrens 				case 0:
1209fa9e4066Sahrens 					types |= ZFS_TYPE_FILESYSTEM;
1210fa9e4066Sahrens 					break;
1211fa9e4066Sahrens 				case 1:
1212fa9e4066Sahrens 					types |= ZFS_TYPE_VOLUME;
1213fa9e4066Sahrens 					break;
1214fa9e4066Sahrens 				case 2:
1215fa9e4066Sahrens 					types |= ZFS_TYPE_SNAPSHOT;
1216fa9e4066Sahrens 					break;
1217fa9e4066Sahrens 				default:
1218fa9e4066Sahrens 					(void) fprintf(stderr,
1219fa9e4066Sahrens 					    gettext("invalid type '%s'\n"),
1220fa9e4066Sahrens 					    value);
1221fa9e4066Sahrens 					usage(FALSE);
1222fa9e4066Sahrens 				}
1223fa9e4066Sahrens 			}
1224fa9e4066Sahrens 			break;
1225fa9e4066Sahrens 		case ':':
1226fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing argument for "
1227fa9e4066Sahrens 			    "'%c' option\n"), optopt);
1228fa9e4066Sahrens 			usage(FALSE);
1229fa9e4066Sahrens 			break;
1230fa9e4066Sahrens 		case '?':
1231fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
1232fa9e4066Sahrens 			    optopt);
1233fa9e4066Sahrens 			usage(FALSE);
1234fa9e4066Sahrens 		}
1235fa9e4066Sahrens 	}
1236fa9e4066Sahrens 
1237fa9e4066Sahrens 	argc -= optind;
1238fa9e4066Sahrens 	argv += optind;
1239fa9e4066Sahrens 
1240fa9e4066Sahrens 	if (fields == NULL)
1241fa9e4066Sahrens 		fields = basic_fields;
1242fa9e4066Sahrens 
124307ba0419Seschrock 	/*
124407ba0419Seschrock 	 * If the user specifies '-o all', the zfs_get_proplist() doesn't
124507ba0419Seschrock 	 * normally include the name of the dataset.  For 'zfs list', we always
124607ba0419Seschrock 	 * want this property to be first.
124707ba0419Seschrock 	 */
124807ba0419Seschrock 	if (strcmp(fields, "all") == 0) {
124907ba0419Seschrock 		cb.cb_fields[0] = ZFS_PROP_NAME;
125007ba0419Seschrock 		alloffset = 1;
125107ba0419Seschrock 	} else {
125207ba0419Seschrock 		alloffset = 0;
1253fa9e4066Sahrens 	}
1254fa9e4066Sahrens 
125507ba0419Seschrock 	if ((ret = zfs_get_proplist(fields, cb.cb_fields + alloffset,
125607ba0419Seschrock 	    ZFS_NPROP_ALL - alloffset, &cb.cb_fieldcount, &badopt)) != 0) {
125707ba0419Seschrock 		if (ret == EINVAL)
1258fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid property "
125907ba0419Seschrock 			    "'%s'\n"), badopt);
126007ba0419Seschrock 		else
126107ba0419Seschrock 			(void) fprintf(stderr, gettext("too many properties "
126207ba0419Seschrock 			    "specified\n"));
1263fa9e4066Sahrens 		usage(FALSE);
1264fa9e4066Sahrens 	}
1265fa9e4066Sahrens 
126607ba0419Seschrock 	cb.cb_fieldcount += alloffset;
1267fa9e4066Sahrens 	cb.cb_scripted = scripted;
1268fa9e4066Sahrens 	cb.cb_first = TRUE;
1269fa9e4066Sahrens 
1270fa9e4066Sahrens 	ret = zfs_for_each(argc, argv, recurse, types, list_callback, &cb);
1271fa9e4066Sahrens 
1272fa9e4066Sahrens 	if (ret == 0 && cb.cb_first == TRUE)
1273fa9e4066Sahrens 		(void) printf(gettext("no datasets available\n"));
1274fa9e4066Sahrens 
1275fa9e4066Sahrens 	return (ret);
1276fa9e4066Sahrens }
1277fa9e4066Sahrens 
1278fa9e4066Sahrens /*
1279fa9e4066Sahrens  * zfs rename <fs | snap | vol> <fs | snap | vol>
1280fa9e4066Sahrens  *
1281fa9e4066Sahrens  * Renames the given dataset to another of the same type.
1282fa9e4066Sahrens  */
1283fa9e4066Sahrens /* ARGSUSED */
1284fa9e4066Sahrens static int
1285fa9e4066Sahrens zfs_do_rename(int argc, char **argv)
1286fa9e4066Sahrens {
1287fa9e4066Sahrens 	zfs_handle_t *zhp;
1288fa9e4066Sahrens 	int ret = 1;
1289fa9e4066Sahrens 
1290fa9e4066Sahrens 	/* check options */
1291fa9e4066Sahrens 	if (argc > 1 && argv[1][0] == '-') {
1292fa9e4066Sahrens 		(void) fprintf(stderr, gettext("invalid option '%c'\n"),
1293fa9e4066Sahrens 		    argv[1][1]);
1294fa9e4066Sahrens 		usage(FALSE);
1295fa9e4066Sahrens 	}
1296fa9e4066Sahrens 
1297fa9e4066Sahrens 	/* check number of arguments */
1298fa9e4066Sahrens 	if (argc < 2) {
1299fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing source dataset "
1300fa9e4066Sahrens 		    "argument\n"));
1301fa9e4066Sahrens 		usage(FALSE);
1302fa9e4066Sahrens 	}
1303fa9e4066Sahrens 	if (argc < 3) {
1304fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing target dataset "
1305fa9e4066Sahrens 		    "argument\n"));
1306fa9e4066Sahrens 		usage(FALSE);
1307fa9e4066Sahrens 	}
1308fa9e4066Sahrens 	if (argc > 3) {
1309fa9e4066Sahrens 		(void) fprintf(stderr, gettext("too many arguments\n"));
1310fa9e4066Sahrens 		usage(FALSE);
1311fa9e4066Sahrens 	}
1312fa9e4066Sahrens 
1313fa9e4066Sahrens 	if ((zhp = zfs_open(argv[1], ZFS_TYPE_ANY)) == NULL)
1314fa9e4066Sahrens 		return (1);
1315fa9e4066Sahrens 
1316fa9e4066Sahrens 	if (zfs_rename(zhp, argv[2]) != 0)
1317fa9e4066Sahrens 		goto error;
1318fa9e4066Sahrens 
1319fa9e4066Sahrens 	ret = 0;
1320fa9e4066Sahrens error:
1321fa9e4066Sahrens 	zfs_close(zhp);
1322fa9e4066Sahrens 	return (ret);
1323fa9e4066Sahrens }
1324fa9e4066Sahrens 
1325fa9e4066Sahrens /*
1326fa9e4066Sahrens  * zfs rollback [-rfR] <snapshot>
1327fa9e4066Sahrens  *
1328fa9e4066Sahrens  * 	-r	Delete any intervening snapshots before doing rollback
1329fa9e4066Sahrens  * 	-R	Delete any snapshots and their clones
1330fa9e4066Sahrens  * 	-f	Force unmount filesystems, even if they are in use.
1331fa9e4066Sahrens  *
1332fa9e4066Sahrens  * Given a filesystem, rollback to a specific snapshot, discarding any changes
1333fa9e4066Sahrens  * since then and making it the active dataset.  If more recent snapshots exist,
1334fa9e4066Sahrens  * the command will complain unless the '-r' flag is given.
1335fa9e4066Sahrens  */
1336fa9e4066Sahrens typedef struct rollback_cbdata {
1337fa9e4066Sahrens 	uint64_t	cb_create;
1338fa9e4066Sahrens 	int		cb_first;
1339fa9e4066Sahrens 	int		cb_doclones;
1340fa9e4066Sahrens 	char		*cb_target;
1341fa9e4066Sahrens 	int		cb_error;
1342fa9e4066Sahrens 	int		cb_recurse;
1343fa9e4066Sahrens 	int		cb_dependent;
1344fa9e4066Sahrens } rollback_cbdata_t;
1345fa9e4066Sahrens 
1346fa9e4066Sahrens /*
1347fa9e4066Sahrens  * Report any snapshots more recent than the one specified.  Used when '-r' is
1348fa9e4066Sahrens  * not specified.  We reuse this same callback for the snapshot dependents - if
1349fa9e4066Sahrens  * 'cb_dependent' is set, then this is a dependent and we should report it
1350fa9e4066Sahrens  * without checking the transaction group.
1351fa9e4066Sahrens  */
1352fa9e4066Sahrens static int
1353fa9e4066Sahrens rollback_check(zfs_handle_t *zhp, void *data)
1354fa9e4066Sahrens {
1355fa9e4066Sahrens 	rollback_cbdata_t *cbp = data;
1356fa9e4066Sahrens 
1357fa9e4066Sahrens 	if (cbp->cb_doclones)
1358fa9e4066Sahrens 		return (0);
1359fa9e4066Sahrens 
1360fa9e4066Sahrens 	if (!cbp->cb_dependent) {
1361fa9e4066Sahrens 		if (strcmp(zfs_get_name(zhp), cbp->cb_target) != 0 &&
1362b12a1c38Slling 		    zfs_get_type(zhp) == ZFS_TYPE_SNAPSHOT &&
1363fa9e4066Sahrens 		    zfs_prop_get_int(zhp, ZFS_PROP_CREATETXG) >
1364fa9e4066Sahrens 		    cbp->cb_create) {
1365fa9e4066Sahrens 
1366fa9e4066Sahrens 			if (cbp->cb_first && !cbp->cb_recurse) {
1367fa9e4066Sahrens 				(void) fprintf(stderr, gettext("cannot "
1368fa9e4066Sahrens 				    "rollback to '%s': more recent snapshots "
1369fa9e4066Sahrens 				    "exist\n"),
1370fa9e4066Sahrens 				    cbp->cb_target);
1371fa9e4066Sahrens 				(void) fprintf(stderr, gettext("use '-r' to "
1372fa9e4066Sahrens 				    "force deletion of the following "
1373fa9e4066Sahrens 				    "snapshots:\n"));
1374fa9e4066Sahrens 				cbp->cb_first = 0;
1375fa9e4066Sahrens 				cbp->cb_error = 1;
1376fa9e4066Sahrens 			}
1377fa9e4066Sahrens 
1378fa9e4066Sahrens 			if (cbp->cb_recurse) {
1379fa9e4066Sahrens 				cbp->cb_dependent = TRUE;
1380fa9e4066Sahrens 				(void) zfs_iter_dependents(zhp, rollback_check,
1381fa9e4066Sahrens 				    cbp);
1382fa9e4066Sahrens 				cbp->cb_dependent = FALSE;
1383fa9e4066Sahrens 			} else {
1384fa9e4066Sahrens 				(void) fprintf(stderr, "%s\n",
1385fa9e4066Sahrens 				    zfs_get_name(zhp));
1386fa9e4066Sahrens 			}
1387fa9e4066Sahrens 		}
1388fa9e4066Sahrens 	} else {
1389fa9e4066Sahrens 		if (cbp->cb_first && cbp->cb_recurse) {
1390fa9e4066Sahrens 			(void) fprintf(stderr, gettext("cannot rollback to "
1391fa9e4066Sahrens 			    "'%s': clones of previous snapshots exist\n"),
1392fa9e4066Sahrens 			    cbp->cb_target);
1393fa9e4066Sahrens 			(void) fprintf(stderr, gettext("use '-R' to "
1394fa9e4066Sahrens 			    "force deletion of the following clones and "
1395fa9e4066Sahrens 			    "dependents:\n"));
1396fa9e4066Sahrens 			cbp->cb_first = 0;
1397fa9e4066Sahrens 			cbp->cb_error = 1;
1398fa9e4066Sahrens 		}
1399fa9e4066Sahrens 
1400fa9e4066Sahrens 		(void) fprintf(stderr, "%s\n", zfs_get_name(zhp));
1401fa9e4066Sahrens 	}
1402fa9e4066Sahrens 
1403fa9e4066Sahrens 	zfs_close(zhp);
1404fa9e4066Sahrens 	return (0);
1405fa9e4066Sahrens }
1406fa9e4066Sahrens 
1407fa9e4066Sahrens static int
1408fa9e4066Sahrens zfs_do_rollback(int argc, char **argv)
1409fa9e4066Sahrens {
1410fa9e4066Sahrens 	int ret;
1411fa9e4066Sahrens 	int c;
1412fa9e4066Sahrens 	rollback_cbdata_t cb = { 0 };
1413fa9e4066Sahrens 	zfs_handle_t *zhp, *snap;
1414fa9e4066Sahrens 	char parentname[ZFS_MAXNAMELEN];
1415fa9e4066Sahrens 	char *delim;
1416b12a1c38Slling 	int force = 0;
1417fa9e4066Sahrens 
1418fa9e4066Sahrens 	/* check options */
1419fa9e4066Sahrens 	while ((c = getopt(argc, argv, "rfR")) != -1) {
1420fa9e4066Sahrens 		switch (c) {
1421fa9e4066Sahrens 		case 'f':
1422b12a1c38Slling 			force = 1;
1423fa9e4066Sahrens 			break;
1424fa9e4066Sahrens 		case 'r':
1425fa9e4066Sahrens 			cb.cb_recurse = 1;
1426fa9e4066Sahrens 			break;
1427fa9e4066Sahrens 		case 'R':
1428fa9e4066Sahrens 			cb.cb_recurse = 1;
1429fa9e4066Sahrens 			cb.cb_doclones = 1;
1430fa9e4066Sahrens 			break;
1431fa9e4066Sahrens 		case '?':
1432fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
1433fa9e4066Sahrens 			    optopt);
1434fa9e4066Sahrens 			usage(FALSE);
1435fa9e4066Sahrens 		}
1436fa9e4066Sahrens 	}
1437fa9e4066Sahrens 
1438fa9e4066Sahrens 	argc -= optind;
1439fa9e4066Sahrens 	argv += optind;
1440fa9e4066Sahrens 
1441fa9e4066Sahrens 	/* check number of arguments */
1442fa9e4066Sahrens 	if (argc < 1) {
1443fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing dataset argument\n"));
1444fa9e4066Sahrens 		usage(FALSE);
1445fa9e4066Sahrens 	}
1446fa9e4066Sahrens 	if (argc > 1) {
1447fa9e4066Sahrens 		(void) fprintf(stderr, gettext("too many arguments\n"));
1448fa9e4066Sahrens 		usage(FALSE);
1449fa9e4066Sahrens 	}
1450fa9e4066Sahrens 
1451fa9e4066Sahrens 	/* open the snapshot */
1452b12a1c38Slling 	if ((snap = zfs_open(argv[0], ZFS_TYPE_SNAPSHOT)) == NULL)
1453fa9e4066Sahrens 		return (1);
1454fa9e4066Sahrens 
1455b12a1c38Slling 	/* open the parent dataset */
1456b12a1c38Slling 	(void) strlcpy(parentname, argv[0], sizeof (parentname));
1457fa9e4066Sahrens 	verify((delim = strrchr(parentname, '@')) != NULL);
1458fa9e4066Sahrens 	*delim = '\0';
1459fa9e4066Sahrens 	if ((zhp = zfs_open(parentname, ZFS_TYPE_ANY)) == NULL) {
1460fa9e4066Sahrens 		zfs_close(snap);
1461fa9e4066Sahrens 		return (1);
1462fa9e4066Sahrens 	}
1463fa9e4066Sahrens 
1464fa9e4066Sahrens 	/*
1465fa9e4066Sahrens 	 * Check for more recent snapshots and/or clones based on the presence
1466fa9e4066Sahrens 	 * of '-r' and '-R'.
1467fa9e4066Sahrens 	 */
1468b12a1c38Slling 	cb.cb_target = argv[0];
1469b12a1c38Slling 	cb.cb_create = zfs_prop_get_int(snap, ZFS_PROP_CREATETXG);
1470fa9e4066Sahrens 	cb.cb_first = 1;
1471fa9e4066Sahrens 	cb.cb_error = 0;
1472fa9e4066Sahrens 	(void) zfs_iter_children(zhp, rollback_check, &cb);
1473fa9e4066Sahrens 
1474fa9e4066Sahrens 	if ((ret = cb.cb_error) != 0)
1475fa9e4066Sahrens 		goto out;
1476fa9e4066Sahrens 
1477fa9e4066Sahrens 	/*
1478b12a1c38Slling 	 * Rollback parent to the given snapshot.
1479fa9e4066Sahrens 	 */
1480b12a1c38Slling 	ret = zfs_rollback(zhp, snap, force);
1481fa9e4066Sahrens 
1482fa9e4066Sahrens out:
1483fa9e4066Sahrens 	zfs_close(snap);
1484fa9e4066Sahrens 	zfs_close(zhp);
1485fa9e4066Sahrens 
1486fa9e4066Sahrens 	if (ret == 0)
1487fa9e4066Sahrens 		return (0);
1488fa9e4066Sahrens 	else
1489fa9e4066Sahrens 		return (1);
1490fa9e4066Sahrens }
1491fa9e4066Sahrens 
1492fa9e4066Sahrens /*
1493fa9e4066Sahrens  * zfs set property=value { fs | snap | vol } ...
1494fa9e4066Sahrens  *
1495fa9e4066Sahrens  * Sets the given property for all datasets specified on the command line.
1496fa9e4066Sahrens  */
1497fa9e4066Sahrens typedef struct set_cbdata {
1498fa9e4066Sahrens 	char		*cb_propname;
1499fa9e4066Sahrens 	char		*cb_value;
1500fa9e4066Sahrens 	zfs_prop_t	cb_prop;
1501fa9e4066Sahrens } set_cbdata_t;
1502fa9e4066Sahrens 
1503fa9e4066Sahrens static int
1504fa9e4066Sahrens set_callback(zfs_handle_t *zhp, void *data)
1505fa9e4066Sahrens {
1506fa9e4066Sahrens 	set_cbdata_t *cbp = data;
1507fa9e4066Sahrens 	int ret = 1;
1508fa9e4066Sahrens 
1509fa9e4066Sahrens 	/* don't allow setting of properties for snapshots */
1510fa9e4066Sahrens 	if (zfs_get_type(zhp) == ZFS_TYPE_SNAPSHOT) {
1511fa9e4066Sahrens 		(void) fprintf(stderr, gettext("cannot set %s property for "
1512fa9e4066Sahrens 		    "'%s': snapshot properties cannot be modified\n"),
1513fa9e4066Sahrens 		    cbp->cb_propname, zfs_get_name(zhp));
1514fa9e4066Sahrens 		return (1);
1515fa9e4066Sahrens 	}
1516fa9e4066Sahrens 
1517fa9e4066Sahrens 	/*
15185c5460e9Seschrock 	 * If we're changing the volsize, make sure the value is appropriate,
15195c5460e9Seschrock 	 * and set the reservation if this is a non-sparse volume.
1520fa9e4066Sahrens 	 */
1521fa9e4066Sahrens 	if (cbp->cb_prop == ZFS_PROP_VOLSIZE &&
15225c5460e9Seschrock 	    zfs_get_type(zhp) == ZFS_TYPE_VOLUME) {
1523fa9e4066Sahrens 		uint64_t volsize = zfs_prop_get_int(zhp, ZFS_PROP_VOLSIZE);
1524fa9e4066Sahrens 		uint64_t avail = zfs_prop_get_int(zhp, ZFS_PROP_AVAILABLE);
15255c5460e9Seschrock 		uint64_t reservation = zfs_prop_get_int(zhp,
15265c5460e9Seschrock 		    ZFS_PROP_RESERVATION);
15275c5460e9Seschrock 		uint64_t blocksize = zfs_prop_get_int(zhp,
15285c5460e9Seschrock 		    ZFS_PROP_VOLBLOCKSIZE);
1529fa9e4066Sahrens 		uint64_t value;
1530fa9e4066Sahrens 
1531fa9e4066Sahrens 		verify(zfs_nicestrtonum(cbp->cb_value, &value) == 0);
1532fa9e4066Sahrens 
15335c5460e9Seschrock 		if (value % blocksize != 0) {
15345c5460e9Seschrock 			char buf[64];
15355c5460e9Seschrock 
15365c5460e9Seschrock 			zfs_nicenum(blocksize, buf, sizeof (buf));
15375c5460e9Seschrock 			(void) fprintf(stderr, gettext("cannot set %s for "
15385c5460e9Seschrock 			    "'%s': must be a multiple of volume block size "
15395c5460e9Seschrock 			    "(%s)\n"), cbp->cb_propname, zfs_get_name(zhp),
15405c5460e9Seschrock 			    buf);
15415c5460e9Seschrock 			return (1);
15425c5460e9Seschrock 		}
15435c5460e9Seschrock 
15445c5460e9Seschrock 		if (value == 0) {
15455c5460e9Seschrock 			(void) fprintf(stderr, gettext("cannot set %s for "
15465c5460e9Seschrock 			    "'%s': cannot be zero\n"), cbp->cb_propname,
15475c5460e9Seschrock 			    zfs_get_name(zhp));
15485c5460e9Seschrock 			return (1);
15495c5460e9Seschrock 		}
15505c5460e9Seschrock 
15515c5460e9Seschrock 		if (volsize == reservation) {
1552fa9e4066Sahrens 			if (value > volsize && (value - volsize) > avail) {
1553fa9e4066Sahrens 				(void) fprintf(stderr, gettext("cannot set "
1554fa9e4066Sahrens 				    "%s property for '%s': volume size exceeds "
1555fa9e4066Sahrens 				    "amount of available space\n"),
1556fa9e4066Sahrens 				    cbp->cb_propname, zfs_get_name(zhp));
1557fa9e4066Sahrens 				return (1);
1558fa9e4066Sahrens 			}
1559fa9e4066Sahrens 
1560fa9e4066Sahrens 			if (zfs_prop_set(zhp, ZFS_PROP_RESERVATION,
1561fa9e4066Sahrens 			    cbp->cb_value) != 0) {
1562fa9e4066Sahrens 				(void) fprintf(stderr, gettext("volsize and "
1563fa9e4066Sahrens 				    "reservation must remain equal\n"));
1564fa9e4066Sahrens 				return (1);
1565fa9e4066Sahrens 			}
1566fa9e4066Sahrens 		}
15675c5460e9Seschrock 	}
1568fa9e4066Sahrens 
1569fa9e4066Sahrens 	/*
1570fa9e4066Sahrens 	 * Do not allow the reservation to be set above the volume size. We do
1571fa9e4066Sahrens 	 * this here instead of inside libzfs because libzfs violates this rule
1572fa9e4066Sahrens 	 * internally.
1573fa9e4066Sahrens 	 */
1574fa9e4066Sahrens 	if (cbp->cb_prop == ZFS_PROP_RESERVATION &&
1575fa9e4066Sahrens 	    zfs_get_type(zhp) == ZFS_TYPE_VOLUME) {
1576fa9e4066Sahrens 		uint64_t value;
1577fa9e4066Sahrens 		uint64_t volsize;
1578fa9e4066Sahrens 
1579fa9e4066Sahrens 		volsize = zfs_prop_get_int(zhp, ZFS_PROP_VOLSIZE);
1580fa9e4066Sahrens 		if (strcmp(cbp->cb_value, "none") == 0)
1581fa9e4066Sahrens 			value = 0;
1582fa9e4066Sahrens 		else
1583fa9e4066Sahrens 			verify(zfs_nicestrtonum(cbp->cb_value, &value) == 0);
1584fa9e4066Sahrens 
1585fa9e4066Sahrens 		if (value > volsize) {
1586fa9e4066Sahrens 			(void) fprintf(stderr, gettext("cannot set %s "
1587fa9e4066Sahrens 			    "for '%s': size is greater than current "
1588fa9e4066Sahrens 			    "volume size\n"), cbp->cb_propname,
1589fa9e4066Sahrens 			    zfs_get_name(zhp));
1590fa9e4066Sahrens 			return (-1);
1591fa9e4066Sahrens 		}
1592fa9e4066Sahrens 	}
1593fa9e4066Sahrens 
1594fa9e4066Sahrens 	if (zfs_prop_set(zhp, cbp->cb_prop, cbp->cb_value) != 0)
1595fa9e4066Sahrens 		return (1);
1596fa9e4066Sahrens 
1597fa9e4066Sahrens 	ret = 0;
1598fa9e4066Sahrens error:
1599fa9e4066Sahrens 	return (ret);
1600fa9e4066Sahrens }
1601fa9e4066Sahrens 
1602fa9e4066Sahrens static int
1603fa9e4066Sahrens zfs_do_set(int argc, char **argv)
1604fa9e4066Sahrens {
1605fa9e4066Sahrens 	set_cbdata_t cb;
1606fa9e4066Sahrens 
1607fa9e4066Sahrens 	/* check for options */
1608fa9e4066Sahrens 	if (argc > 1 && argv[1][0] == '-') {
1609fa9e4066Sahrens 		(void) fprintf(stderr, gettext("invalid option '%c'\n"),
1610fa9e4066Sahrens 		    argv[1][1]);
1611fa9e4066Sahrens 		usage(FALSE);
1612fa9e4066Sahrens 	}
1613fa9e4066Sahrens 
1614fa9e4066Sahrens 	/* check number of arguments */
1615fa9e4066Sahrens 	if (argc < 2) {
1616fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing property=value "
1617fa9e4066Sahrens 		    "argument\n"));
1618fa9e4066Sahrens 		usage(FALSE);
1619fa9e4066Sahrens 	}
1620fa9e4066Sahrens 	if (argc < 3) {
1621fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing dataset name\n"));
1622fa9e4066Sahrens 		usage(FALSE);
1623fa9e4066Sahrens 	}
1624fa9e4066Sahrens 
1625fa9e4066Sahrens 	/* validate property=value argument */
1626fa9e4066Sahrens 	cb.cb_propname = argv[1];
1627fa9e4066Sahrens 	if ((cb.cb_value = strchr(cb.cb_propname, '=')) == NULL) {
1628fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing value in "
1629fa9e4066Sahrens 		    "property=value argument\n"));
1630fa9e4066Sahrens 		usage(FALSE);
1631fa9e4066Sahrens 	}
1632fa9e4066Sahrens 
1633fa9e4066Sahrens 	*cb.cb_value = '\0';
1634fa9e4066Sahrens 	cb.cb_value++;
1635fa9e4066Sahrens 
1636fa9e4066Sahrens 	if (*cb.cb_propname == '\0') {
1637fa9e4066Sahrens 		(void) fprintf(stderr,
1638fa9e4066Sahrens 		    gettext("missing property in property=value argument\n"));
1639fa9e4066Sahrens 		usage(FALSE);
1640fa9e4066Sahrens 	}
1641fa9e4066Sahrens 	if (*cb.cb_value == '\0') {
1642fa9e4066Sahrens 		(void) fprintf(stderr,
1643fa9e4066Sahrens 		    gettext("missing value in property=value argument\n"));
1644fa9e4066Sahrens 		usage(FALSE);
1645fa9e4066Sahrens 	}
1646fa9e4066Sahrens 
1647fa9e4066Sahrens 	/* get the property type */
1648fa9e4066Sahrens 	if ((cb.cb_prop = zfs_name_to_prop(cb.cb_propname)) ==
1649fa9e4066Sahrens 	    ZFS_PROP_INVAL) {
1650fa9e4066Sahrens 		(void) fprintf(stderr,
1651fa9e4066Sahrens 		    gettext("invalid property '%s'\n"), cb.cb_propname);
1652fa9e4066Sahrens 		usage(FALSE);
1653fa9e4066Sahrens 	}
1654fa9e4066Sahrens 
1655fa9e4066Sahrens 	/*
1656fa9e4066Sahrens 	 * Validate that the value is appropriate for this property.  We do this
1657fa9e4066Sahrens 	 * once now so we don't generate multiple errors each time we try to
1658fa9e4066Sahrens 	 * apply it to a dataset.
1659fa9e4066Sahrens 	 */
1660fa9e4066Sahrens 	if (zfs_prop_validate(cb.cb_prop, cb.cb_value, NULL) != 0)
1661fa9e4066Sahrens 		return (1);
1662fa9e4066Sahrens 
1663fa9e4066Sahrens 	return (zfs_for_each(argc - 2, argv + 2, FALSE,
1664fa9e4066Sahrens 	    ZFS_TYPE_ANY, set_callback, &cb));
1665fa9e4066Sahrens }
1666fa9e4066Sahrens 
1667fa9e4066Sahrens /*
1668fa9e4066Sahrens  * zfs snapshot <fs@snap>
1669fa9e4066Sahrens  *
1670fa9e4066Sahrens  * Creates a snapshot with the given name.  While functionally equivalent to
1671fa9e4066Sahrens  * 'zfs create', it is a separate command to diffferentiate intent.
1672fa9e4066Sahrens  */
1673fa9e4066Sahrens static int
1674fa9e4066Sahrens zfs_do_snapshot(int argc, char **argv)
1675fa9e4066Sahrens {
1676fa9e4066Sahrens 	/* check options */
1677fa9e4066Sahrens 	if (argc > 1 && argv[1][0] == '-') {
1678fa9e4066Sahrens 		(void) fprintf(stderr, gettext("invalid option '%c'\n"),
1679fa9e4066Sahrens 		    argv[1][1]);
1680fa9e4066Sahrens 		usage(FALSE);
1681fa9e4066Sahrens 	}
1682fa9e4066Sahrens 
1683fa9e4066Sahrens 	/* check number of arguments */
1684fa9e4066Sahrens 	if (argc < 2) {
1685fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing snapshot argument\n"));
1686fa9e4066Sahrens 		usage(FALSE);
1687fa9e4066Sahrens 	}
1688fa9e4066Sahrens 	if (argc > 2) {
1689fa9e4066Sahrens 		(void) fprintf(stderr, gettext("too many arguments\n"));
1690fa9e4066Sahrens 		usage(FALSE);
1691fa9e4066Sahrens 	}
1692fa9e4066Sahrens 
1693fa9e4066Sahrens 	return (zfs_snapshot(argv[1]) != 0);
1694fa9e4066Sahrens }
1695fa9e4066Sahrens 
1696fa9e4066Sahrens /*
1697fa9e4066Sahrens  * zfs backup [-i <fs@snap>] <fs@snap>
1698fa9e4066Sahrens  *
1699fa9e4066Sahrens  * Send a backup stream to stdout.
1700fa9e4066Sahrens  */
1701fa9e4066Sahrens static int
1702fa9e4066Sahrens zfs_do_backup(int argc, char **argv)
1703fa9e4066Sahrens {
1704fa9e4066Sahrens 	char *fromname = NULL;
1705fa9e4066Sahrens 	zfs_handle_t *zhp_from = NULL, *zhp_to;
1706fa9e4066Sahrens 	int c, err;
1707fa9e4066Sahrens 
1708fa9e4066Sahrens 	/* check options */
1709fa9e4066Sahrens 	while ((c = getopt(argc, argv, ":i:")) != -1) {
1710fa9e4066Sahrens 		switch (c) {
1711fa9e4066Sahrens 		case 'i':
1712fa9e4066Sahrens 			fromname = optarg;
1713fa9e4066Sahrens 			break;
1714fa9e4066Sahrens 		case ':':
1715fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing argument for "
1716fa9e4066Sahrens 			    "'%c' option\n"), optopt);
1717fa9e4066Sahrens 			usage(FALSE);
1718fa9e4066Sahrens 			break;
1719fa9e4066Sahrens 		case '?':
1720fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
1721fa9e4066Sahrens 			    optopt);
1722fa9e4066Sahrens 			usage(FALSE);
1723fa9e4066Sahrens 		}
1724fa9e4066Sahrens 	}
1725fa9e4066Sahrens 
1726fa9e4066Sahrens 	argc -= optind;
1727fa9e4066Sahrens 	argv += optind;
1728fa9e4066Sahrens 
1729fa9e4066Sahrens 	/* check number of arguments */
1730fa9e4066Sahrens 	if (argc < 1) {
1731fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing snapshot argument\n"));
1732fa9e4066Sahrens 		usage(FALSE);
1733fa9e4066Sahrens 	}
1734fa9e4066Sahrens 	if (argc > 1) {
1735fa9e4066Sahrens 		(void) fprintf(stderr, gettext("too many arguments\n"));
1736fa9e4066Sahrens 		usage(FALSE);
1737fa9e4066Sahrens 	}
1738fa9e4066Sahrens 
1739fa9e4066Sahrens 	if (isatty(STDOUT_FILENO)) {
1740fa9e4066Sahrens 		(void) fprintf(stderr,
1741fa9e4066Sahrens 		    gettext("Error: Backup stream can not be written "
1742fa9e4066Sahrens 			    "to a terminal.\n"
1743fa9e4066Sahrens 			    "You must redirect standard output.\n"));
1744fa9e4066Sahrens 		return (1);
1745fa9e4066Sahrens 	}
1746fa9e4066Sahrens 
1747fa9e4066Sahrens 	if (fromname) {
1748fa9e4066Sahrens 		if ((zhp_from = zfs_open(fromname, ZFS_TYPE_SNAPSHOT)) == NULL)
1749fa9e4066Sahrens 			return (1);
1750fa9e4066Sahrens 	}
1751fa9e4066Sahrens 	if ((zhp_to = zfs_open(argv[0], ZFS_TYPE_SNAPSHOT)) == NULL)
1752fa9e4066Sahrens 		return (1);
1753fa9e4066Sahrens 
1754fa9e4066Sahrens 	err = zfs_backup(zhp_to, zhp_from);
1755fa9e4066Sahrens 
1756fa9e4066Sahrens 	if (zhp_from)
1757fa9e4066Sahrens 		zfs_close(zhp_from);
1758fa9e4066Sahrens 	zfs_close(zhp_to);
1759fa9e4066Sahrens 
1760fa9e4066Sahrens 	return (err != 0);
1761fa9e4066Sahrens }
1762fa9e4066Sahrens 
1763fa9e4066Sahrens /*
1764fa9e4066Sahrens  * zfs restore <fs@snap>
1765fa9e4066Sahrens  *
1766fa9e4066Sahrens  * Restore a backup stream from stdin.
1767fa9e4066Sahrens  */
1768fa9e4066Sahrens static int
1769fa9e4066Sahrens zfs_do_restore(int argc, char **argv)
1770fa9e4066Sahrens {
1771fa9e4066Sahrens 	int c, err;
1772fa9e4066Sahrens 	int isprefix = FALSE;
1773fa9e4066Sahrens 	int dryrun = FALSE;
1774fa9e4066Sahrens 	int verbose = FALSE;
1775fa9e4066Sahrens 
1776fa9e4066Sahrens 	/* check options */
1777fa9e4066Sahrens 	while ((c = getopt(argc, argv, ":dnv")) != -1) {
1778fa9e4066Sahrens 		switch (c) {
1779fa9e4066Sahrens 		case 'd':
1780fa9e4066Sahrens 			isprefix = TRUE;
1781fa9e4066Sahrens 			break;
1782fa9e4066Sahrens 		case 'n':
1783fa9e4066Sahrens 			dryrun = TRUE;
1784fa9e4066Sahrens 			break;
1785fa9e4066Sahrens 		case 'v':
1786fa9e4066Sahrens 			verbose = TRUE;
1787fa9e4066Sahrens 			break;
1788fa9e4066Sahrens 		case ':':
1789fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing argument for "
1790fa9e4066Sahrens 			    "'%c' option\n"), optopt);
1791fa9e4066Sahrens 			usage(FALSE);
1792fa9e4066Sahrens 			break;
1793fa9e4066Sahrens 		case '?':
1794fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
1795fa9e4066Sahrens 			    optopt);
1796fa9e4066Sahrens 			usage(FALSE);
1797fa9e4066Sahrens 		}
1798fa9e4066Sahrens 	}
1799fa9e4066Sahrens 
1800fa9e4066Sahrens 	argc -= optind;
1801fa9e4066Sahrens 	argv += optind;
1802fa9e4066Sahrens 
1803fa9e4066Sahrens 	/* check number of arguments */
1804fa9e4066Sahrens 	if (argc < 1) {
1805fa9e4066Sahrens 		(void) fprintf(stderr, gettext("missing snapshot argument\n"));
1806fa9e4066Sahrens 		usage(FALSE);
1807fa9e4066Sahrens 	}
1808fa9e4066Sahrens 	if (argc > 1) {
1809fa9e4066Sahrens 		(void) fprintf(stderr, gettext("too many arguments\n"));
1810fa9e4066Sahrens 		usage(FALSE);
1811fa9e4066Sahrens 	}
1812fa9e4066Sahrens 
1813fa9e4066Sahrens 	if (isatty(STDIN_FILENO)) {
1814fa9e4066Sahrens 		(void) fprintf(stderr,
1815fa9e4066Sahrens 		    gettext("Error: Backup stream can not be read "
1816fa9e4066Sahrens 			    "from a terminal.\n"
1817fa9e4066Sahrens 			    "You must redirect standard input.\n"));
1818fa9e4066Sahrens 		return (1);
1819fa9e4066Sahrens 	}
1820fa9e4066Sahrens 
1821fa9e4066Sahrens 	err = zfs_restore(argv[0], isprefix, verbose, dryrun);
1822fa9e4066Sahrens 	return (err != 0);
1823fa9e4066Sahrens }
1824fa9e4066Sahrens 
18257f7322feSeschrock typedef struct get_all_cbdata {
18267f7322feSeschrock 	zfs_handle_t	**cb_handles;
18277f7322feSeschrock 	size_t		cb_alloc;
18287f7322feSeschrock 	size_t		cb_used;
18297f7322feSeschrock } get_all_cbdata_t;
18307f7322feSeschrock 
18317f7322feSeschrock static int
18327f7322feSeschrock get_one_filesystem(zfs_handle_t *zhp, void *data)
18337f7322feSeschrock {
18347f7322feSeschrock 	get_all_cbdata_t *cbp = data;
18357f7322feSeschrock 
18367f7322feSeschrock 	/*
18377f7322feSeschrock 	 * Skip any zvols
18387f7322feSeschrock 	 */
18397f7322feSeschrock 	if (zfs_get_type(zhp) != ZFS_TYPE_FILESYSTEM) {
18407f7322feSeschrock 		zfs_close(zhp);
18417f7322feSeschrock 		return (0);
18427f7322feSeschrock 	}
18437f7322feSeschrock 
18447f7322feSeschrock 	if (cbp->cb_alloc == cbp->cb_used) {
18457f7322feSeschrock 		zfs_handle_t **handles;
18467f7322feSeschrock 
18477f7322feSeschrock 		if (cbp->cb_alloc == 0)
18487f7322feSeschrock 			cbp->cb_alloc = 64;
18497f7322feSeschrock 		else
18507f7322feSeschrock 			cbp->cb_alloc *= 2;
18517f7322feSeschrock 
18527f7322feSeschrock 		handles = safe_malloc(cbp->cb_alloc * sizeof (void *));
18537f7322feSeschrock 
18547f7322feSeschrock 		if (cbp->cb_handles) {
18557f7322feSeschrock 			bcopy(cbp->cb_handles, handles,
18567f7322feSeschrock 			    cbp->cb_used * sizeof (void *));
18577f7322feSeschrock 			free(cbp->cb_handles);
18587f7322feSeschrock 		}
18597f7322feSeschrock 
18607f7322feSeschrock 		cbp->cb_handles = handles;
18617f7322feSeschrock 	}
18627f7322feSeschrock 
18637f7322feSeschrock 	cbp->cb_handles[cbp->cb_used++] = zhp;
18647f7322feSeschrock 
18657f7322feSeschrock 	return (zfs_iter_filesystems(zhp, get_one_filesystem, data));
18667f7322feSeschrock }
18677f7322feSeschrock 
18687f7322feSeschrock static void
18697f7322feSeschrock get_all_filesystems(zfs_handle_t ***fslist, size_t *count)
18707f7322feSeschrock {
18717f7322feSeschrock 	get_all_cbdata_t cb = { 0 };
18727f7322feSeschrock 
18737f7322feSeschrock 	(void) zfs_iter_root(get_one_filesystem, &cb);
18747f7322feSeschrock 
18757f7322feSeschrock 	*fslist = cb.cb_handles;
18767f7322feSeschrock 	*count = cb.cb_used;
18777f7322feSeschrock }
18787f7322feSeschrock 
18797f7322feSeschrock static int
18807f7322feSeschrock mountpoint_compare(const void *a, const void *b)
18817f7322feSeschrock {
18827f7322feSeschrock 	zfs_handle_t **za = (zfs_handle_t **)a;
18837f7322feSeschrock 	zfs_handle_t **zb = (zfs_handle_t **)b;
18847f7322feSeschrock 	char mounta[MAXPATHLEN];
18857f7322feSeschrock 	char mountb[MAXPATHLEN];
18867f7322feSeschrock 
18877f7322feSeschrock 	verify(zfs_prop_get(*za, ZFS_PROP_MOUNTPOINT, mounta,
18887f7322feSeschrock 	    sizeof (mounta), NULL, NULL, 0, FALSE) == 0);
18897f7322feSeschrock 	verify(zfs_prop_get(*zb, ZFS_PROP_MOUNTPOINT, mountb,
18907f7322feSeschrock 	    sizeof (mountb), NULL, NULL, 0, FALSE) == 0);
18917f7322feSeschrock 
18927f7322feSeschrock 	return (strcmp(mounta, mountb));
18937f7322feSeschrock }
1894fa9e4066Sahrens 
1895fa9e4066Sahrens /*
1896fa9e4066Sahrens  * Generic callback for sharing or mounting filesystems.  Because the code is so
1897fa9e4066Sahrens  * similar, we have a common function with an extra parameter to determine which
1898fa9e4066Sahrens  * mode we are using.
1899fa9e4066Sahrens  */
1900fa9e4066Sahrens #define	OP_SHARE	0x1
1901fa9e4066Sahrens #define	OP_MOUNT	0x2
1902fa9e4066Sahrens 
1903fa9e4066Sahrens typedef struct share_mount_cbdata {
1904fa9e4066Sahrens 	int	cb_type;
1905fa9e4066Sahrens 	int	cb_explicit;
1906fa9e4066Sahrens 	int	cb_flags;
1907fa9e4066Sahrens 	const char *cb_options;
1908fa9e4066Sahrens } share_mount_cbdata_t;
1909fa9e4066Sahrens 
1910fa9e4066Sahrens /*
1911fa9e4066Sahrens  * Share or mount the filesystem.
1912fa9e4066Sahrens  */
1913fa9e4066Sahrens static int
1914fa9e4066Sahrens share_mount_callback(zfs_handle_t *zhp, void *data)
1915fa9e4066Sahrens {
1916fa9e4066Sahrens 	char mountpoint[ZFS_MAXPROPLEN];
1917fa9e4066Sahrens 	char shareopts[ZFS_MAXPROPLEN];
1918fa9e4066Sahrens 	share_mount_cbdata_t *cbp = data;
1919fa9e4066Sahrens 	const char *cmdname = cbp->cb_type == OP_SHARE ? "share" : "mount";
1920fa9e4066Sahrens 	struct mnttab mnt;
1921fa9e4066Sahrens 	uint64_t zoned;
1922fa9e4066Sahrens 
1923fa9e4066Sahrens 	if (cbp->cb_options == NULL)
1924fa9e4066Sahrens 		mnt.mnt_mntopts = "";
1925fa9e4066Sahrens 	else
1926fa9e4066Sahrens 		mnt.mnt_mntopts = (char *)cbp->cb_options;
1927fa9e4066Sahrens 
1928fa9e4066Sahrens 	/*
1929fa9e4066Sahrens 	 * Check to make sure we can mount/share this dataset.  If we are in the
1930fa9e4066Sahrens 	 * global zone and the filesystem is exported to a local zone, or if we
1931fa9e4066Sahrens 	 * are in a local zone and the filesystem is not exported, then it is an
1932fa9e4066Sahrens 	 * error.
1933fa9e4066Sahrens 	 */
1934fa9e4066Sahrens 	zoned = zfs_prop_get_int(zhp, ZFS_PROP_ZONED);
1935fa9e4066Sahrens 
1936fa9e4066Sahrens 	if (zoned && getzoneid() == GLOBAL_ZONEID) {
1937fa9e4066Sahrens 		if (!cbp->cb_explicit)
1938fa9e4066Sahrens 			return (0);
1939fa9e4066Sahrens 
1940fa9e4066Sahrens 		(void) fprintf(stderr, gettext("cannot %s '%s': dataset is "
1941fa9e4066Sahrens 		    "exported to a local zone\n"), cmdname, zfs_get_name(zhp));
1942fa9e4066Sahrens 		return (1);
1943fa9e4066Sahrens 
1944fa9e4066Sahrens 	} else if (!zoned && getzoneid() != GLOBAL_ZONEID) {
1945fa9e4066Sahrens 		if (!cbp->cb_explicit)
1946fa9e4066Sahrens 			return (0);
1947fa9e4066Sahrens 
1948fa9e4066Sahrens 		(void) fprintf(stderr, gettext("cannot %s '%s': permission "
1949fa9e4066Sahrens 		    "denied\n"), cmdname, zfs_get_name(zhp));
1950fa9e4066Sahrens 		return (1);
1951fa9e4066Sahrens 	}
1952fa9e4066Sahrens 
1953fa9e4066Sahrens 	/*
1954fa9e4066Sahrens 	 * Inore any filesystems which don't apply to us.  This includes those
1955fa9e4066Sahrens 	 * with a legacy mountpoint, or those with legacy share options.
1956fa9e4066Sahrens 	 */
1957fa9e4066Sahrens 	verify(zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint,
1958fa9e4066Sahrens 	    sizeof (mountpoint), NULL, NULL, 0, FALSE) == 0);
1959fa9e4066Sahrens 	verify(zfs_prop_get(zhp, ZFS_PROP_SHARENFS, shareopts,
1960fa9e4066Sahrens 	    sizeof (shareopts), NULL, NULL, 0, FALSE) == 0);
1961fa9e4066Sahrens 
1962fa9e4066Sahrens 	if (cbp->cb_type == OP_SHARE) {
1963fa9e4066Sahrens 		if (strcmp(shareopts, "off") == 0) {
1964fa9e4066Sahrens 			if (!cbp->cb_explicit)
1965fa9e4066Sahrens 				return (0);
1966fa9e4066Sahrens 
1967fa9e4066Sahrens 			(void) fprintf(stderr, gettext("cannot share '%s': "
1968fa9e4066Sahrens 			    "legacy share\n"), zfs_get_name(zhp));
1969fa9e4066Sahrens 			(void) fprintf(stderr, gettext("use share(1M) to "
1970fa9e4066Sahrens 			    "share this filesystem\n"));
1971fa9e4066Sahrens 			return (1);
1972fa9e4066Sahrens 		}
1973fa9e4066Sahrens 	}
1974fa9e4066Sahrens 
1975fa9e4066Sahrens 	/*
1976fa9e4066Sahrens 	 * We cannot share or mount legacy filesystems.  If the shareopts is
1977fa9e4066Sahrens 	 * non-legacy but the mountpoint is legacy, we treat it as a legacy
1978fa9e4066Sahrens 	 * share.
1979fa9e4066Sahrens 	 */
1980fa9e4066Sahrens 	if (strcmp(mountpoint, "legacy") == 0) {
1981fa9e4066Sahrens 		if (!cbp->cb_explicit)
1982fa9e4066Sahrens 			return (0);
1983fa9e4066Sahrens 
1984fa9e4066Sahrens 		(void) fprintf(stderr, gettext("cannot %s '%s': "
1985fa9e4066Sahrens 		    "legacy mountpoint\n"), cmdname, zfs_get_name(zhp));
1986fa9e4066Sahrens 		(void) fprintf(stderr, gettext("use %s to "
1987fa9e4066Sahrens 		    "%s this filesystem\n"), cbp->cb_type == OP_SHARE ?
1988fa9e4066Sahrens 		    "share(1M)" : "mount(1M)", cmdname);
1989fa9e4066Sahrens 		return (1);
1990fa9e4066Sahrens 	}
1991fa9e4066Sahrens 
1992fa9e4066Sahrens 	if (strcmp(mountpoint, "none") == 0) {
1993fa9e4066Sahrens 		if (!cbp->cb_explicit)
1994fa9e4066Sahrens 			return (0);
1995fa9e4066Sahrens 
1996fa9e4066Sahrens 		(void) fprintf(stderr, gettext("cannot %s '%s': no "
1997fa9e4066Sahrens 		    "mountpoint set\n"), cmdname, zfs_get_name(zhp));
1998fa9e4066Sahrens 		return (1);
1999fa9e4066Sahrens 	}
2000fa9e4066Sahrens 
2001fa9e4066Sahrens 	/*
2002fa9e4066Sahrens 	 * At this point, we have verified that the mountpoint and/or shareopts
2003fa9e4066Sahrens 	 * are appropriate for auto management.  Determine if the filesystem is
2004fa9e4066Sahrens 	 * currently mounted or shared, and abort if this is an explicit
2005fa9e4066Sahrens 	 * request.
2006fa9e4066Sahrens 	 */
2007fa9e4066Sahrens 	switch (cbp->cb_type) {
2008fa9e4066Sahrens 	case OP_SHARE:
2009fa9e4066Sahrens 		if (zfs_is_shared(zhp, NULL)) {
2010fa9e4066Sahrens 			if (cbp->cb_explicit) {
2011fa9e4066Sahrens 				(void) fprintf(stderr, gettext("cannot share "
2012fa9e4066Sahrens 				    "'%s': filesystem already shared\n"),
2013fa9e4066Sahrens 				    zfs_get_name(zhp));
2014fa9e4066Sahrens 				return (1);
2015fa9e4066Sahrens 			} else {
2016fa9e4066Sahrens 				return (0);
2017fa9e4066Sahrens 			}
2018fa9e4066Sahrens 		}
2019fa9e4066Sahrens 		break;
2020fa9e4066Sahrens 
2021fa9e4066Sahrens 	case OP_MOUNT:
2022fa9e4066Sahrens 		if (!hasmntopt(&mnt, MNTOPT_REMOUNT) &&
2023fa9e4066Sahrens 		    zfs_is_mounted(zhp, NULL)) {
2024fa9e4066Sahrens 			if (cbp->cb_explicit) {
2025fa9e4066Sahrens 				(void) fprintf(stderr, gettext("cannot mount "
2026fa9e4066Sahrens 				    "'%s': filesystem already mounted\n"),
2027fa9e4066Sahrens 				    zfs_get_name(zhp));
2028fa9e4066Sahrens 				return (1);
2029fa9e4066Sahrens 			} else {
2030fa9e4066Sahrens 				return (0);
2031fa9e4066Sahrens 			}
2032fa9e4066Sahrens 		}
2033fa9e4066Sahrens 		break;
2034fa9e4066Sahrens 	}
2035fa9e4066Sahrens 
2036fa9e4066Sahrens 	/*
2037fa9e4066Sahrens 	 * Mount and optionally share the filesystem.
2038fa9e4066Sahrens 	 */
2039fa9e4066Sahrens 	switch (cbp->cb_type) {
2040fa9e4066Sahrens 	case OP_SHARE:
2041fa9e4066Sahrens 		{
2042fa9e4066Sahrens 			if (!zfs_is_mounted(zhp, NULL) &&
2043fa9e4066Sahrens 			    zfs_mount(zhp, NULL, 0) != 0)
2044fa9e4066Sahrens 				return (1);
2045fa9e4066Sahrens 
2046fa9e4066Sahrens 			if (zfs_share(zhp) != 0)
2047fa9e4066Sahrens 				return (1);
2048fa9e4066Sahrens 		}
2049fa9e4066Sahrens 		break;
2050fa9e4066Sahrens 
2051fa9e4066Sahrens 	case OP_MOUNT:
2052fa9e4066Sahrens 		if (zfs_mount(zhp, cbp->cb_options, cbp->cb_flags) != 0)
2053fa9e4066Sahrens 			return (1);
2054fa9e4066Sahrens 		break;
2055fa9e4066Sahrens 	}
2056fa9e4066Sahrens 
2057fa9e4066Sahrens 	return (0);
2058fa9e4066Sahrens }
2059fa9e4066Sahrens 
2060fa9e4066Sahrens static int
2061fa9e4066Sahrens share_or_mount(int type, int argc, char **argv)
2062fa9e4066Sahrens {
2063fa9e4066Sahrens 	int do_all = 0;
2064fa9e4066Sahrens 	int c, ret;
2065fa9e4066Sahrens 	share_mount_cbdata_t cb = { 0 };
2066fa9e4066Sahrens 
2067fa9e4066Sahrens 	cb.cb_type = type;
2068fa9e4066Sahrens 
2069fa9e4066Sahrens 	/* check options */
2070fa9e4066Sahrens 	while ((c = getopt(argc, argv, type == OP_MOUNT ? ":ao:O" : "a"))
2071fa9e4066Sahrens 	    != -1) {
2072fa9e4066Sahrens 		switch (c) {
2073fa9e4066Sahrens 		case 'a':
2074fa9e4066Sahrens 			do_all = 1;
2075fa9e4066Sahrens 			break;
2076fa9e4066Sahrens 		case 'o':
2077fa9e4066Sahrens 			cb.cb_options = optarg;
2078fa9e4066Sahrens 			break;
2079fa9e4066Sahrens 		case 'O':
2080fa9e4066Sahrens 			cb.cb_flags |= MS_OVERLAY;
2081fa9e4066Sahrens 			break;
2082fa9e4066Sahrens 		case ':':
2083fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing argument for "
2084fa9e4066Sahrens 			    "'%c' option\n"), optopt);
2085fa9e4066Sahrens 			usage(FALSE);
2086fa9e4066Sahrens 			break;
2087fa9e4066Sahrens 		case '?':
2088fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
2089fa9e4066Sahrens 			    optopt);
2090fa9e4066Sahrens 			usage(FALSE);
2091fa9e4066Sahrens 		}
2092fa9e4066Sahrens 	}
2093fa9e4066Sahrens 
2094fa9e4066Sahrens 	argc -= optind;
2095fa9e4066Sahrens 	argv += optind;
2096fa9e4066Sahrens 
2097fa9e4066Sahrens 	/* check number of arguments */
2098fa9e4066Sahrens 	if (do_all) {
20997f7322feSeschrock 		zfs_handle_t **fslist = NULL;
21007f7322feSeschrock 		size_t i, count = 0;
21017f7322feSeschrock 
2102fa9e4066Sahrens 		if (argc != 0) {
2103fa9e4066Sahrens 			(void) fprintf(stderr, gettext("too many arguments\n"));
2104fa9e4066Sahrens 			usage(FALSE);
2105fa9e4066Sahrens 		}
2106fa9e4066Sahrens 
21077f7322feSeschrock 		get_all_filesystems(&fslist, &count);
21087f7322feSeschrock 
21097f7322feSeschrock 		if (count == 0)
21107f7322feSeschrock 			return (0);
21117f7322feSeschrock 
21127f7322feSeschrock 		qsort(fslist, count, sizeof (void *), mountpoint_compare);
21137f7322feSeschrock 
21147f7322feSeschrock 		for (i = 0; i < count; i++) {
21157f7322feSeschrock 			if ((ret = share_mount_callback(fslist[i], &cb)) != 0)
21167f7322feSeschrock 				break;
21177f7322feSeschrock 		}
21187f7322feSeschrock 
21197f7322feSeschrock 		for (i = 0; i < count; i++)
21207f7322feSeschrock 			zfs_close(fslist[i]);
21217f7322feSeschrock 
21227f7322feSeschrock 		free(fslist);
2123fa9e4066Sahrens 	} else if (argc == 0) {
2124fa9e4066Sahrens 		struct mnttab entry;
2125fa9e4066Sahrens 
2126fa9e4066Sahrens 		if (type == OP_SHARE) {
2127fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing filesystem "
2128fa9e4066Sahrens 			    "argument\n"));
2129fa9e4066Sahrens 			usage(FALSE);
2130fa9e4066Sahrens 		}
2131fa9e4066Sahrens 
2132fa9e4066Sahrens 		/*
2133fa9e4066Sahrens 		 * When mount is given no arguments, go through /etc/mnttab and
2134fa9e4066Sahrens 		 * display any active ZFS mounts.  We hide any snapshots, since
2135fa9e4066Sahrens 		 * they are controlled automatically.
2136fa9e4066Sahrens 		 */
2137fa9e4066Sahrens 		rewind(mnttab_file);
2138fa9e4066Sahrens 		while (getmntent(mnttab_file, &entry) == 0) {
2139fa9e4066Sahrens 			if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0 ||
2140fa9e4066Sahrens 			    strchr(entry.mnt_special, '@') != NULL)
2141fa9e4066Sahrens 				continue;
2142fa9e4066Sahrens 
2143fa9e4066Sahrens 			(void) printf("%-30s  %s\n", entry.mnt_special,
2144fa9e4066Sahrens 			    entry.mnt_mountp);
2145fa9e4066Sahrens 		}
2146fa9e4066Sahrens 
2147fa9e4066Sahrens 		ret = 0;
2148fa9e4066Sahrens 	} else {
2149fa9e4066Sahrens 		zfs_handle_t *zhp;
2150fa9e4066Sahrens 
2151fa9e4066Sahrens 		if (argc > 1) {
2152fa9e4066Sahrens 			(void) fprintf(stderr,
2153fa9e4066Sahrens 			    gettext("too many arguments\n"));
2154fa9e4066Sahrens 			usage(FALSE);
2155fa9e4066Sahrens 		}
2156fa9e4066Sahrens 
2157fa9e4066Sahrens 		if ((zhp = zfs_open(argv[0], ZFS_TYPE_FILESYSTEM)) == NULL)
2158fa9e4066Sahrens 			ret = 1;
2159fa9e4066Sahrens 		else {
2160fa9e4066Sahrens 			cb.cb_explicit = TRUE;
2161fa9e4066Sahrens 			ret = share_mount_callback(zhp, &cb);
2162fa9e4066Sahrens 			zfs_close(zhp);
2163fa9e4066Sahrens 		}
2164fa9e4066Sahrens 	}
2165fa9e4066Sahrens 
2166fa9e4066Sahrens 	return (ret);
2167fa9e4066Sahrens }
2168fa9e4066Sahrens 
2169fa9e4066Sahrens /*
2170fa9e4066Sahrens  * zfs mount -a
2171fa9e4066Sahrens  * zfs mount filesystem
2172fa9e4066Sahrens  *
2173fa9e4066Sahrens  * Mount all filesystems, or mount the given filesystem.
2174fa9e4066Sahrens  */
2175fa9e4066Sahrens static int
2176fa9e4066Sahrens zfs_do_mount(int argc, char **argv)
2177fa9e4066Sahrens {
2178fa9e4066Sahrens 	return (share_or_mount(OP_MOUNT, argc, argv));
2179fa9e4066Sahrens }
2180fa9e4066Sahrens 
2181fa9e4066Sahrens /*
2182fa9e4066Sahrens  * zfs share -a
2183fa9e4066Sahrens  * zfs share filesystem
2184fa9e4066Sahrens  *
2185fa9e4066Sahrens  * Share all filesystems, or share the given filesystem.
2186fa9e4066Sahrens  */
2187fa9e4066Sahrens static int
2188fa9e4066Sahrens zfs_do_share(int argc, char **argv)
2189fa9e4066Sahrens {
2190fa9e4066Sahrens 	return (share_or_mount(OP_SHARE, argc, argv));
2191fa9e4066Sahrens }
2192fa9e4066Sahrens 
2193fa9e4066Sahrens typedef struct unshare_unmount_node {
2194fa9e4066Sahrens 	zfs_handle_t	*un_zhp;
2195fa9e4066Sahrens 	char		*un_mountp;
2196fa9e4066Sahrens 	uu_avl_node_t	un_avlnode;
2197fa9e4066Sahrens } unshare_unmount_node_t;
2198fa9e4066Sahrens 
2199fa9e4066Sahrens /* ARGSUSED */
2200fa9e4066Sahrens static int
2201fa9e4066Sahrens unshare_unmount_compare(const void *larg, const void *rarg, void *unused)
2202fa9e4066Sahrens {
2203fa9e4066Sahrens 	const unshare_unmount_node_t *l = larg;
2204fa9e4066Sahrens 	const unshare_unmount_node_t *r = rarg;
2205fa9e4066Sahrens 
2206fa9e4066Sahrens 	return (strcmp(l->un_mountp, r->un_mountp));
2207fa9e4066Sahrens }
2208fa9e4066Sahrens 
2209fa9e4066Sahrens /*
2210fa9e4066Sahrens  * Convenience routine used by zfs_do_umount() and manual_unmount().  Given an
2211fa9e4066Sahrens  * absolute path, find the entry /etc/mnttab, verify that its a ZFS filesystem,
2212fa9e4066Sahrens  * and unmount it appropriately.
2213fa9e4066Sahrens  */
2214fa9e4066Sahrens static int
2215fa9e4066Sahrens unshare_unmount_path(int type, char *path, int flags, int is_manual)
2216fa9e4066Sahrens {
2217fa9e4066Sahrens 	zfs_handle_t *zhp;
2218fa9e4066Sahrens 	int ret;
2219fa9e4066Sahrens 	struct stat64 statbuf;
2220fa9e4066Sahrens 	struct extmnttab entry;
2221fa9e4066Sahrens 	const char *cmdname = (type == OP_SHARE) ? "unshare" : "unmount";
2222fa9e4066Sahrens 	char property[ZFS_MAXPROPLEN];
2223fa9e4066Sahrens 
2224fa9e4066Sahrens 	/*
2225fa9e4066Sahrens 	 * Search for the path in /etc/mnttab.  Rather than looking for the
2226fa9e4066Sahrens 	 * specific path, which can be fooled by non-standard paths (i.e. ".."
2227fa9e4066Sahrens 	 * or "//"), we stat() the path and search for the corresponding
2228fa9e4066Sahrens 	 * (major,minor) device pair.
2229fa9e4066Sahrens 	 */
2230fa9e4066Sahrens 	if (stat64(path, &statbuf) != 0) {
2231fa9e4066Sahrens 		(void) fprintf(stderr, gettext("cannot %s '%s': %s\n"),
2232fa9e4066Sahrens 		    cmdname, path, strerror(errno));
2233fa9e4066Sahrens 		return (1);
2234fa9e4066Sahrens 	}
2235fa9e4066Sahrens 
2236fa9e4066Sahrens 	/*
2237fa9e4066Sahrens 	 * Search for the given (major,minor) pair in the mount table.
2238fa9e4066Sahrens 	 */
2239fa9e4066Sahrens 	rewind(mnttab_file);
2240fa9e4066Sahrens 	while ((ret = getextmntent(mnttab_file, &entry, 0)) == 0) {
2241fa9e4066Sahrens 		if (entry.mnt_major == major(statbuf.st_dev) &&
2242fa9e4066Sahrens 		    entry.mnt_minor == minor(statbuf.st_dev))
2243fa9e4066Sahrens 			break;
2244fa9e4066Sahrens 	}
2245fa9e4066Sahrens 	if (ret != 0) {
2246fa9e4066Sahrens 		(void) fprintf(stderr, gettext("cannot %s '%s': not "
2247fa9e4066Sahrens 		    "currently mounted\n"), cmdname, path);
2248fa9e4066Sahrens 		return (1);
2249fa9e4066Sahrens 	}
2250fa9e4066Sahrens 
2251fa9e4066Sahrens 	if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0) {
2252fa9e4066Sahrens 		(void) fprintf(stderr, gettext("cannot %s '%s': not a ZFS "
2253fa9e4066Sahrens 		    "filesystem\n"), cmdname, path);
2254fa9e4066Sahrens 		return (1);
2255fa9e4066Sahrens 	}
2256fa9e4066Sahrens 
2257fa9e4066Sahrens 	if ((zhp = zfs_open(entry.mnt_special, ZFS_TYPE_FILESYSTEM)) == NULL)
2258fa9e4066Sahrens 		return (1);
2259fa9e4066Sahrens 
2260fa9e4066Sahrens 	verify(zfs_prop_get(zhp, type == OP_SHARE ?
2261fa9e4066Sahrens 		ZFS_PROP_SHARENFS : ZFS_PROP_MOUNTPOINT, property,
2262fa9e4066Sahrens 		sizeof (property), NULL, NULL, 0, FALSE) == 0);
2263fa9e4066Sahrens 
2264fa9e4066Sahrens 	if (type == OP_SHARE) {
2265fa9e4066Sahrens 		if (strcmp(property, "off") == 0) {
2266fa9e4066Sahrens 			(void) fprintf(stderr, gettext("cannot unshare "
2267fa9e4066Sahrens 			    "'%s': legacy share\n"), path);
2268fa9e4066Sahrens 			(void) fprintf(stderr, gettext("use "
2269fa9e4066Sahrens 			    "unshare(1M) to unshare this filesystem\n"));
2270fa9e4066Sahrens 			ret = 1;
2271fa9e4066Sahrens 		} else if (!zfs_is_shared(zhp, NULL)) {
2272fa9e4066Sahrens 			(void) fprintf(stderr, gettext("cannot unshare '%s': "
2273fa9e4066Sahrens 			    "not currently shared\n"), path);
2274fa9e4066Sahrens 			ret = 1;
2275fa9e4066Sahrens 		} else {
2276fa9e4066Sahrens 			ret = zfs_unshareall(zhp);
2277fa9e4066Sahrens 		}
2278fa9e4066Sahrens 	} else {
22796b90ca48Slling 		if (is_manual) {
22806b90ca48Slling 			ret = zfs_unmount(zhp, NULL, flags);
2281c0ea9bc7Slling 		} else if (strcmp(property, "legacy") == 0) {
2282fa9e4066Sahrens 			(void) fprintf(stderr, gettext("cannot unmount "
2283fa9e4066Sahrens 			    "'%s': legacy mountpoint\n"),
2284fa9e4066Sahrens 			    zfs_get_name(zhp));
2285fa9e4066Sahrens 			(void) fprintf(stderr, gettext("use umount(1M) "
2286fa9e4066Sahrens 			    "to unmount this filesystem\n"));
2287fa9e4066Sahrens 			ret = 1;
2288fa9e4066Sahrens 		} else {
2289fa9e4066Sahrens 			ret = zfs_unmountall(zhp, flags);
2290fa9e4066Sahrens 		}
2291fa9e4066Sahrens 	}
2292fa9e4066Sahrens 
2293fa9e4066Sahrens 	zfs_close(zhp);
2294fa9e4066Sahrens 
2295fa9e4066Sahrens 	return (ret != 0);
2296fa9e4066Sahrens }
2297fa9e4066Sahrens 
2298fa9e4066Sahrens /*
2299fa9e4066Sahrens  * Generic callback for unsharing or unmounting a filesystem.
2300fa9e4066Sahrens  */
2301fa9e4066Sahrens static int
2302fa9e4066Sahrens unshare_unmount(int type, int argc, char **argv)
2303fa9e4066Sahrens {
2304fa9e4066Sahrens 	int do_all = 0;
2305fa9e4066Sahrens 	int flags = 0;
2306fa9e4066Sahrens 	int ret = 0;
2307fa9e4066Sahrens 	int c;
2308fa9e4066Sahrens 	zfs_handle_t *zhp;
2309fa9e4066Sahrens 	char property[ZFS_MAXPROPLEN];
2310fa9e4066Sahrens 
2311fa9e4066Sahrens 	/* check options */
2312fa9e4066Sahrens 	while ((c = getopt(argc, argv, type == OP_SHARE ? "a" : "af")) != -1) {
2313fa9e4066Sahrens 		switch (c) {
2314fa9e4066Sahrens 		case 'a':
2315fa9e4066Sahrens 			do_all = 1;
2316fa9e4066Sahrens 			break;
2317fa9e4066Sahrens 		case 'f':
2318fa9e4066Sahrens 			flags = MS_FORCE;
2319fa9e4066Sahrens 			break;
2320fa9e4066Sahrens 		case '?':
2321fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
2322fa9e4066Sahrens 			    optopt);
2323fa9e4066Sahrens 			usage(FALSE);
2324fa9e4066Sahrens 		}
2325fa9e4066Sahrens 	}
2326fa9e4066Sahrens 
2327fa9e4066Sahrens 	argc -= optind;
2328fa9e4066Sahrens 	argv += optind;
2329fa9e4066Sahrens 
2330fa9e4066Sahrens 	/* ensure correct number of arguments */
2331fa9e4066Sahrens 	if (do_all) {
2332fa9e4066Sahrens 		if (argc != 0) {
2333fa9e4066Sahrens 			(void) fprintf(stderr, gettext("too many arguments\n"));
2334fa9e4066Sahrens 			usage(FALSE);
2335fa9e4066Sahrens 		}
2336fa9e4066Sahrens 	} else if (argc != 1) {
2337fa9e4066Sahrens 		if (argc == 0)
2338fa9e4066Sahrens 			(void) fprintf(stderr,
2339fa9e4066Sahrens 			    gettext("missing filesystem argument\n"));
2340fa9e4066Sahrens 		else
2341fa9e4066Sahrens 			(void) fprintf(stderr,
2342fa9e4066Sahrens 			    gettext("too many arguments\n"));
2343fa9e4066Sahrens 		usage(FALSE);
2344fa9e4066Sahrens 	}
2345fa9e4066Sahrens 
2346fa9e4066Sahrens 	if (do_all) {
2347fa9e4066Sahrens 		/*
2348fa9e4066Sahrens 		 * We could make use of zfs_for_each() to walk all datasets in
2349fa9e4066Sahrens 		 * the system, but this would be very inefficient, especially
2350fa9e4066Sahrens 		 * since we would have to linearly search /etc/mnttab for each
2351fa9e4066Sahrens 		 * one.  Instead, do one pass through /etc/mnttab looking for
2352fa9e4066Sahrens 		 * zfs entries and call zfs_unmount() for each one.
2353fa9e4066Sahrens 		 *
2354fa9e4066Sahrens 		 * Things get a little tricky if the administrator has created
2355fa9e4066Sahrens 		 * mountpoints beneath other ZFS filesystems.  In this case, we
2356fa9e4066Sahrens 		 * have to unmount the deepest filesystems first.  To accomplish
2357fa9e4066Sahrens 		 * this, we place all the mountpoints in an AVL tree sorted by
2358fa9e4066Sahrens 		 * the special type (dataset name), and walk the result in
2359fa9e4066Sahrens 		 * reverse to make sure to get any snapshots first.
2360fa9e4066Sahrens 		 */
2361fa9e4066Sahrens 		struct mnttab entry;
2362fa9e4066Sahrens 		uu_avl_pool_t *pool;
2363fa9e4066Sahrens 		uu_avl_t *tree;
2364fa9e4066Sahrens 		unshare_unmount_node_t *node;
2365fa9e4066Sahrens 		uu_avl_index_t idx;
2366fa9e4066Sahrens 		uu_avl_walk_t *walk;
2367fa9e4066Sahrens 
2368fa9e4066Sahrens 		if ((pool = uu_avl_pool_create("unmount_pool",
2369fa9e4066Sahrens 		    sizeof (unshare_unmount_node_t),
2370fa9e4066Sahrens 		    offsetof(unshare_unmount_node_t, un_avlnode),
2371fa9e4066Sahrens 		    unshare_unmount_compare,
2372fa9e4066Sahrens 		    UU_DEFAULT)) == NULL) {
2373fa9e4066Sahrens 			(void) fprintf(stderr, gettext("internal error: "
2374fa9e4066Sahrens 			    "out of memory\n"));
2375fa9e4066Sahrens 			exit(1);
2376fa9e4066Sahrens 		}
2377fa9e4066Sahrens 
2378fa9e4066Sahrens 		if ((tree = uu_avl_create(pool, NULL, UU_DEFAULT)) == NULL) {
2379fa9e4066Sahrens 			(void) fprintf(stderr, gettext("internal error: "
2380fa9e4066Sahrens 			    "out of memory\n"));
2381fa9e4066Sahrens 			exit(1);
2382fa9e4066Sahrens 		}
2383fa9e4066Sahrens 
2384fa9e4066Sahrens 		rewind(mnttab_file);
2385fa9e4066Sahrens 		while (getmntent(mnttab_file, &entry) == 0) {
2386fa9e4066Sahrens 
2387fa9e4066Sahrens 			/* ignore non-ZFS entries */
2388fa9e4066Sahrens 			if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0)
2389fa9e4066Sahrens 				continue;
2390fa9e4066Sahrens 
2391fa9e4066Sahrens 			/* ignore snapshots */
2392fa9e4066Sahrens 			if (strchr(entry.mnt_special, '@') != NULL)
2393fa9e4066Sahrens 				continue;
2394fa9e4066Sahrens 
2395fa9e4066Sahrens 			if ((zhp = zfs_open(entry.mnt_special,
2396fa9e4066Sahrens 			    ZFS_TYPE_FILESYSTEM)) == NULL) {
2397fa9e4066Sahrens 				ret = 1;
2398fa9e4066Sahrens 				continue;
2399fa9e4066Sahrens 			}
2400fa9e4066Sahrens 
2401fa9e4066Sahrens 			verify(zfs_prop_get(zhp, type == OP_SHARE ?
2402fa9e4066Sahrens 			    ZFS_PROP_SHARENFS : ZFS_PROP_MOUNTPOINT,
2403fa9e4066Sahrens 			    property, sizeof (property), NULL, NULL,
2404fa9e4066Sahrens 			    0, FALSE) == 0);
2405fa9e4066Sahrens 
2406fa9e4066Sahrens 			/* Ignore legacy mounts and shares */
2407fa9e4066Sahrens 			if ((type == OP_SHARE &&
2408fa9e4066Sahrens 			    strcmp(property, "off") == 0) ||
2409fa9e4066Sahrens 			    (type == OP_MOUNT &&
2410fa9e4066Sahrens 			    strcmp(property, "legacy") == 0)) {
2411fa9e4066Sahrens 				zfs_close(zhp);
2412fa9e4066Sahrens 				continue;
2413fa9e4066Sahrens 			}
2414fa9e4066Sahrens 
2415fa9e4066Sahrens 			node = safe_malloc(sizeof (unshare_unmount_node_t));
2416fa9e4066Sahrens 			node->un_zhp = zhp;
2417fa9e4066Sahrens 
2418fa9e4066Sahrens 			if ((node->un_mountp = strdup(entry.mnt_mountp)) ==
2419fa9e4066Sahrens 			    NULL) {
2420fa9e4066Sahrens 				(void) fprintf(stderr, gettext("internal error:"
2421fa9e4066Sahrens 				    " out of memory\n"));
2422fa9e4066Sahrens 				exit(1);
2423fa9e4066Sahrens 			}
2424fa9e4066Sahrens 
2425fa9e4066Sahrens 			uu_avl_node_init(node, &node->un_avlnode, pool);
2426fa9e4066Sahrens 
2427fa9e4066Sahrens 			if (uu_avl_find(tree, node, NULL, &idx) == NULL) {
2428fa9e4066Sahrens 				uu_avl_insert(tree, node, idx);
2429fa9e4066Sahrens 			} else {
2430fa9e4066Sahrens 				zfs_close(node->un_zhp);
2431fa9e4066Sahrens 				free(node->un_mountp);
2432fa9e4066Sahrens 				free(node);
2433fa9e4066Sahrens 			}
2434fa9e4066Sahrens 		}
2435fa9e4066Sahrens 
2436fa9e4066Sahrens 		/*
2437fa9e4066Sahrens 		 * Walk the AVL tree in reverse, unmounting each filesystem and
2438fa9e4066Sahrens 		 * removing it from the AVL tree in the process.
2439fa9e4066Sahrens 		 */
2440fa9e4066Sahrens 		if ((walk = uu_avl_walk_start(tree,
2441fa9e4066Sahrens 		    UU_WALK_REVERSE | UU_WALK_ROBUST)) == NULL) {
2442fa9e4066Sahrens 			(void) fprintf(stderr,
2443fa9e4066Sahrens 			    gettext("internal error: out of memory"));
2444fa9e4066Sahrens 			exit(1);
2445fa9e4066Sahrens 		}
2446fa9e4066Sahrens 
2447fa9e4066Sahrens 		while ((node = uu_avl_walk_next(walk)) != NULL) {
2448fa9e4066Sahrens 			uu_avl_remove(tree, node);
2449fa9e4066Sahrens 
2450fa9e4066Sahrens 			switch (type) {
2451fa9e4066Sahrens 			case OP_SHARE:
2452fa9e4066Sahrens 				if (zfs_unshare(node->un_zhp,
2453fa9e4066Sahrens 				    node->un_mountp) != 0)
2454fa9e4066Sahrens 					ret = 1;
2455fa9e4066Sahrens 				break;
2456fa9e4066Sahrens 
2457fa9e4066Sahrens 			case OP_MOUNT:
2458fa9e4066Sahrens 				if (zfs_unmount(node->un_zhp,
2459fa9e4066Sahrens 				    node->un_mountp, flags) != 0)
2460fa9e4066Sahrens 					ret = 1;
2461fa9e4066Sahrens 				break;
2462fa9e4066Sahrens 			}
2463fa9e4066Sahrens 
2464fa9e4066Sahrens 			zfs_close(node->un_zhp);
2465fa9e4066Sahrens 			free(node->un_mountp);
2466fa9e4066Sahrens 			free(node);
2467fa9e4066Sahrens 		}
2468fa9e4066Sahrens 
2469fa9e4066Sahrens 		uu_avl_walk_end(walk);
2470fa9e4066Sahrens 		uu_avl_destroy(tree);
2471fa9e4066Sahrens 		uu_avl_pool_destroy(pool);
2472fa9e4066Sahrens 	} else {
2473fa9e4066Sahrens 		/*
2474fa9e4066Sahrens 		 * We have an argument, but it may be a full path or a ZFS
2475fa9e4066Sahrens 		 * filesystem.  Pass full paths off to unmount_path() (shared by
2476fa9e4066Sahrens 		 * manual_unmount), otherwise open the filesystem and pass to
2477fa9e4066Sahrens 		 * zfs_unmount().
2478fa9e4066Sahrens 		 */
2479fa9e4066Sahrens 		if (argv[0][0] == '/')
2480fa9e4066Sahrens 			return (unshare_unmount_path(type, argv[0],
2481fa9e4066Sahrens 				flags, FALSE));
2482fa9e4066Sahrens 
2483fa9e4066Sahrens 		if ((zhp = zfs_open(argv[0], ZFS_TYPE_FILESYSTEM)) == NULL)
2484fa9e4066Sahrens 			return (1);
2485fa9e4066Sahrens 
2486fa9e4066Sahrens 		verify(zfs_prop_get(zhp, type == OP_SHARE ?
2487fa9e4066Sahrens 		    ZFS_PROP_SHARENFS : ZFS_PROP_MOUNTPOINT, property,
2488fa9e4066Sahrens 		    sizeof (property), NULL, NULL, 0, FALSE) == 0);
2489fa9e4066Sahrens 
2490fa9e4066Sahrens 		switch (type) {
2491fa9e4066Sahrens 		case OP_SHARE:
2492fa9e4066Sahrens 			if (strcmp(property, "off") == 0) {
2493fa9e4066Sahrens 				(void) fprintf(stderr, gettext("cannot unshare "
2494fa9e4066Sahrens 				    "'%s': legacy share\n"), zfs_get_name(zhp));
2495fa9e4066Sahrens 				(void) fprintf(stderr, gettext("use unshare(1M)"
2496fa9e4066Sahrens 				    " to unshare this filesystem\n"));
2497fa9e4066Sahrens 				ret = 1;
2498fa9e4066Sahrens 			} else if (!zfs_is_shared(zhp, NULL)) {
2499fa9e4066Sahrens 				(void) fprintf(stderr, gettext("cannot unshare "
2500fa9e4066Sahrens 				    "'%s': not currently shared\n"),
2501fa9e4066Sahrens 				    zfs_get_name(zhp));
2502fa9e4066Sahrens 				ret = 1;
2503fa9e4066Sahrens 			} else if (zfs_unshareall(zhp) != 0) {
2504fa9e4066Sahrens 				ret = 1;
2505fa9e4066Sahrens 			}
2506fa9e4066Sahrens 			break;
2507fa9e4066Sahrens 
2508fa9e4066Sahrens 		case OP_MOUNT:
2509fa9e4066Sahrens 			if (strcmp(property, "legacy") == 0) {
2510fa9e4066Sahrens 				(void) fprintf(stderr, gettext("cannot unmount "
2511fa9e4066Sahrens 				    "'%s': legacy mountpoint\n"),
2512fa9e4066Sahrens 				    zfs_get_name(zhp));
2513fa9e4066Sahrens 				(void) fprintf(stderr, gettext("use umount(1M) "
2514fa9e4066Sahrens 				    "to unmount this filesystem\n"));
2515fa9e4066Sahrens 				ret = 1;
2516fa9e4066Sahrens 			} else if (!zfs_is_mounted(zhp, NULL)) {
2517fa9e4066Sahrens 				(void) fprintf(stderr, gettext("cannot unmount "
2518fa9e4066Sahrens 				    "'%s': not currently mounted\n"),
2519fa9e4066Sahrens 				    zfs_get_name(zhp));
2520fa9e4066Sahrens 				ret = 1;
2521fa9e4066Sahrens 			} else if (zfs_unmountall(zhp, flags) != 0) {
2522fa9e4066Sahrens 				ret = 1;
2523fa9e4066Sahrens 			}
2524fa9e4066Sahrens 		}
2525fa9e4066Sahrens 
2526fa9e4066Sahrens 		zfs_close(zhp);
2527fa9e4066Sahrens 	}
2528fa9e4066Sahrens 
2529fa9e4066Sahrens 	return (ret);
2530fa9e4066Sahrens }
2531fa9e4066Sahrens 
2532fa9e4066Sahrens /*
2533fa9e4066Sahrens  * zfs unmount -a
2534fa9e4066Sahrens  * zfs unmount filesystem
2535fa9e4066Sahrens  *
2536fa9e4066Sahrens  * Unmount all filesystems, or a specific ZFS filesystem.
2537fa9e4066Sahrens  */
2538fa9e4066Sahrens static int
2539fa9e4066Sahrens zfs_do_unmount(int argc, char **argv)
2540fa9e4066Sahrens {
2541fa9e4066Sahrens 	return (unshare_unmount(OP_MOUNT, argc, argv));
2542fa9e4066Sahrens }
2543fa9e4066Sahrens 
2544fa9e4066Sahrens /*
2545fa9e4066Sahrens  * zfs unshare -a
2546fa9e4066Sahrens  * zfs unshare filesystem
2547fa9e4066Sahrens  *
2548fa9e4066Sahrens  * Unshare all filesystems, or a specific ZFS filesystem.
2549fa9e4066Sahrens  */
2550fa9e4066Sahrens static int
2551fa9e4066Sahrens zfs_do_unshare(int argc, char **argv)
2552fa9e4066Sahrens {
2553fa9e4066Sahrens 	return (unshare_unmount(OP_SHARE, argc, argv));
2554fa9e4066Sahrens }
2555fa9e4066Sahrens 
2556fa9e4066Sahrens /*
2557fa9e4066Sahrens  * Called when invoked as /etc/fs/zfs/mount.  Do the mount if the mountpoint is
2558fa9e4066Sahrens  * 'legacy'.  Otherwise, complain that use should be using 'zfs mount'.
2559fa9e4066Sahrens  */
2560fa9e4066Sahrens static int
2561fa9e4066Sahrens manual_mount(int argc, char **argv)
2562fa9e4066Sahrens {
2563fa9e4066Sahrens 	zfs_handle_t *zhp;
2564fa9e4066Sahrens 	char mountpoint[ZFS_MAXPROPLEN];
2565fa9e4066Sahrens 	char mntopts[MNT_LINE_MAX] = { '\0' };
2566fa9e4066Sahrens 	int ret;
2567fa9e4066Sahrens 	int c;
2568fa9e4066Sahrens 	int flags = 0;
2569fa9e4066Sahrens 	char *dataset, *path;
2570fa9e4066Sahrens 
2571fa9e4066Sahrens 	/* check options */
2572fa9e4066Sahrens 	while ((c = getopt(argc, argv, ":o:O")) != -1) {
2573fa9e4066Sahrens 		switch (c) {
2574fa9e4066Sahrens 		case 'o':
2575fa9e4066Sahrens 			(void) strlcpy(mntopts, optarg, sizeof (mntopts));
2576fa9e4066Sahrens 			break;
2577fa9e4066Sahrens 		case 'O':
2578fa9e4066Sahrens 			flags |= MS_OVERLAY;
2579fa9e4066Sahrens 			break;
2580fa9e4066Sahrens 		case ':':
2581fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing argument for "
2582fa9e4066Sahrens 			    "'%c' option\n"), optopt);
2583fa9e4066Sahrens 			usage(FALSE);
2584fa9e4066Sahrens 			break;
2585fa9e4066Sahrens 		case '?':
2586fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
2587fa9e4066Sahrens 			    optopt);
2588fa9e4066Sahrens 			(void) fprintf(stderr, gettext("usage: mount [-o opts] "
2589fa9e4066Sahrens 			    "<path>\n"));
2590fa9e4066Sahrens 			return (2);
2591fa9e4066Sahrens 		}
2592fa9e4066Sahrens 	}
2593fa9e4066Sahrens 
2594fa9e4066Sahrens 	argc -= optind;
2595fa9e4066Sahrens 	argv += optind;
2596fa9e4066Sahrens 
2597fa9e4066Sahrens 	/* check that we only have two arguments */
2598fa9e4066Sahrens 	if (argc != 2) {
2599fa9e4066Sahrens 		if (argc == 0)
2600fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing dataset "
2601fa9e4066Sahrens 			    "argument\n"));
2602fa9e4066Sahrens 		else if (argc == 1)
2603fa9e4066Sahrens 			(void) fprintf(stderr,
2604fa9e4066Sahrens 			    gettext("missing mountpoint argument\n"));
2605fa9e4066Sahrens 		else
2606fa9e4066Sahrens 			(void) fprintf(stderr, gettext("too many arguments\n"));
2607fa9e4066Sahrens 		(void) fprintf(stderr, "usage: mount <dataset> <mountpoint>\n");
2608fa9e4066Sahrens 		return (2);
2609fa9e4066Sahrens 	}
2610fa9e4066Sahrens 
2611fa9e4066Sahrens 	dataset = argv[0];
2612fa9e4066Sahrens 	path = argv[1];
2613fa9e4066Sahrens 
2614fa9e4066Sahrens 	/* try to open the dataset */
2615fa9e4066Sahrens 	if ((zhp = zfs_open(dataset, ZFS_TYPE_FILESYSTEM)) == NULL)
2616fa9e4066Sahrens 		return (1);
2617fa9e4066Sahrens 
2618fa9e4066Sahrens 	(void) zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint,
2619fa9e4066Sahrens 	    sizeof (mountpoint), NULL, NULL, 0, FALSE);
2620fa9e4066Sahrens 
2621fa9e4066Sahrens 	/* check for legacy mountpoint and complain appropriately */
2622fa9e4066Sahrens 	ret = 0;
2623fa9e4066Sahrens 	if (strcmp(mountpoint, ZFS_MOUNTPOINT_LEGACY) == 0) {
2624fa9e4066Sahrens 		if (mount(dataset, path, MS_OPTIONSTR | flags, MNTTYPE_ZFS,
2625fa9e4066Sahrens 		    NULL, 0, mntopts, sizeof (mntopts)) != 0) {
2626fa9e4066Sahrens 			(void) fprintf(stderr, gettext("mount failed: %s\n"),
2627fa9e4066Sahrens 			    strerror(errno));
2628fa9e4066Sahrens 			ret = 1;
2629fa9e4066Sahrens 		}
2630fa9e4066Sahrens 	} else {
2631fa9e4066Sahrens 		(void) fprintf(stderr, gettext("filesystem '%s' cannot be "
2632fa9e4066Sahrens 		    "mounted using 'mount -F zfs'\n"), dataset);
2633fa9e4066Sahrens 		(void) fprintf(stderr, gettext("Use 'zfs set mountpoint=%s' "
2634fa9e4066Sahrens 		    "instead.\n"), path);
2635fa9e4066Sahrens 		(void) fprintf(stderr, gettext("If you must use 'mount -F zfs' "
2636fa9e4066Sahrens 		    "or /etc/vfstab, use 'zfs set mountpoint=legacy'.\n"));
2637fa9e4066Sahrens 		(void) fprintf(stderr, gettext("See zfs(1M) for more "
2638fa9e4066Sahrens 		    "information.\n"));
2639fa9e4066Sahrens 		ret = 1;
2640fa9e4066Sahrens 	}
2641fa9e4066Sahrens 
2642fa9e4066Sahrens 	return (ret);
2643fa9e4066Sahrens }
2644fa9e4066Sahrens 
2645fa9e4066Sahrens /*
2646fa9e4066Sahrens  * Called when invoked as /etc/fs/zfs/umount.  Unlike a manual mount, we allow
2647fa9e4066Sahrens  * unmounts of non-legacy filesystems, as this is the dominant administrative
2648fa9e4066Sahrens  * interface.
2649fa9e4066Sahrens  */
2650fa9e4066Sahrens static int
2651fa9e4066Sahrens manual_unmount(int argc, char **argv)
2652fa9e4066Sahrens {
2653fa9e4066Sahrens 	int flags = 0;
2654fa9e4066Sahrens 	int c;
2655fa9e4066Sahrens 
2656fa9e4066Sahrens 	/* check options */
2657fa9e4066Sahrens 	while ((c = getopt(argc, argv, "f")) != -1) {
2658fa9e4066Sahrens 		switch (c) {
2659fa9e4066Sahrens 		case 'f':
2660fa9e4066Sahrens 			flags = MS_FORCE;
2661fa9e4066Sahrens 			break;
2662fa9e4066Sahrens 		case '?':
2663fa9e4066Sahrens 			(void) fprintf(stderr, gettext("invalid option '%c'\n"),
2664fa9e4066Sahrens 			    optopt);
2665fa9e4066Sahrens 			(void) fprintf(stderr, gettext("usage: unmount [-f] "
2666fa9e4066Sahrens 			    "<path>\n"));
2667fa9e4066Sahrens 			return (2);
2668fa9e4066Sahrens 		}
2669fa9e4066Sahrens 	}
2670fa9e4066Sahrens 
2671fa9e4066Sahrens 	argc -= optind;
2672fa9e4066Sahrens 	argv += optind;
2673fa9e4066Sahrens 
2674fa9e4066Sahrens 	/* check arguments */
2675fa9e4066Sahrens 	if (argc != 1) {
2676fa9e4066Sahrens 		if (argc == 0)
2677fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing path "
2678fa9e4066Sahrens 			    "argument\n"));
2679fa9e4066Sahrens 		else
2680fa9e4066Sahrens 			(void) fprintf(stderr, gettext("too many arguments\n"));
2681fa9e4066Sahrens 		(void) fprintf(stderr, gettext("usage: unmount [-f] <path>\n"));
2682fa9e4066Sahrens 		return (2);
2683fa9e4066Sahrens 	}
2684fa9e4066Sahrens 
2685fa9e4066Sahrens 	return (unshare_unmount_path(OP_MOUNT, argv[0], flags, TRUE));
2686fa9e4066Sahrens }
2687fa9e4066Sahrens 
2688fa9e4066Sahrens static int
2689fa9e4066Sahrens volcheck(zpool_handle_t *zhp, void *data)
2690fa9e4066Sahrens {
2691fa9e4066Sahrens 	int isinit = (int)data;
2692fa9e4066Sahrens 
2693fa9e4066Sahrens 	if (isinit)
2694fa9e4066Sahrens 		return (zpool_create_zvol_links(zhp));
2695fa9e4066Sahrens 	else
2696fa9e4066Sahrens 		return (zpool_remove_zvol_links(zhp));
2697fa9e4066Sahrens }
2698fa9e4066Sahrens 
2699fa9e4066Sahrens /*
2700fa9e4066Sahrens  * Iterate over all pools in the system and either create or destroy /dev/zvol
2701fa9e4066Sahrens  * links, depending on the value of 'isinit'.
2702fa9e4066Sahrens  */
2703fa9e4066Sahrens static int
2704fa9e4066Sahrens do_volcheck(int isinit)
2705fa9e4066Sahrens {
2706fa9e4066Sahrens 	return (zpool_iter(volcheck, (void *)isinit) ? 1 : 0);
2707fa9e4066Sahrens }
2708fa9e4066Sahrens 
2709fa9e4066Sahrens int
2710fa9e4066Sahrens main(int argc, char **argv)
2711fa9e4066Sahrens {
2712fa9e4066Sahrens 	int ret;
2713fa9e4066Sahrens 	int i;
2714fa9e4066Sahrens 	char *progname;
2715fa9e4066Sahrens 	char *cmdname;
2716fa9e4066Sahrens 
2717fa9e4066Sahrens 	(void) setlocale(LC_ALL, "");
2718fa9e4066Sahrens 	(void) textdomain(TEXT_DOMAIN);
2719fa9e4066Sahrens 
2720fa9e4066Sahrens 	opterr = 0;
2721fa9e4066Sahrens 
2722fa9e4066Sahrens 	if ((mnttab_file = fopen(MNTTAB, "r")) == NULL) {
2723fa9e4066Sahrens 		(void) fprintf(stderr, gettext("internal error: unable to "
2724fa9e4066Sahrens 		    "open %s\n"), MNTTAB);
2725fa9e4066Sahrens 		return (1);
2726fa9e4066Sahrens 	}
2727fa9e4066Sahrens 
2728fa9e4066Sahrens 	/*
2729fa9e4066Sahrens 	 * This command also doubles as the /etc/fs mount and unmount program.
2730fa9e4066Sahrens 	 * Determine if we should take this behavior based on argv[0].
2731fa9e4066Sahrens 	 */
2732fa9e4066Sahrens 	progname = basename(argv[0]);
2733fa9e4066Sahrens 	if (strcmp(progname, "mount") == 0) {
2734fa9e4066Sahrens 		ret = manual_mount(argc, argv);
2735fa9e4066Sahrens 	} else if (strcmp(progname, "umount") == 0) {
2736fa9e4066Sahrens 		ret = manual_unmount(argc, argv);
2737fa9e4066Sahrens 	} else {
2738fa9e4066Sahrens 		/*
2739fa9e4066Sahrens 		 * Make sure the user has specified some command.
2740fa9e4066Sahrens 		 */
2741fa9e4066Sahrens 		if (argc < 2) {
2742fa9e4066Sahrens 			(void) fprintf(stderr, gettext("missing command\n"));
2743fa9e4066Sahrens 			usage(FALSE);
2744fa9e4066Sahrens 		}
2745fa9e4066Sahrens 
2746fa9e4066Sahrens 		cmdname = argv[1];
2747fa9e4066Sahrens 
2748fa9e4066Sahrens 		/*
2749fa9e4066Sahrens 		 * The 'umount' command is an alias for 'unmount'
2750fa9e4066Sahrens 		 */
2751fa9e4066Sahrens 		if (strcmp(cmdname, "umount") == 0)
2752fa9e4066Sahrens 			cmdname = "unmount";
2753fa9e4066Sahrens 
2754fa9e4066Sahrens 		/*
2755fa9e4066Sahrens 		 * Special case '-?'
2756fa9e4066Sahrens 		 */
2757fa9e4066Sahrens 		if (strcmp(cmdname, "-?") == 0)
2758fa9e4066Sahrens 			usage(TRUE);
2759fa9e4066Sahrens 
2760fa9e4066Sahrens 		/*
2761fa9e4066Sahrens 		 * 'volinit' and 'volfini' do not appear in the usage message,
2762fa9e4066Sahrens 		 * so we have to special case them here.
2763fa9e4066Sahrens 		 */
2764fa9e4066Sahrens 		if (strcmp(cmdname, "volinit") == 0)
2765fa9e4066Sahrens 			return (do_volcheck(TRUE));
2766fa9e4066Sahrens 		else if (strcmp(cmdname, "volfini") == 0)
2767fa9e4066Sahrens 			return (do_volcheck(FALSE));
2768fa9e4066Sahrens 
2769fa9e4066Sahrens 		/*
2770fa9e4066Sahrens 		 * Run the appropriate command.
2771fa9e4066Sahrens 		 */
2772fa9e4066Sahrens 		for (i = 0; i < NCOMMAND; i++) {
2773fa9e4066Sahrens 			if (command_table[i].name == NULL)
2774fa9e4066Sahrens 				continue;
2775fa9e4066Sahrens 
2776fa9e4066Sahrens 			if (strcmp(cmdname, command_table[i].name) == 0) {
2777fa9e4066Sahrens 				current_command = &command_table[i];
2778fa9e4066Sahrens 				ret = command_table[i].func(argc - 1, argv + 1);
2779fa9e4066Sahrens 				break;
2780fa9e4066Sahrens 			}
2781fa9e4066Sahrens 		}
2782fa9e4066Sahrens 
2783fa9e4066Sahrens 		if (i == NCOMMAND) {
2784fa9e4066Sahrens 			(void) fprintf(stderr, gettext("unrecognized "
2785fa9e4066Sahrens 			    "command '%s'\n"), cmdname);
2786fa9e4066Sahrens 			usage(FALSE);
2787fa9e4066Sahrens 		}
2788fa9e4066Sahrens 	}
2789fa9e4066Sahrens 
2790fa9e4066Sahrens 	(void) fclose(mnttab_file);
2791fa9e4066Sahrens 
2792fa9e4066Sahrens 	/*
2793fa9e4066Sahrens 	 * The 'ZFS_ABORT' environment variable causes us to dump core on exit
2794fa9e4066Sahrens 	 * for the purposes of running ::findleaks.
2795fa9e4066Sahrens 	 */
2796fa9e4066Sahrens 	if (getenv("ZFS_ABORT") != NULL) {
2797fa9e4066Sahrens 		(void) printf("dumping core by request\n");
2798fa9e4066Sahrens 		abort();
2799fa9e4066Sahrens 	}
2800fa9e4066Sahrens 
2801fa9e4066Sahrens 	return (ret);
2802fa9e4066Sahrens }
2803