xref: /illumos-gate/usr/src/uts/common/fs/zfs/zfs_ioctl.c (revision e9dbad6f)
1fa9e4066Sahrens /*
2fa9e4066Sahrens  * CDDL HEADER START
3fa9e4066Sahrens  *
4fa9e4066Sahrens  * The contents of this file are subject to the terms of the
5441d80aaSlling  * Common Development and Distribution License (the "License").
6441d80aaSlling  * You may not use this file except in compliance with the License.
7fa9e4066Sahrens  *
8fa9e4066Sahrens  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9fa9e4066Sahrens  * or http://www.opensolaris.org/os/licensing.
10fa9e4066Sahrens  * See the License for the specific language governing permissions
11fa9e4066Sahrens  * and limitations under the License.
12fa9e4066Sahrens  *
13fa9e4066Sahrens  * When distributing Covered Code, include this CDDL HEADER in each
14fa9e4066Sahrens  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15fa9e4066Sahrens  * If applicable, add the following below this CDDL HEADER, with the
16fa9e4066Sahrens  * fields enclosed by brackets "[]" replaced with your own identifying
17fa9e4066Sahrens  * information: Portions Copyright [yyyy] [name of copyright owner]
18fa9e4066Sahrens  *
19fa9e4066Sahrens  * CDDL HEADER END
20fa9e4066Sahrens  */
21fa9e4066Sahrens /*
22c67d9675Seschrock  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
23fa9e4066Sahrens  * Use is subject to license terms.
24fa9e4066Sahrens  */
25fa9e4066Sahrens 
26fa9e4066Sahrens #pragma ident	"%Z%%M%	%I%	%E% SMI"
27fa9e4066Sahrens 
28fa9e4066Sahrens #include <sys/types.h>
29fa9e4066Sahrens #include <sys/param.h>
30fa9e4066Sahrens #include <sys/errno.h>
31fa9e4066Sahrens #include <sys/uio.h>
32fa9e4066Sahrens #include <sys/buf.h>
33fa9e4066Sahrens #include <sys/modctl.h>
34fa9e4066Sahrens #include <sys/open.h>
35fa9e4066Sahrens #include <sys/file.h>
36fa9e4066Sahrens #include <sys/kmem.h>
37fa9e4066Sahrens #include <sys/conf.h>
38fa9e4066Sahrens #include <sys/cmn_err.h>
39fa9e4066Sahrens #include <sys/stat.h>
40fa9e4066Sahrens #include <sys/zfs_ioctl.h>
41fa9e4066Sahrens #include <sys/zap.h>
42fa9e4066Sahrens #include <sys/spa.h>
43fa9e4066Sahrens #include <sys/vdev.h>
44fa9e4066Sahrens #include <sys/dmu.h>
45fa9e4066Sahrens #include <sys/dsl_dir.h>
46fa9e4066Sahrens #include <sys/dsl_dataset.h>
47fa9e4066Sahrens #include <sys/dsl_prop.h>
48fa9e4066Sahrens #include <sys/ddi.h>
49fa9e4066Sahrens #include <sys/sunddi.h>
50fa9e4066Sahrens #include <sys/sunldi.h>
51fa9e4066Sahrens #include <sys/policy.h>
52fa9e4066Sahrens #include <sys/zone.h>
53fa9e4066Sahrens #include <sys/nvpair.h>
54fa9e4066Sahrens #include <sys/pathname.h>
55fa9e4066Sahrens #include <sys/mount.h>
56fa9e4066Sahrens #include <sys/sdt.h>
57fa9e4066Sahrens #include <sys/fs/zfs.h>
58fa9e4066Sahrens #include <sys/zfs_ctldir.h>
59fa9e4066Sahrens 
60fa9e4066Sahrens #include "zfs_namecheck.h"
61*e9dbad6fSeschrock #include "zfs_prop.h"
62fa9e4066Sahrens 
63fa9e4066Sahrens extern struct modlfs zfs_modlfs;
64fa9e4066Sahrens 
65fa9e4066Sahrens extern void zfs_init(void);
66fa9e4066Sahrens extern void zfs_fini(void);
67fa9e4066Sahrens 
68fa9e4066Sahrens ldi_ident_t zfs_li = NULL;
69fa9e4066Sahrens dev_info_t *zfs_dip;
70fa9e4066Sahrens 
71fa9e4066Sahrens typedef int zfs_ioc_func_t(zfs_cmd_t *);
72*e9dbad6fSeschrock typedef int zfs_secpolicy_func_t(const char *, cred_t *);
73fa9e4066Sahrens 
74fa9e4066Sahrens typedef struct zfs_ioc_vec {
75fa9e4066Sahrens 	zfs_ioc_func_t		*zvec_func;
76fa9e4066Sahrens 	zfs_secpolicy_func_t	*zvec_secpolicy;
77fa9e4066Sahrens 	enum {
78fa9e4066Sahrens 		no_name,
79fa9e4066Sahrens 		pool_name,
80fa9e4066Sahrens 		dataset_name
81fa9e4066Sahrens 	}			zvec_namecheck;
82fa9e4066Sahrens } zfs_ioc_vec_t;
83fa9e4066Sahrens 
84fa9e4066Sahrens /* _NOTE(PRINTFLIKE(4)) - this is printf-like, but lint is too whiney */
85fa9e4066Sahrens void
86fa9e4066Sahrens __dprintf(const char *file, const char *func, int line, const char *fmt, ...)
87fa9e4066Sahrens {
88fa9e4066Sahrens 	const char *newfile;
89fa9e4066Sahrens 	char buf[256];
90fa9e4066Sahrens 	va_list adx;
91fa9e4066Sahrens 
92fa9e4066Sahrens 	/*
93fa9e4066Sahrens 	 * Get rid of annoying "../common/" prefix to filename.
94fa9e4066Sahrens 	 */
95fa9e4066Sahrens 	newfile = strrchr(file, '/');
96fa9e4066Sahrens 	if (newfile != NULL) {
97fa9e4066Sahrens 		newfile = newfile + 1; /* Get rid of leading / */
98fa9e4066Sahrens 	} else {
99fa9e4066Sahrens 		newfile = file;
100fa9e4066Sahrens 	}
101fa9e4066Sahrens 
102fa9e4066Sahrens 	va_start(adx, fmt);
103fa9e4066Sahrens 	(void) vsnprintf(buf, sizeof (buf), fmt, adx);
104fa9e4066Sahrens 	va_end(adx);
105fa9e4066Sahrens 
106fa9e4066Sahrens 	/*
107fa9e4066Sahrens 	 * To get this data, use the zfs-dprintf probe as so:
108fa9e4066Sahrens 	 * dtrace -q -n 'zfs-dprintf \
109fa9e4066Sahrens 	 *	/stringof(arg0) == "dbuf.c"/ \
110fa9e4066Sahrens 	 *	{printf("%s: %s", stringof(arg1), stringof(arg3))}'
111fa9e4066Sahrens 	 * arg0 = file name
112fa9e4066Sahrens 	 * arg1 = function name
113fa9e4066Sahrens 	 * arg2 = line number
114fa9e4066Sahrens 	 * arg3 = message
115fa9e4066Sahrens 	 */
116fa9e4066Sahrens 	DTRACE_PROBE4(zfs__dprintf,
117fa9e4066Sahrens 	    char *, newfile, char *, func, int, line, char *, buf);
118fa9e4066Sahrens }
119fa9e4066Sahrens 
120fa9e4066Sahrens /*
121fa9e4066Sahrens  * Policy for top-level read operations (list pools).  Requires no privileges,
122fa9e4066Sahrens  * and can be used in the local zone, as there is no associated dataset.
123fa9e4066Sahrens  */
124fa9e4066Sahrens /* ARGSUSED */
125fa9e4066Sahrens static int
126*e9dbad6fSeschrock zfs_secpolicy_none(const char *unused1, cred_t *cr)
127fa9e4066Sahrens {
128fa9e4066Sahrens 	return (0);
129fa9e4066Sahrens }
130fa9e4066Sahrens 
131fa9e4066Sahrens /*
132fa9e4066Sahrens  * Policy for dataset read operations (list children, get statistics).  Requires
133fa9e4066Sahrens  * no privileges, but must be visible in the local zone.
134fa9e4066Sahrens  */
135fa9e4066Sahrens /* ARGSUSED */
136fa9e4066Sahrens static int
137*e9dbad6fSeschrock zfs_secpolicy_read(const char *dataset, cred_t *cr)
138fa9e4066Sahrens {
139fa9e4066Sahrens 	if (INGLOBALZONE(curproc) ||
140fa9e4066Sahrens 	    zone_dataset_visible(dataset, NULL))
141fa9e4066Sahrens 		return (0);
142fa9e4066Sahrens 
143fa9e4066Sahrens 	return (ENOENT);
144fa9e4066Sahrens }
145fa9e4066Sahrens 
146fa9e4066Sahrens static int
147fa9e4066Sahrens zfs_dozonecheck(const char *dataset, cred_t *cr)
148fa9e4066Sahrens {
149fa9e4066Sahrens 	uint64_t zoned;
150fa9e4066Sahrens 	int writable = 1;
151fa9e4066Sahrens 
152fa9e4066Sahrens 	/*
153fa9e4066Sahrens 	 * The dataset must be visible by this zone -- check this first
154fa9e4066Sahrens 	 * so they don't see EPERM on something they shouldn't know about.
155fa9e4066Sahrens 	 */
156fa9e4066Sahrens 	if (!INGLOBALZONE(curproc) &&
157fa9e4066Sahrens 	    !zone_dataset_visible(dataset, &writable))
158fa9e4066Sahrens 		return (ENOENT);
159fa9e4066Sahrens 
160fa9e4066Sahrens 	if (dsl_prop_get_integer(dataset, "zoned", &zoned, NULL))
161fa9e4066Sahrens 		return (ENOENT);
162fa9e4066Sahrens 
163fa9e4066Sahrens 	if (INGLOBALZONE(curproc)) {
164fa9e4066Sahrens 		/*
165fa9e4066Sahrens 		 * If the fs is zoned, only root can access it from the
166fa9e4066Sahrens 		 * global zone.
167fa9e4066Sahrens 		 */
168fa9e4066Sahrens 		if (secpolicy_zfs(cr) && zoned)
169fa9e4066Sahrens 			return (EPERM);
170fa9e4066Sahrens 	} else {
171fa9e4066Sahrens 		/*
172fa9e4066Sahrens 		 * If we are in a local zone, the 'zoned' property must be set.
173fa9e4066Sahrens 		 */
174fa9e4066Sahrens 		if (!zoned)
175fa9e4066Sahrens 			return (EPERM);
176fa9e4066Sahrens 
177fa9e4066Sahrens 		/* must be writable by this zone */
178fa9e4066Sahrens 		if (!writable)
179fa9e4066Sahrens 			return (EPERM);
180fa9e4066Sahrens 	}
181fa9e4066Sahrens 	return (0);
182fa9e4066Sahrens }
183fa9e4066Sahrens 
184fa9e4066Sahrens /*
185fa9e4066Sahrens  * Policy for dataset write operations (create children, set properties, etc).
186fa9e4066Sahrens  * Requires SYS_MOUNT privilege, and must be writable in the local zone.
187fa9e4066Sahrens  */
188fa9e4066Sahrens int
189*e9dbad6fSeschrock zfs_secpolicy_write(const char *dataset, cred_t *cr)
190fa9e4066Sahrens {
191fa9e4066Sahrens 	int error;
192fa9e4066Sahrens 
193fa9e4066Sahrens 	if (error = zfs_dozonecheck(dataset, cr))
194fa9e4066Sahrens 		return (error);
195fa9e4066Sahrens 
196fa9e4066Sahrens 	return (secpolicy_zfs(cr));
197fa9e4066Sahrens }
198fa9e4066Sahrens 
199fa9e4066Sahrens /*
200fa9e4066Sahrens  * Policy for operations that want to write a dataset's parent:
201fa9e4066Sahrens  * create, destroy, snapshot, clone, restore.
202fa9e4066Sahrens  */
203fa9e4066Sahrens static int
204*e9dbad6fSeschrock zfs_secpolicy_parent(const char *dataset, cred_t *cr)
205fa9e4066Sahrens {
206fa9e4066Sahrens 	char parentname[MAXNAMELEN];
207fa9e4066Sahrens 	char *cp;
208fa9e4066Sahrens 
209fa9e4066Sahrens 	/*
210fa9e4066Sahrens 	 * Remove the @bla or /bla from the end of the name to get the parent.
211fa9e4066Sahrens 	 */
212fa9e4066Sahrens 	(void) strncpy(parentname, dataset, sizeof (parentname));
213fa9e4066Sahrens 	cp = strrchr(parentname, '@');
214fa9e4066Sahrens 	if (cp != NULL) {
215fa9e4066Sahrens 		cp[0] = '\0';
216fa9e4066Sahrens 	} else {
217fa9e4066Sahrens 		cp = strrchr(parentname, '/');
218fa9e4066Sahrens 		if (cp == NULL)
219fa9e4066Sahrens 			return (ENOENT);
220fa9e4066Sahrens 		cp[0] = '\0';
221fa9e4066Sahrens 
222fa9e4066Sahrens 	}
223fa9e4066Sahrens 
224*e9dbad6fSeschrock 	return (zfs_secpolicy_write(parentname, cr));
225fa9e4066Sahrens }
226fa9e4066Sahrens 
227fa9e4066Sahrens /*
228fa9e4066Sahrens  * Policy for pool operations - create/destroy pools, add vdevs, etc.  Requires
229fa9e4066Sahrens  * SYS_CONFIG privilege, which is not available in a local zone.
230fa9e4066Sahrens  */
231fa9e4066Sahrens /* ARGSUSED */
232fa9e4066Sahrens static int
233*e9dbad6fSeschrock zfs_secpolicy_config(const char *unused, cred_t *cr)
234fa9e4066Sahrens {
235fa9e4066Sahrens 	if (secpolicy_sys_config(cr, B_FALSE) != 0)
236fa9e4066Sahrens 		return (EPERM);
237fa9e4066Sahrens 
238fa9e4066Sahrens 	return (0);
239fa9e4066Sahrens }
240fa9e4066Sahrens 
241ea8dc4b6Seschrock /*
242ea8dc4b6Seschrock  * Policy for fault injection.  Requires all privileges.
243ea8dc4b6Seschrock  */
244ea8dc4b6Seschrock /* ARGSUSED */
245ea8dc4b6Seschrock static int
246*e9dbad6fSeschrock zfs_secpolicy_inject(const char *unused, cred_t *cr)
247ea8dc4b6Seschrock {
248ea8dc4b6Seschrock 	return (secpolicy_zinject(cr));
249ea8dc4b6Seschrock }
250ea8dc4b6Seschrock 
251fa9e4066Sahrens /*
252fa9e4066Sahrens  * Returns the nvlist as specified by the user in the zfs_cmd_t.
253fa9e4066Sahrens  */
254fa9e4066Sahrens static int
255*e9dbad6fSeschrock get_nvlist(zfs_cmd_t *zc, nvlist_t **nvp)
256fa9e4066Sahrens {
257fa9e4066Sahrens 	char *packed;
258fa9e4066Sahrens 	size_t size;
259fa9e4066Sahrens 	int error;
260fa9e4066Sahrens 	nvlist_t *config = NULL;
261fa9e4066Sahrens 
262fa9e4066Sahrens 	/*
263*e9dbad6fSeschrock 	 * Read in and unpack the user-supplied nvlist.
264fa9e4066Sahrens 	 */
265*e9dbad6fSeschrock 	if ((size = zc->zc_nvlist_src_size) == 0)
266fa9e4066Sahrens 		return (EINVAL);
267fa9e4066Sahrens 
268fa9e4066Sahrens 	packed = kmem_alloc(size, KM_SLEEP);
269fa9e4066Sahrens 
270*e9dbad6fSeschrock 	if ((error = xcopyin((void *)(uintptr_t)zc->zc_nvlist_src, packed,
271fa9e4066Sahrens 	    size)) != 0) {
272fa9e4066Sahrens 		kmem_free(packed, size);
273fa9e4066Sahrens 		return (error);
274fa9e4066Sahrens 	}
275fa9e4066Sahrens 
276fa9e4066Sahrens 	if ((error = nvlist_unpack(packed, size, &config, 0)) != 0) {
277fa9e4066Sahrens 		kmem_free(packed, size);
278fa9e4066Sahrens 		return (error);
279fa9e4066Sahrens 	}
280fa9e4066Sahrens 
281fa9e4066Sahrens 	kmem_free(packed, size);
282fa9e4066Sahrens 
283fa9e4066Sahrens 	*nvp = config;
284fa9e4066Sahrens 	return (0);
285fa9e4066Sahrens }
286fa9e4066Sahrens 
287*e9dbad6fSeschrock static int
288*e9dbad6fSeschrock put_nvlist(zfs_cmd_t *zc, nvlist_t *nvl)
289*e9dbad6fSeschrock {
290*e9dbad6fSeschrock 	char *packed = NULL;
291*e9dbad6fSeschrock 	size_t size;
292*e9dbad6fSeschrock 	int error;
293*e9dbad6fSeschrock 
294*e9dbad6fSeschrock 	VERIFY(nvlist_size(nvl, &size, NV_ENCODE_NATIVE) == 0);
295*e9dbad6fSeschrock 
296*e9dbad6fSeschrock 	if (size > zc->zc_nvlist_dst_size) {
297*e9dbad6fSeschrock 		error = ENOMEM;
298*e9dbad6fSeschrock 	} else {
299*e9dbad6fSeschrock 		VERIFY(nvlist_pack(nvl, &packed, &size, NV_ENCODE_NATIVE,
300*e9dbad6fSeschrock 		    KM_SLEEP) == 0);
301*e9dbad6fSeschrock 		error = xcopyout(packed, (void *)(uintptr_t)zc->zc_nvlist_dst,
302*e9dbad6fSeschrock 		    size);
303*e9dbad6fSeschrock 		kmem_free(packed, size);
304*e9dbad6fSeschrock 	}
305*e9dbad6fSeschrock 
306*e9dbad6fSeschrock 	zc->zc_nvlist_dst_size = size;
307*e9dbad6fSeschrock 	return (error);
308*e9dbad6fSeschrock }
309*e9dbad6fSeschrock 
310fa9e4066Sahrens static int
311fa9e4066Sahrens zfs_ioc_pool_create(zfs_cmd_t *zc)
312fa9e4066Sahrens {
313fa9e4066Sahrens 	int error;
314fa9e4066Sahrens 	nvlist_t *config;
315fa9e4066Sahrens 
316*e9dbad6fSeschrock 	if ((error = get_nvlist(zc, &config)) != 0)
317fa9e4066Sahrens 		return (error);
318fa9e4066Sahrens 
319*e9dbad6fSeschrock 	error = spa_create(zc->zc_name, config, zc->zc_value[0] == '\0' ?
320*e9dbad6fSeschrock 	    NULL : zc->zc_value);
321fa9e4066Sahrens 
322fa9e4066Sahrens 	nvlist_free(config);
323fa9e4066Sahrens 
324fa9e4066Sahrens 	return (error);
325fa9e4066Sahrens }
326fa9e4066Sahrens 
327fa9e4066Sahrens static int
328fa9e4066Sahrens zfs_ioc_pool_destroy(zfs_cmd_t *zc)
329fa9e4066Sahrens {
330fa9e4066Sahrens 	return (spa_destroy(zc->zc_name));
331fa9e4066Sahrens }
332fa9e4066Sahrens 
333fa9e4066Sahrens static int
334fa9e4066Sahrens zfs_ioc_pool_import(zfs_cmd_t *zc)
335fa9e4066Sahrens {
336fa9e4066Sahrens 	int error;
337fa9e4066Sahrens 	nvlist_t *config;
338fa9e4066Sahrens 	uint64_t guid;
339fa9e4066Sahrens 
340*e9dbad6fSeschrock 	if ((error = get_nvlist(zc, &config)) != 0)
341fa9e4066Sahrens 		return (error);
342fa9e4066Sahrens 
343fa9e4066Sahrens 	if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, &guid) != 0 ||
344ea8dc4b6Seschrock 	    guid != zc->zc_guid)
345fa9e4066Sahrens 		error = EINVAL;
346fa9e4066Sahrens 	else
347fa9e4066Sahrens 		error = spa_import(zc->zc_name, config,
348*e9dbad6fSeschrock 		    zc->zc_value[0] == '\0' ? NULL : zc->zc_value);
349fa9e4066Sahrens 
350fa9e4066Sahrens 	nvlist_free(config);
351fa9e4066Sahrens 
352fa9e4066Sahrens 	return (error);
353fa9e4066Sahrens }
354fa9e4066Sahrens 
355fa9e4066Sahrens static int
356fa9e4066Sahrens zfs_ioc_pool_export(zfs_cmd_t *zc)
357fa9e4066Sahrens {
35844cd46caSbillm 	return (spa_export(zc->zc_name, NULL));
359fa9e4066Sahrens }
360fa9e4066Sahrens 
361fa9e4066Sahrens static int
362fa9e4066Sahrens zfs_ioc_pool_configs(zfs_cmd_t *zc)
363fa9e4066Sahrens {
364fa9e4066Sahrens 	nvlist_t *configs;
365fa9e4066Sahrens 	int error;
366fa9e4066Sahrens 
367fa9e4066Sahrens 	if ((configs = spa_all_configs(&zc->zc_cookie)) == NULL)
368fa9e4066Sahrens 		return (EEXIST);
369fa9e4066Sahrens 
370*e9dbad6fSeschrock 	error = put_nvlist(zc, configs);
371fa9e4066Sahrens 
372fa9e4066Sahrens 	nvlist_free(configs);
373fa9e4066Sahrens 
374fa9e4066Sahrens 	return (error);
375fa9e4066Sahrens }
376fa9e4066Sahrens 
377fa9e4066Sahrens static int
378fa9e4066Sahrens zfs_ioc_pool_stats(zfs_cmd_t *zc)
379fa9e4066Sahrens {
380fa9e4066Sahrens 	nvlist_t *config;
381fa9e4066Sahrens 	int error;
382ea8dc4b6Seschrock 	int ret = 0;
383fa9e4066Sahrens 
384*e9dbad6fSeschrock 	error = spa_get_stats(zc->zc_name, &config, zc->zc_value,
385*e9dbad6fSeschrock 	    sizeof (zc->zc_value));
386fa9e4066Sahrens 
387fa9e4066Sahrens 	if (config != NULL) {
388*e9dbad6fSeschrock 		ret = put_nvlist(zc, config);
389fa9e4066Sahrens 		nvlist_free(config);
390ea8dc4b6Seschrock 
391ea8dc4b6Seschrock 		/*
392ea8dc4b6Seschrock 		 * The config may be present even if 'error' is non-zero.
393ea8dc4b6Seschrock 		 * In this case we return success, and preserve the real errno
394ea8dc4b6Seschrock 		 * in 'zc_cookie'.
395ea8dc4b6Seschrock 		 */
396ea8dc4b6Seschrock 		zc->zc_cookie = error;
397fa9e4066Sahrens 	} else {
398ea8dc4b6Seschrock 		ret = error;
399fa9e4066Sahrens 	}
400fa9e4066Sahrens 
401ea8dc4b6Seschrock 	return (ret);
402fa9e4066Sahrens }
403fa9e4066Sahrens 
404fa9e4066Sahrens /*
405fa9e4066Sahrens  * Try to import the given pool, returning pool stats as appropriate so that
406fa9e4066Sahrens  * user land knows which devices are available and overall pool health.
407fa9e4066Sahrens  */
408fa9e4066Sahrens static int
409fa9e4066Sahrens zfs_ioc_pool_tryimport(zfs_cmd_t *zc)
410fa9e4066Sahrens {
411fa9e4066Sahrens 	nvlist_t *tryconfig, *config;
412fa9e4066Sahrens 	int error;
413fa9e4066Sahrens 
414*e9dbad6fSeschrock 	if ((error = get_nvlist(zc, &tryconfig)) != 0)
415fa9e4066Sahrens 		return (error);
416fa9e4066Sahrens 
417fa9e4066Sahrens 	config = spa_tryimport(tryconfig);
418fa9e4066Sahrens 
419fa9e4066Sahrens 	nvlist_free(tryconfig);
420fa9e4066Sahrens 
421fa9e4066Sahrens 	if (config == NULL)
422fa9e4066Sahrens 		return (EINVAL);
423fa9e4066Sahrens 
424*e9dbad6fSeschrock 	error = put_nvlist(zc, config);
425fa9e4066Sahrens 	nvlist_free(config);
426fa9e4066Sahrens 
427fa9e4066Sahrens 	return (error);
428fa9e4066Sahrens }
429fa9e4066Sahrens 
430fa9e4066Sahrens static int
431fa9e4066Sahrens zfs_ioc_pool_scrub(zfs_cmd_t *zc)
432fa9e4066Sahrens {
433fa9e4066Sahrens 	spa_t *spa;
434fa9e4066Sahrens 	int error;
435fa9e4066Sahrens 
436fa9e4066Sahrens 	error = spa_open(zc->zc_name, &spa, FTAG);
437fa9e4066Sahrens 	if (error == 0) {
438fa9e4066Sahrens 		error = spa_scrub(spa, zc->zc_cookie, B_FALSE);
439fa9e4066Sahrens 		spa_close(spa, FTAG);
440fa9e4066Sahrens 	}
441fa9e4066Sahrens 	return (error);
442fa9e4066Sahrens }
443fa9e4066Sahrens 
444fa9e4066Sahrens static int
445fa9e4066Sahrens zfs_ioc_pool_freeze(zfs_cmd_t *zc)
446fa9e4066Sahrens {
447fa9e4066Sahrens 	spa_t *spa;
448fa9e4066Sahrens 	int error;
449fa9e4066Sahrens 
450fa9e4066Sahrens 	error = spa_open(zc->zc_name, &spa, FTAG);
451fa9e4066Sahrens 	if (error == 0) {
452fa9e4066Sahrens 		spa_freeze(spa);
453fa9e4066Sahrens 		spa_close(spa, FTAG);
454fa9e4066Sahrens 	}
455fa9e4066Sahrens 	return (error);
456fa9e4066Sahrens }
457fa9e4066Sahrens 
458eaca9bbdSeschrock static int
459eaca9bbdSeschrock zfs_ioc_pool_upgrade(zfs_cmd_t *zc)
460eaca9bbdSeschrock {
461eaca9bbdSeschrock 	spa_t *spa;
462eaca9bbdSeschrock 	int error;
463eaca9bbdSeschrock 
464eaca9bbdSeschrock 	error = spa_open(zc->zc_name, &spa, FTAG);
465eaca9bbdSeschrock 	if (error == 0) {
466eaca9bbdSeschrock 		spa_upgrade(spa);
467eaca9bbdSeschrock 		spa_close(spa, FTAG);
468eaca9bbdSeschrock 	}
469eaca9bbdSeschrock 	return (error);
470eaca9bbdSeschrock }
471eaca9bbdSeschrock 
472fa9e4066Sahrens static int
473fa9e4066Sahrens zfs_ioc_vdev_add(zfs_cmd_t *zc)
474fa9e4066Sahrens {
475fa9e4066Sahrens 	spa_t *spa;
476fa9e4066Sahrens 	int error;
477fa9e4066Sahrens 	nvlist_t *config;
478fa9e4066Sahrens 
479fa9e4066Sahrens 	error = spa_open(zc->zc_name, &spa, FTAG);
480fa9e4066Sahrens 	if (error != 0)
481fa9e4066Sahrens 		return (error);
482fa9e4066Sahrens 
483*e9dbad6fSeschrock 	if ((error = get_nvlist(zc, &config)) == 0) {
484fa9e4066Sahrens 		error = spa_vdev_add(spa, config);
485fa9e4066Sahrens 		nvlist_free(config);
486fa9e4066Sahrens 	}
487fa9e4066Sahrens 
488fa9e4066Sahrens 	spa_close(spa, FTAG);
489fa9e4066Sahrens 	return (error);
490fa9e4066Sahrens }
491fa9e4066Sahrens 
492fa9e4066Sahrens static int
493fa9e4066Sahrens zfs_ioc_vdev_remove(zfs_cmd_t *zc)
494fa9e4066Sahrens {
49599653d4eSeschrock 	spa_t *spa;
49699653d4eSeschrock 	int error;
49799653d4eSeschrock 
49899653d4eSeschrock 	error = spa_open(zc->zc_name, &spa, FTAG);
49999653d4eSeschrock 	if (error != 0)
50099653d4eSeschrock 		return (error);
50199653d4eSeschrock 	error = spa_vdev_remove(spa, zc->zc_guid, B_FALSE);
50299653d4eSeschrock 	spa_close(spa, FTAG);
50399653d4eSeschrock 	return (error);
504fa9e4066Sahrens }
505fa9e4066Sahrens 
506fa9e4066Sahrens static int
507fa9e4066Sahrens zfs_ioc_vdev_online(zfs_cmd_t *zc)
508fa9e4066Sahrens {
509fa9e4066Sahrens 	spa_t *spa;
510fa9e4066Sahrens 	int error;
511fa9e4066Sahrens 
512fa9e4066Sahrens 	error = spa_open(zc->zc_name, &spa, FTAG);
513fa9e4066Sahrens 	if (error != 0)
514fa9e4066Sahrens 		return (error);
515ea8dc4b6Seschrock 	error = vdev_online(spa, zc->zc_guid);
516fa9e4066Sahrens 	spa_close(spa, FTAG);
517fa9e4066Sahrens 	return (error);
518fa9e4066Sahrens }
519fa9e4066Sahrens 
520fa9e4066Sahrens static int
521fa9e4066Sahrens zfs_ioc_vdev_offline(zfs_cmd_t *zc)
522fa9e4066Sahrens {
523fa9e4066Sahrens 	spa_t *spa;
524441d80aaSlling 	int istmp = zc->zc_cookie;
525fa9e4066Sahrens 	int error;
526fa9e4066Sahrens 
527fa9e4066Sahrens 	error = spa_open(zc->zc_name, &spa, FTAG);
528fa9e4066Sahrens 	if (error != 0)
529fa9e4066Sahrens 		return (error);
530ea8dc4b6Seschrock 	error = vdev_offline(spa, zc->zc_guid, istmp);
531fa9e4066Sahrens 	spa_close(spa, FTAG);
532fa9e4066Sahrens 	return (error);
533fa9e4066Sahrens }
534fa9e4066Sahrens 
535fa9e4066Sahrens static int
536fa9e4066Sahrens zfs_ioc_vdev_attach(zfs_cmd_t *zc)
537fa9e4066Sahrens {
538fa9e4066Sahrens 	spa_t *spa;
539fa9e4066Sahrens 	int replacing = zc->zc_cookie;
540fa9e4066Sahrens 	nvlist_t *config;
541fa9e4066Sahrens 	int error;
542fa9e4066Sahrens 
543fa9e4066Sahrens 	error = spa_open(zc->zc_name, &spa, FTAG);
544fa9e4066Sahrens 	if (error != 0)
545fa9e4066Sahrens 		return (error);
546fa9e4066Sahrens 
547*e9dbad6fSeschrock 	if ((error = get_nvlist(zc, &config)) == 0) {
548ea8dc4b6Seschrock 		error = spa_vdev_attach(spa, zc->zc_guid, config, replacing);
549fa9e4066Sahrens 		nvlist_free(config);
550fa9e4066Sahrens 	}
551fa9e4066Sahrens 
552fa9e4066Sahrens 	spa_close(spa, FTAG);
553fa9e4066Sahrens 	return (error);
554fa9e4066Sahrens }
555fa9e4066Sahrens 
556fa9e4066Sahrens static int
557fa9e4066Sahrens zfs_ioc_vdev_detach(zfs_cmd_t *zc)
558fa9e4066Sahrens {
559fa9e4066Sahrens 	spa_t *spa;
560fa9e4066Sahrens 	int error;
561fa9e4066Sahrens 
562fa9e4066Sahrens 	error = spa_open(zc->zc_name, &spa, FTAG);
563fa9e4066Sahrens 	if (error != 0)
564fa9e4066Sahrens 		return (error);
565fa9e4066Sahrens 
566ea8dc4b6Seschrock 	error = spa_vdev_detach(spa, zc->zc_guid, B_FALSE);
567fa9e4066Sahrens 
568fa9e4066Sahrens 	spa_close(spa, FTAG);
569fa9e4066Sahrens 	return (error);
570fa9e4066Sahrens }
571fa9e4066Sahrens 
572c67d9675Seschrock static int
573c67d9675Seschrock zfs_ioc_vdev_setpath(zfs_cmd_t *zc)
574c67d9675Seschrock {
575c67d9675Seschrock 	spa_t *spa;
576*e9dbad6fSeschrock 	char *path = zc->zc_value;
577ea8dc4b6Seschrock 	uint64_t guid = zc->zc_guid;
578c67d9675Seschrock 	int error;
579c67d9675Seschrock 
580c67d9675Seschrock 	error = spa_open(zc->zc_name, &spa, FTAG);
581c67d9675Seschrock 	if (error != 0)
582c67d9675Seschrock 		return (error);
583c67d9675Seschrock 
584c67d9675Seschrock 	error = spa_vdev_setpath(spa, guid, path);
585c67d9675Seschrock 
586c67d9675Seschrock 	spa_close(spa, FTAG);
587c67d9675Seschrock 	return (error);
588c67d9675Seschrock }
589c67d9675Seschrock 
590fa9e4066Sahrens static int
591fa9e4066Sahrens zfs_ioc_objset_stats(zfs_cmd_t *zc)
592fa9e4066Sahrens {
593fa9e4066Sahrens 	objset_t *os = NULL;
594fa9e4066Sahrens 	int error;
5957f7322feSeschrock 	nvlist_t *nv;
596fa9e4066Sahrens 
597fa9e4066Sahrens retry:
598fa9e4066Sahrens 	error = dmu_objset_open(zc->zc_name, DMU_OST_ANY,
599fa9e4066Sahrens 	    DS_MODE_STANDARD | DS_MODE_READONLY, &os);
600fa9e4066Sahrens 	if (error != 0) {
601fa9e4066Sahrens 		/*
602fa9e4066Sahrens 		 * This is ugly: dmu_objset_open() can return EBUSY if
603fa9e4066Sahrens 		 * the objset is held exclusively. Fortunately this hold is
604fa9e4066Sahrens 		 * only for a short while, so we retry here.
605fa9e4066Sahrens 		 * This avoids user code having to handle EBUSY,
606fa9e4066Sahrens 		 * for example for a "zfs list".
607fa9e4066Sahrens 		 */
608fa9e4066Sahrens 		if (error == EBUSY) {
609fa9e4066Sahrens 			delay(1);
610fa9e4066Sahrens 			goto retry;
611fa9e4066Sahrens 		}
612fa9e4066Sahrens 		return (error);
613fa9e4066Sahrens 	}
614fa9e4066Sahrens 
615fa9e4066Sahrens 	dmu_objset_stats(os, &zc->zc_objset_stats);
616fa9e4066Sahrens 
617*e9dbad6fSeschrock 	if (zc->zc_nvlist_dst != NULL &&
6187f7322feSeschrock 	    (error = dsl_prop_get_all(os, &nv)) == 0) {
619*e9dbad6fSeschrock 		error = put_nvlist(zc, nv);
6207f7322feSeschrock 		nvlist_free(nv);
6217f7322feSeschrock 	}
622fa9e4066Sahrens 
6237f7322feSeschrock 	if (!error && zc->zc_objset_stats.dds_type == DMU_OST_ZVOL)
624*e9dbad6fSeschrock 		error = zvol_get_stats(os, &zc->zc_vol_stats);
625fa9e4066Sahrens 
626*e9dbad6fSeschrock 	spa_altroot(dmu_objset_spa(os), zc->zc_value, sizeof (zc->zc_value));
627ea8dc4b6Seschrock 
628fa9e4066Sahrens 	dmu_objset_close(os);
629fa9e4066Sahrens 	return (error);
630fa9e4066Sahrens }
631fa9e4066Sahrens 
632fa9e4066Sahrens static int
633fa9e4066Sahrens zfs_ioc_dataset_list_next(zfs_cmd_t *zc)
634fa9e4066Sahrens {
63587e5029aSahrens 	objset_t *os;
636fa9e4066Sahrens 	int error;
637fa9e4066Sahrens 	char *p;
638fa9e4066Sahrens 
63987e5029aSahrens retry:
64087e5029aSahrens 	error = dmu_objset_open(zc->zc_name, DMU_OST_ANY,
64187e5029aSahrens 	    DS_MODE_STANDARD | DS_MODE_READONLY, &os);
64287e5029aSahrens 	if (error != 0) {
64387e5029aSahrens 		/*
64487e5029aSahrens 		 * This is ugly: dmu_objset_open() can return EBUSY if
64587e5029aSahrens 		 * the objset is held exclusively. Fortunately this hold is
64687e5029aSahrens 		 * only for a short while, so we retry here.
64787e5029aSahrens 		 * This avoids user code having to handle EBUSY,
64887e5029aSahrens 		 * for example for a "zfs list".
64987e5029aSahrens 		 */
65087e5029aSahrens 		if (error == EBUSY) {
65187e5029aSahrens 			delay(1);
65287e5029aSahrens 			goto retry;
65387e5029aSahrens 		}
65487e5029aSahrens 		if (error == ENOENT)
65587e5029aSahrens 			error = ESRCH;
65687e5029aSahrens 		return (error);
657fa9e4066Sahrens 	}
658fa9e4066Sahrens 
659fa9e4066Sahrens 	p = strrchr(zc->zc_name, '/');
660fa9e4066Sahrens 	if (p == NULL || p[1] != '\0')
661fa9e4066Sahrens 		(void) strlcat(zc->zc_name, "/", sizeof (zc->zc_name));
662fa9e4066Sahrens 	p = zc->zc_name + strlen(zc->zc_name);
663fa9e4066Sahrens 
664fa9e4066Sahrens 	do {
66587e5029aSahrens 		error = dmu_dir_list_next(os,
66687e5029aSahrens 		    sizeof (zc->zc_name) - (p - zc->zc_name), p,
66787e5029aSahrens 		    NULL, &zc->zc_cookie);
668fa9e4066Sahrens 		if (error == ENOENT)
669fa9e4066Sahrens 			error = ESRCH;
67087e5029aSahrens 	} while (error == 0 && !INGLOBALZONE(curproc) &&
671fa9e4066Sahrens 	    !zone_dataset_visible(zc->zc_name, NULL));
672fa9e4066Sahrens 
673fa9e4066Sahrens 	/*
67487e5029aSahrens 	 * If it's a hidden dataset (ie. with a '$' in its name), don't
67587e5029aSahrens 	 * try to get stats for it.  Userland will skip over it.
676fa9e4066Sahrens 	 */
67787e5029aSahrens 	if (error == 0 && strchr(zc->zc_name, '$') == NULL)
67887e5029aSahrens 		error = zfs_ioc_objset_stats(zc); /* fill in the stats */
679fa9e4066Sahrens 
68087e5029aSahrens 	dmu_objset_close(os);
681fa9e4066Sahrens 	return (error);
682fa9e4066Sahrens }
683fa9e4066Sahrens 
684fa9e4066Sahrens static int
685fa9e4066Sahrens zfs_ioc_snapshot_list_next(zfs_cmd_t *zc)
686fa9e4066Sahrens {
68787e5029aSahrens 	objset_t *os;
688fa9e4066Sahrens 	int error;
689fa9e4066Sahrens 
690fa9e4066Sahrens retry:
69187e5029aSahrens 	error = dmu_objset_open(zc->zc_name, DMU_OST_ANY,
69287e5029aSahrens 	    DS_MODE_STANDARD | DS_MODE_READONLY, &os);
69387e5029aSahrens 	if (error != 0) {
694fa9e4066Sahrens 		/*
69587e5029aSahrens 		 * This is ugly: dmu_objset_open() can return EBUSY if
696fa9e4066Sahrens 		 * the objset is held exclusively. Fortunately this hold is
697fa9e4066Sahrens 		 * only for a short while, so we retry here.
698fa9e4066Sahrens 		 * This avoids user code having to handle EBUSY,
69987e5029aSahrens 		 * for example for a "zfs list".
700fa9e4066Sahrens 		 */
701fa9e4066Sahrens 		if (error == EBUSY) {
702fa9e4066Sahrens 			delay(1);
703fa9e4066Sahrens 			goto retry;
704fa9e4066Sahrens 		}
705fa9e4066Sahrens 		if (error == ENOENT)
70687e5029aSahrens 			error = ESRCH;
707fa9e4066Sahrens 		return (error);
708fa9e4066Sahrens 	}
709fa9e4066Sahrens 
710b81d61a6Slling 	/*
711b81d61a6Slling 	 * A dataset name of maximum length cannot have any snapshots,
712b81d61a6Slling 	 * so exit immediately.
713b81d61a6Slling 	 */
714b81d61a6Slling 	if (strlcat(zc->zc_name, "@", sizeof (zc->zc_name)) >= MAXNAMELEN) {
71587e5029aSahrens 		dmu_objset_close(os);
716b81d61a6Slling 		return (ESRCH);
717fa9e4066Sahrens 	}
718fa9e4066Sahrens 
71987e5029aSahrens 	error = dmu_snapshot_list_next(os,
72087e5029aSahrens 	    sizeof (zc->zc_name) - strlen(zc->zc_name),
72187e5029aSahrens 	    zc->zc_name + strlen(zc->zc_name), NULL, &zc->zc_cookie);
72287e5029aSahrens 	if (error == ENOENT)
72387e5029aSahrens 		error = ESRCH;
724fa9e4066Sahrens 
72587e5029aSahrens 	if (error == 0)
72687e5029aSahrens 		error = zfs_ioc_objset_stats(zc); /* fill in the stats */
727fa9e4066Sahrens 
72887e5029aSahrens 	dmu_objset_close(os);
729fa9e4066Sahrens 	return (error);
730fa9e4066Sahrens }
731fa9e4066Sahrens 
732fa9e4066Sahrens static int
733*e9dbad6fSeschrock zfs_set_prop_nvlist(const char *name, dev_t dev, cred_t *cr, nvlist_t *nvl)
734fa9e4066Sahrens {
735*e9dbad6fSeschrock 	nvpair_t *elem;
736*e9dbad6fSeschrock 	int error;
737*e9dbad6fSeschrock 	const char *propname;
738*e9dbad6fSeschrock 	zfs_prop_t prop;
739*e9dbad6fSeschrock 	uint64_t intval;
740*e9dbad6fSeschrock 	char *strval;
741*e9dbad6fSeschrock 
742*e9dbad6fSeschrock 	elem = NULL;
743*e9dbad6fSeschrock 	while ((elem = nvlist_next_nvpair(nvl, elem)) != NULL) {
744*e9dbad6fSeschrock 		propname = nvpair_name(elem);
745*e9dbad6fSeschrock 
746*e9dbad6fSeschrock 		if ((prop = zfs_name_to_prop(propname)) ==
747*e9dbad6fSeschrock 		    ZFS_PROP_INVAL) {
748*e9dbad6fSeschrock 			/*
749*e9dbad6fSeschrock 			 * If this is a user-defined property, it must be a
750*e9dbad6fSeschrock 			 * string, and there is no further validation to do.
751*e9dbad6fSeschrock 			 */
752*e9dbad6fSeschrock 			if (!zfs_prop_user(propname) ||
753*e9dbad6fSeschrock 			    nvpair_type(elem) != DATA_TYPE_STRING)
754*e9dbad6fSeschrock 				return (EINVAL);
755*e9dbad6fSeschrock 
756*e9dbad6fSeschrock 			VERIFY(nvpair_value_string(elem, &strval) == 0);
757*e9dbad6fSeschrock 			error = dsl_prop_set(name, propname, 1,
758*e9dbad6fSeschrock 			    strlen(strval) + 1, strval);
759*e9dbad6fSeschrock 			if (error == 0)
760*e9dbad6fSeschrock 				continue;
761*e9dbad6fSeschrock 			else
762*e9dbad6fSeschrock 				break;
763*e9dbad6fSeschrock 		}
764fa9e4066Sahrens 
765*e9dbad6fSeschrock 		/*
766*e9dbad6fSeschrock 		 * Check permissions for special properties.
767*e9dbad6fSeschrock 		 */
768*e9dbad6fSeschrock 		switch (prop) {
769*e9dbad6fSeschrock 		case ZFS_PROP_ZONED:
770*e9dbad6fSeschrock 			/*
771*e9dbad6fSeschrock 			 * Disallow setting of 'zoned' from within a local zone.
772*e9dbad6fSeschrock 			 */
773*e9dbad6fSeschrock 			if (!INGLOBALZONE(curproc))
774*e9dbad6fSeschrock 				return (EPERM);
775*e9dbad6fSeschrock 			break;
776fa9e4066Sahrens 
777*e9dbad6fSeschrock 		case ZFS_PROP_QUOTA:
778*e9dbad6fSeschrock 			if (error = zfs_dozonecheck(name, cr))
779*e9dbad6fSeschrock 				return (error);
780fa9e4066Sahrens 
781*e9dbad6fSeschrock 			if (!INGLOBALZONE(curproc)) {
782*e9dbad6fSeschrock 				uint64_t zoned;
783*e9dbad6fSeschrock 				char setpoint[MAXNAMELEN];
784*e9dbad6fSeschrock 				int dslen;
785*e9dbad6fSeschrock 				/*
786*e9dbad6fSeschrock 				 * Unprivileged users are allowed to modify the
787*e9dbad6fSeschrock 				 * quota on things *under* (ie. contained by)
788*e9dbad6fSeschrock 				 * the thing they own.
789*e9dbad6fSeschrock 				 */
790*e9dbad6fSeschrock 				if (dsl_prop_get_integer(name, "zoned", &zoned,
791*e9dbad6fSeschrock 				    setpoint))
792*e9dbad6fSeschrock 					return (EPERM);
793*e9dbad6fSeschrock 				if (!zoned) /* this shouldn't happen */
794*e9dbad6fSeschrock 					return (EPERM);
795*e9dbad6fSeschrock 				dslen = strlen(name);
796*e9dbad6fSeschrock 				if (dslen <= strlen(setpoint))
797*e9dbad6fSeschrock 					return (EPERM);
798*e9dbad6fSeschrock 			}
799*e9dbad6fSeschrock 		}
800*e9dbad6fSeschrock 
801*e9dbad6fSeschrock 		switch (prop) {
802*e9dbad6fSeschrock 		case ZFS_PROP_QUOTA:
803*e9dbad6fSeschrock 			if ((error = nvpair_value_uint64(elem, &intval)) != 0 ||
804*e9dbad6fSeschrock 			    (error = dsl_dir_set_quota(name,
805*e9dbad6fSeschrock 			    intval)) != 0)
806*e9dbad6fSeschrock 				return (error);
807*e9dbad6fSeschrock 			break;
808*e9dbad6fSeschrock 
809*e9dbad6fSeschrock 		case ZFS_PROP_RESERVATION:
810*e9dbad6fSeschrock 			if ((error = nvpair_value_uint64(elem, &intval)) != 0 ||
811*e9dbad6fSeschrock 			    (error = dsl_dir_set_reservation(name,
812*e9dbad6fSeschrock 			    intval)) != 0)
813*e9dbad6fSeschrock 				return (error);
814*e9dbad6fSeschrock 			break;
815*e9dbad6fSeschrock 
816*e9dbad6fSeschrock 		case ZFS_PROP_VOLSIZE:
817*e9dbad6fSeschrock 			if ((error = nvpair_value_uint64(elem, &intval)) != 0 ||
818*e9dbad6fSeschrock 			    (error = zvol_set_volsize(name, dev,
819*e9dbad6fSeschrock 			    intval)) != 0)
820*e9dbad6fSeschrock 				return (error);
821*e9dbad6fSeschrock 			break;
822*e9dbad6fSeschrock 
823*e9dbad6fSeschrock 		case ZFS_PROP_VOLBLOCKSIZE:
824*e9dbad6fSeschrock 			if ((error = nvpair_value_uint64(elem, &intval)) != 0 ||
825*e9dbad6fSeschrock 			    (error = zvol_set_volblocksize(name,
826*e9dbad6fSeschrock 			    intval)) != 0)
827*e9dbad6fSeschrock 				return (error);
828*e9dbad6fSeschrock 			break;
829*e9dbad6fSeschrock 
830*e9dbad6fSeschrock 		default:
831*e9dbad6fSeschrock 			if (nvpair_type(elem) == DATA_TYPE_STRING) {
832*e9dbad6fSeschrock 				if (zfs_prop_get_type(prop) !=
833*e9dbad6fSeschrock 				    prop_type_string)
834*e9dbad6fSeschrock 					return (EINVAL);
835*e9dbad6fSeschrock 				ASSERT(nvpair_value_string(elem, &strval) == 0);
836*e9dbad6fSeschrock 				error = dsl_prop_set(name,
837*e9dbad6fSeschrock 				    nvpair_name(elem), 1, strlen(strval) + 1,
838*e9dbad6fSeschrock 				    strval);
839*e9dbad6fSeschrock 			} else if (nvpair_type(elem) == DATA_TYPE_UINT64) {
840*e9dbad6fSeschrock 				ASSERT(nvpair_value_uint64(elem, &intval) == 0);
841*e9dbad6fSeschrock 
842*e9dbad6fSeschrock 				switch (zfs_prop_get_type(prop)) {
843*e9dbad6fSeschrock 				case prop_type_number:
844*e9dbad6fSeschrock 					break;
845*e9dbad6fSeschrock 				case prop_type_boolean:
846*e9dbad6fSeschrock 					if (intval > 1)
847*e9dbad6fSeschrock 						error = EINVAL;
848*e9dbad6fSeschrock 					break;
849*e9dbad6fSeschrock 				case prop_type_string:
850*e9dbad6fSeschrock 					error = EINVAL;
851*e9dbad6fSeschrock 					break;
852*e9dbad6fSeschrock 				case prop_type_index:
853*e9dbad6fSeschrock 					switch (prop) {
854*e9dbad6fSeschrock 					case ZFS_PROP_CHECKSUM:
855*e9dbad6fSeschrock 						if (intval >=
856*e9dbad6fSeschrock 						    ZIO_CHECKSUM_FUNCTIONS)
857*e9dbad6fSeschrock 							error = EINVAL;
858*e9dbad6fSeschrock 						break;
859*e9dbad6fSeschrock 					case ZFS_PROP_COMPRESSION:
860*e9dbad6fSeschrock 						if (intval >=
861*e9dbad6fSeschrock 						    ZIO_COMPRESS_FUNCTIONS)
862*e9dbad6fSeschrock 							error = EINVAL;
863*e9dbad6fSeschrock 						break;
864*e9dbad6fSeschrock 					case ZFS_PROP_SNAPDIR:
865*e9dbad6fSeschrock 						if (intval >
866*e9dbad6fSeschrock 						    ZFS_SNAPDIR_VISIBLE)
867*e9dbad6fSeschrock 							error = EINVAL;
868*e9dbad6fSeschrock 						break;
869*e9dbad6fSeschrock 					case ZFS_PROP_ACLMODE:
870*e9dbad6fSeschrock 						if (intval >
871*e9dbad6fSeschrock 						    ZFS_ACL_PASSTHROUGH)
872*e9dbad6fSeschrock 							error = EINVAL;
873*e9dbad6fSeschrock 						break;
874*e9dbad6fSeschrock 					case ZFS_PROP_ACLINHERIT:
875*e9dbad6fSeschrock 						if (intval > ZFS_ACL_SECURE ||
876*e9dbad6fSeschrock 						    intval == ZFS_ACL_GROUPMASK)
877*e9dbad6fSeschrock 							error = EINVAL;
878*e9dbad6fSeschrock 						break;
879*e9dbad6fSeschrock 					default:
880*e9dbad6fSeschrock 						cmn_err(CE_PANIC,
881*e9dbad6fSeschrock 						    "unknown index property");
882*e9dbad6fSeschrock 					}
883*e9dbad6fSeschrock 					break;
884*e9dbad6fSeschrock 				default:
885*e9dbad6fSeschrock 					cmn_err(CE_PANIC, "unknown property "
886*e9dbad6fSeschrock 					    "type");
887*e9dbad6fSeschrock 					break;
888*e9dbad6fSeschrock 				}
889*e9dbad6fSeschrock 
890*e9dbad6fSeschrock 				error = dsl_prop_set(name, propname, 8, 1,
891*e9dbad6fSeschrock 				    &intval);
892*e9dbad6fSeschrock 			} else {
893*e9dbad6fSeschrock 				return (EINVAL);
894*e9dbad6fSeschrock 			}
895*e9dbad6fSeschrock 			break;
896*e9dbad6fSeschrock 		}
897*e9dbad6fSeschrock 	}
898*e9dbad6fSeschrock 
899*e9dbad6fSeschrock 	return (0);
900fa9e4066Sahrens }
901fa9e4066Sahrens 
902fa9e4066Sahrens static int
903*e9dbad6fSeschrock zfs_ioc_set_prop(zfs_cmd_t *zc)
904fa9e4066Sahrens {
905*e9dbad6fSeschrock 	nvlist_t *nvl;
906*e9dbad6fSeschrock 	int error;
907*e9dbad6fSeschrock 	zfs_prop_t prop;
908*e9dbad6fSeschrock 
909*e9dbad6fSeschrock 	/*
910*e9dbad6fSeschrock 	 * If zc_value is set, then this is an attempt to inherit a value.
911*e9dbad6fSeschrock 	 * Otherwise, zc_nvlist refers to a list of properties to set.
912*e9dbad6fSeschrock 	 */
913*e9dbad6fSeschrock 	if (zc->zc_value[0] != '\0') {
914*e9dbad6fSeschrock 		if (!zfs_prop_user(zc->zc_value) &&
915*e9dbad6fSeschrock 		    ((prop = zfs_name_to_prop(zc->zc_value)) ==
916*e9dbad6fSeschrock 		    ZFS_PROP_INVAL ||
917*e9dbad6fSeschrock 		    !zfs_prop_inheritable(prop)))
918*e9dbad6fSeschrock 			return (EINVAL);
919*e9dbad6fSeschrock 
920*e9dbad6fSeschrock 		return (dsl_prop_set(zc->zc_name, zc->zc_value, 0, 0, NULL));
921*e9dbad6fSeschrock 	}
922*e9dbad6fSeschrock 
923*e9dbad6fSeschrock 	if ((error = get_nvlist(zc, &nvl)) != 0)
924*e9dbad6fSeschrock 		return (error);
925*e9dbad6fSeschrock 
926*e9dbad6fSeschrock 	error = zfs_set_prop_nvlist(zc->zc_name, zc->zc_dev,
927*e9dbad6fSeschrock 	    (cred_t *)(uintptr_t)zc->zc_cred, nvl);
928*e9dbad6fSeschrock 	nvlist_free(nvl);
929*e9dbad6fSeschrock 	return (error);
930fa9e4066Sahrens }
931fa9e4066Sahrens 
932fa9e4066Sahrens static int
933fa9e4066Sahrens zfs_ioc_create_minor(zfs_cmd_t *zc)
934fa9e4066Sahrens {
935*e9dbad6fSeschrock 	return (zvol_create_minor(zc->zc_name, zc->zc_dev));
936fa9e4066Sahrens }
937fa9e4066Sahrens 
938fa9e4066Sahrens static int
939fa9e4066Sahrens zfs_ioc_remove_minor(zfs_cmd_t *zc)
940fa9e4066Sahrens {
941*e9dbad6fSeschrock 	return (zvol_remove_minor(zc->zc_name));
942fa9e4066Sahrens }
943fa9e4066Sahrens 
944fa9e4066Sahrens /*
945fa9e4066Sahrens  * Search the vfs list for a specified resource.  Returns a pointer to it
946fa9e4066Sahrens  * or NULL if no suitable entry is found. The caller of this routine
947fa9e4066Sahrens  * is responsible for releasing the returned vfs pointer.
948fa9e4066Sahrens  */
949fa9e4066Sahrens static vfs_t *
950fa9e4066Sahrens zfs_get_vfs(const char *resource)
951fa9e4066Sahrens {
952fa9e4066Sahrens 	struct vfs *vfsp;
953fa9e4066Sahrens 	struct vfs *vfs_found = NULL;
954fa9e4066Sahrens 
955fa9e4066Sahrens 	vfs_list_read_lock();
956fa9e4066Sahrens 	vfsp = rootvfs;
957fa9e4066Sahrens 	do {
958fa9e4066Sahrens 		if (strcmp(refstr_value(vfsp->vfs_resource), resource) == 0) {
959fa9e4066Sahrens 			VFS_HOLD(vfsp);
960fa9e4066Sahrens 			vfs_found = vfsp;
961fa9e4066Sahrens 			break;
962fa9e4066Sahrens 		}
963fa9e4066Sahrens 		vfsp = vfsp->vfs_next;
964fa9e4066Sahrens 	} while (vfsp != rootvfs);
965fa9e4066Sahrens 	vfs_list_unlock();
966fa9e4066Sahrens 	return (vfs_found);
967fa9e4066Sahrens }
968fa9e4066Sahrens 
969fa9e4066Sahrens static void
970fa9e4066Sahrens zfs_create_cb(objset_t *os, void *arg, dmu_tx_t *tx)
971fa9e4066Sahrens {
972*e9dbad6fSeschrock 	zfs_create_data_t *zc = arg;
973fa9e4066Sahrens 	zfs_create_fs(os, (cred_t *)(uintptr_t)zc->zc_cred, tx);
974fa9e4066Sahrens }
975fa9e4066Sahrens 
976fa9e4066Sahrens static int
977fa9e4066Sahrens zfs_ioc_create(zfs_cmd_t *zc)
978fa9e4066Sahrens {
979fa9e4066Sahrens 	objset_t *clone;
980fa9e4066Sahrens 	int error = 0;
981*e9dbad6fSeschrock 	zfs_create_data_t cbdata = { 0 };
982fa9e4066Sahrens 	void (*cbfunc)(objset_t *os, void *arg, dmu_tx_t *tx);
983fa9e4066Sahrens 	dmu_objset_type_t type = zc->zc_objset_type;
984fa9e4066Sahrens 
985fa9e4066Sahrens 	switch (type) {
986fa9e4066Sahrens 
987fa9e4066Sahrens 	case DMU_OST_ZFS:
988fa9e4066Sahrens 		cbfunc = zfs_create_cb;
989fa9e4066Sahrens 		break;
990fa9e4066Sahrens 
991fa9e4066Sahrens 	case DMU_OST_ZVOL:
992fa9e4066Sahrens 		cbfunc = zvol_create_cb;
993fa9e4066Sahrens 		break;
994fa9e4066Sahrens 
995fa9e4066Sahrens 	default:
9961d452cf5Sahrens 		cbfunc = NULL;
997fa9e4066Sahrens 	}
9981d452cf5Sahrens 	if (strchr(zc->zc_name, '@'))
9991d452cf5Sahrens 		return (EINVAL);
1000fa9e4066Sahrens 
1001*e9dbad6fSeschrock 	if (zc->zc_nvlist_src != NULL &&
1002*e9dbad6fSeschrock 	    (error = get_nvlist(zc, &cbdata.zc_props)) != 0)
1003*e9dbad6fSeschrock 		return (error);
1004*e9dbad6fSeschrock 
1005*e9dbad6fSeschrock 	cbdata.zc_cred = (cred_t *)(uintptr_t)zc->zc_cred;
1006*e9dbad6fSeschrock 	cbdata.zc_dev = (dev_t)zc->zc_dev;
1007*e9dbad6fSeschrock 
1008*e9dbad6fSeschrock 	if (zc->zc_value[0] != '\0') {
1009fa9e4066Sahrens 		/*
1010fa9e4066Sahrens 		 * We're creating a clone of an existing snapshot.
1011fa9e4066Sahrens 		 */
1012*e9dbad6fSeschrock 		zc->zc_value[sizeof (zc->zc_value) - 1] = '\0';
1013*e9dbad6fSeschrock 		if (dataset_namecheck(zc->zc_value, NULL, NULL) != 0) {
1014*e9dbad6fSeschrock 			nvlist_free(cbdata.zc_props);
1015fa9e4066Sahrens 			return (EINVAL);
1016*e9dbad6fSeschrock 		}
1017fa9e4066Sahrens 
1018*e9dbad6fSeschrock 		error = dmu_objset_open(zc->zc_value, type,
1019fa9e4066Sahrens 		    DS_MODE_STANDARD | DS_MODE_READONLY, &clone);
1020*e9dbad6fSeschrock 		if (error) {
1021*e9dbad6fSeschrock 			nvlist_free(cbdata.zc_props);
1022fa9e4066Sahrens 			return (error);
1023*e9dbad6fSeschrock 		}
1024fa9e4066Sahrens 		error = dmu_objset_create(zc->zc_name, type, clone, NULL, NULL);
1025fa9e4066Sahrens 		dmu_objset_close(clone);
1026fa9e4066Sahrens 	} else {
1027*e9dbad6fSeschrock 		if (cbfunc == NULL) {
1028*e9dbad6fSeschrock 			nvlist_free(cbdata.zc_props);
10291d452cf5Sahrens 			return (EINVAL);
1030*e9dbad6fSeschrock 		}
10315c5460e9Seschrock 
1032*e9dbad6fSeschrock 		if (type == DMU_OST_ZVOL) {
1033*e9dbad6fSeschrock 			uint64_t volsize, volblocksize;
1034*e9dbad6fSeschrock 
1035*e9dbad6fSeschrock 			if (cbdata.zc_props == NULL ||
1036*e9dbad6fSeschrock 			    nvlist_lookup_uint64(cbdata.zc_props,
1037*e9dbad6fSeschrock 			    zfs_prop_to_name(ZFS_PROP_VOLSIZE),
1038*e9dbad6fSeschrock 			    &volsize) != 0) {
1039*e9dbad6fSeschrock 				nvlist_free(cbdata.zc_props);
1040*e9dbad6fSeschrock 				return (EINVAL);
1041*e9dbad6fSeschrock 			}
1042*e9dbad6fSeschrock 
1043*e9dbad6fSeschrock 			if ((error = nvlist_lookup_uint64(cbdata.zc_props,
1044*e9dbad6fSeschrock 			    zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE),
1045*e9dbad6fSeschrock 			    &volblocksize)) != 0 && error != ENOENT) {
1046*e9dbad6fSeschrock 				nvlist_free(cbdata.zc_props);
1047*e9dbad6fSeschrock 				return (EINVAL);
1048*e9dbad6fSeschrock 			}
1049*e9dbad6fSeschrock 
1050*e9dbad6fSeschrock 			if (error != 0)
1051*e9dbad6fSeschrock 				volblocksize = zfs_prop_default_numeric(
1052*e9dbad6fSeschrock 				    ZFS_PROP_VOLBLOCKSIZE);
1053*e9dbad6fSeschrock 
1054*e9dbad6fSeschrock 			if ((error = zvol_check_volblocksize(
1055*e9dbad6fSeschrock 			    volblocksize)) != 0 ||
1056*e9dbad6fSeschrock 			    (error = zvol_check_volsize(volsize,
1057*e9dbad6fSeschrock 			    volblocksize)) != 0) {
1058*e9dbad6fSeschrock 				nvlist_free(cbdata.zc_props);
10595c5460e9Seschrock 				return (error);
1060*e9dbad6fSeschrock 			}
1061fa9e4066Sahrens 		}
1062*e9dbad6fSeschrock 
1063*e9dbad6fSeschrock 		error = dmu_objset_create(zc->zc_name, type, NULL, cbfunc,
1064*e9dbad6fSeschrock 		    &cbdata);
1065fa9e4066Sahrens 	}
1066*e9dbad6fSeschrock 
1067*e9dbad6fSeschrock 	/*
1068*e9dbad6fSeschrock 	 * It would be nice to do this atomically.
1069*e9dbad6fSeschrock 	 */
1070*e9dbad6fSeschrock 	if (error == 0) {
1071*e9dbad6fSeschrock 		if ((error = zfs_set_prop_nvlist(zc->zc_name,
1072*e9dbad6fSeschrock 		    zc->zc_dev, (cred_t *)(uintptr_t)zc->zc_cred,
1073*e9dbad6fSeschrock 		    cbdata.zc_props)) != 0)
1074*e9dbad6fSeschrock 			(void) dmu_objset_destroy(zc->zc_name);
1075*e9dbad6fSeschrock 	}
1076*e9dbad6fSeschrock 
1077*e9dbad6fSeschrock 	nvlist_free(cbdata.zc_props);
1078fa9e4066Sahrens 	return (error);
1079fa9e4066Sahrens }
1080fa9e4066Sahrens 
1081fa9e4066Sahrens static int
10821d452cf5Sahrens zfs_ioc_snapshot(zfs_cmd_t *zc)
1083fa9e4066Sahrens {
1084*e9dbad6fSeschrock 	if (snapshot_namecheck(zc->zc_value, NULL, NULL) != 0)
10851d452cf5Sahrens 		return (EINVAL);
10861d452cf5Sahrens 	return (dmu_objset_snapshot(zc->zc_name,
1087*e9dbad6fSeschrock 	    zc->zc_value, zc->zc_cookie));
10881d452cf5Sahrens }
1089fa9e4066Sahrens 
10901d452cf5Sahrens static int
10911d452cf5Sahrens zfs_unmount_snap(char *name, void *arg)
10921d452cf5Sahrens {
10931d452cf5Sahrens 	char *snapname = arg;
10941d452cf5Sahrens 	char *cp;
10950b69c2f0Sahrens 	vfs_t *vfsp = NULL;
10961d452cf5Sahrens 
10971d452cf5Sahrens 	/*
10981d452cf5Sahrens 	 * Snapshots (which are under .zfs control) must be unmounted
10991d452cf5Sahrens 	 * before they can be destroyed.
11001d452cf5Sahrens 	 */
11011d452cf5Sahrens 
11021d452cf5Sahrens 	if (snapname) {
11031d452cf5Sahrens 		(void) strcat(name, "@");
11041d452cf5Sahrens 		(void) strcat(name, snapname);
11051d452cf5Sahrens 		vfsp = zfs_get_vfs(name);
11061d452cf5Sahrens 		cp = strchr(name, '@');
11071d452cf5Sahrens 		*cp = '\0';
11080b69c2f0Sahrens 	} else if (strchr(name, '@')) {
11091d452cf5Sahrens 		vfsp = zfs_get_vfs(name);
11101d452cf5Sahrens 	}
11111d452cf5Sahrens 
11121d452cf5Sahrens 	if (vfsp) {
1113fa9e4066Sahrens 		/*
11141d452cf5Sahrens 		 * Always force the unmount for snapshots.
1115fa9e4066Sahrens 		 */
11161d452cf5Sahrens 		int flag = MS_FORCE;
11171d452cf5Sahrens 		int err;
11181d452cf5Sahrens 
11191d452cf5Sahrens 		if ((err = vn_vfswlock(vfsp->vfs_vnodecovered)) != 0) {
1120fa9e4066Sahrens 			VFS_RELE(vfsp);
11211d452cf5Sahrens 			return (err);
1122fa9e4066Sahrens 		}
11231d452cf5Sahrens 		VFS_RELE(vfsp);
11241d452cf5Sahrens 		if ((err = dounmount(vfsp, flag, kcred)) != 0)
11251d452cf5Sahrens 			return (err);
11261d452cf5Sahrens 	}
11271d452cf5Sahrens 	return (0);
11281d452cf5Sahrens }
11291d452cf5Sahrens 
11301d452cf5Sahrens static int
11311d452cf5Sahrens zfs_ioc_destroy_snaps(zfs_cmd_t *zc)
11321d452cf5Sahrens {
11331d452cf5Sahrens 	int err;
11341d452cf5Sahrens 
1135*e9dbad6fSeschrock 	if (snapshot_namecheck(zc->zc_value, NULL, NULL) != 0)
11361d452cf5Sahrens 		return (EINVAL);
11371d452cf5Sahrens 	err = dmu_objset_find(zc->zc_name,
1138*e9dbad6fSeschrock 	    zfs_unmount_snap, zc->zc_value, DS_FIND_CHILDREN);
11391d452cf5Sahrens 	if (err)
11401d452cf5Sahrens 		return (err);
1141*e9dbad6fSeschrock 	return (dmu_snapshots_destroy(zc->zc_name, zc->zc_value));
11421d452cf5Sahrens }
11431d452cf5Sahrens 
11441d452cf5Sahrens static int
11451d452cf5Sahrens zfs_ioc_destroy(zfs_cmd_t *zc)
11461d452cf5Sahrens {
11471d452cf5Sahrens 	if (strchr(zc->zc_name, '@') && zc->zc_objset_type == DMU_OST_ZFS) {
11481d452cf5Sahrens 		int err = zfs_unmount_snap(zc->zc_name, NULL);
11491d452cf5Sahrens 		if (err)
11501d452cf5Sahrens 			return (err);
1151fa9e4066Sahrens 	}
1152fa9e4066Sahrens 
1153fa9e4066Sahrens 	return (dmu_objset_destroy(zc->zc_name));
1154fa9e4066Sahrens }
1155fa9e4066Sahrens 
1156fa9e4066Sahrens static int
1157fa9e4066Sahrens zfs_ioc_rollback(zfs_cmd_t *zc)
1158fa9e4066Sahrens {
1159fa9e4066Sahrens 	return (dmu_objset_rollback(zc->zc_name));
1160fa9e4066Sahrens }
1161fa9e4066Sahrens 
1162fa9e4066Sahrens static int
1163fa9e4066Sahrens zfs_ioc_rename(zfs_cmd_t *zc)
1164fa9e4066Sahrens {
1165*e9dbad6fSeschrock 	zc->zc_value[sizeof (zc->zc_value) - 1] = '\0';
1166*e9dbad6fSeschrock 	if (dataset_namecheck(zc->zc_value, NULL, NULL) != 0)
1167fa9e4066Sahrens 		return (EINVAL);
1168fa9e4066Sahrens 
1169fa9e4066Sahrens 	if (strchr(zc->zc_name, '@') != NULL &&
1170fa9e4066Sahrens 	    zc->zc_objset_type == DMU_OST_ZFS) {
11711d452cf5Sahrens 		int err = zfs_unmount_snap(zc->zc_name, NULL);
11721d452cf5Sahrens 		if (err)
11731d452cf5Sahrens 			return (err);
1174fa9e4066Sahrens 	}
1175fa9e4066Sahrens 
1176*e9dbad6fSeschrock 	return (dmu_objset_rename(zc->zc_name, zc->zc_value));
1177fa9e4066Sahrens }
1178fa9e4066Sahrens 
1179fa9e4066Sahrens static int
1180fa9e4066Sahrens zfs_ioc_recvbackup(zfs_cmd_t *zc)
1181fa9e4066Sahrens {
1182fa9e4066Sahrens 	file_t *fp;
1183fa9e4066Sahrens 	int error, fd;
1184fa9e4066Sahrens 
1185fa9e4066Sahrens 	fd = zc->zc_cookie;
1186fa9e4066Sahrens 	fp = getf(fd);
1187fa9e4066Sahrens 	if (fp == NULL)
1188fa9e4066Sahrens 		return (EBADF);
1189*e9dbad6fSeschrock 	error = dmu_recvbackup(zc->zc_value, &zc->zc_begin_record,
1190*e9dbad6fSeschrock 	    &zc->zc_cookie, (boolean_t)zc->zc_guid, fp->f_vnode,
119198579b20Snd 	    fp->f_offset);
1192fa9e4066Sahrens 	releasef(fd);
1193fa9e4066Sahrens 	return (error);
1194fa9e4066Sahrens }
1195fa9e4066Sahrens 
1196fa9e4066Sahrens static int
1197fa9e4066Sahrens zfs_ioc_sendbackup(zfs_cmd_t *zc)
1198fa9e4066Sahrens {
1199fa9e4066Sahrens 	objset_t *fromsnap = NULL;
1200fa9e4066Sahrens 	objset_t *tosnap;
1201fa9e4066Sahrens 	file_t *fp;
1202fa9e4066Sahrens 	int error;
1203fa9e4066Sahrens 
1204fa9e4066Sahrens 	error = dmu_objset_open(zc->zc_name, DMU_OST_ANY,
1205fa9e4066Sahrens 	    DS_MODE_STANDARD | DS_MODE_READONLY, &tosnap);
1206fa9e4066Sahrens 	if (error)
1207fa9e4066Sahrens 		return (error);
1208fa9e4066Sahrens 
1209*e9dbad6fSeschrock 	if (zc->zc_value[0] != '\0') {
1210*e9dbad6fSeschrock 		error = dmu_objset_open(zc->zc_value, DMU_OST_ANY,
1211fa9e4066Sahrens 		    DS_MODE_STANDARD | DS_MODE_READONLY, &fromsnap);
1212fa9e4066Sahrens 		if (error) {
1213fa9e4066Sahrens 			dmu_objset_close(tosnap);
1214fa9e4066Sahrens 			return (error);
1215fa9e4066Sahrens 		}
1216fa9e4066Sahrens 	}
1217fa9e4066Sahrens 
1218fa9e4066Sahrens 	fp = getf(zc->zc_cookie);
1219fa9e4066Sahrens 	if (fp == NULL) {
1220fa9e4066Sahrens 		dmu_objset_close(tosnap);
1221fa9e4066Sahrens 		if (fromsnap)
1222fa9e4066Sahrens 			dmu_objset_close(fromsnap);
1223fa9e4066Sahrens 		return (EBADF);
1224fa9e4066Sahrens 	}
1225fa9e4066Sahrens 
1226fa9e4066Sahrens 	error = dmu_sendbackup(tosnap, fromsnap, fp->f_vnode);
1227fa9e4066Sahrens 
1228fa9e4066Sahrens 	releasef(zc->zc_cookie);
1229fa9e4066Sahrens 	if (fromsnap)
1230fa9e4066Sahrens 		dmu_objset_close(fromsnap);
1231fa9e4066Sahrens 	dmu_objset_close(tosnap);
1232fa9e4066Sahrens 	return (error);
1233fa9e4066Sahrens }
1234fa9e4066Sahrens 
1235ea8dc4b6Seschrock static int
1236ea8dc4b6Seschrock zfs_ioc_inject_fault(zfs_cmd_t *zc)
1237ea8dc4b6Seschrock {
1238ea8dc4b6Seschrock 	int id, error;
1239ea8dc4b6Seschrock 
1240ea8dc4b6Seschrock 	error = zio_inject_fault(zc->zc_name, (int)zc->zc_guid, &id,
1241ea8dc4b6Seschrock 	    &zc->zc_inject_record);
1242ea8dc4b6Seschrock 
1243ea8dc4b6Seschrock 	if (error == 0)
1244ea8dc4b6Seschrock 		zc->zc_guid = (uint64_t)id;
1245ea8dc4b6Seschrock 
1246ea8dc4b6Seschrock 	return (error);
1247ea8dc4b6Seschrock }
1248ea8dc4b6Seschrock 
1249ea8dc4b6Seschrock static int
1250ea8dc4b6Seschrock zfs_ioc_clear_fault(zfs_cmd_t *zc)
1251ea8dc4b6Seschrock {
1252ea8dc4b6Seschrock 	return (zio_clear_fault((int)zc->zc_guid));
1253ea8dc4b6Seschrock }
1254ea8dc4b6Seschrock 
1255ea8dc4b6Seschrock static int
1256ea8dc4b6Seschrock zfs_ioc_inject_list_next(zfs_cmd_t *zc)
1257ea8dc4b6Seschrock {
1258ea8dc4b6Seschrock 	int id = (int)zc->zc_guid;
1259ea8dc4b6Seschrock 	int error;
1260ea8dc4b6Seschrock 
1261ea8dc4b6Seschrock 	error = zio_inject_list_next(&id, zc->zc_name, sizeof (zc->zc_name),
1262ea8dc4b6Seschrock 	    &zc->zc_inject_record);
1263ea8dc4b6Seschrock 
1264ea8dc4b6Seschrock 	zc->zc_guid = id;
1265ea8dc4b6Seschrock 
1266ea8dc4b6Seschrock 	return (error);
1267ea8dc4b6Seschrock }
1268ea8dc4b6Seschrock 
1269ea8dc4b6Seschrock static int
1270ea8dc4b6Seschrock zfs_ioc_error_log(zfs_cmd_t *zc)
1271ea8dc4b6Seschrock {
1272ea8dc4b6Seschrock 	spa_t *spa;
1273ea8dc4b6Seschrock 	int error;
1274*e9dbad6fSeschrock 	size_t count = (size_t)zc->zc_nvlist_dst_size;
1275ea8dc4b6Seschrock 
1276ea8dc4b6Seschrock 	if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
1277ea8dc4b6Seschrock 		return (error);
1278ea8dc4b6Seschrock 
1279*e9dbad6fSeschrock 	error = spa_get_errlog(spa, (void *)(uintptr_t)zc->zc_nvlist_dst,
1280ea8dc4b6Seschrock 	    &count);
1281ea8dc4b6Seschrock 	if (error == 0)
1282*e9dbad6fSeschrock 		zc->zc_nvlist_dst_size = count;
1283ea8dc4b6Seschrock 	else
1284*e9dbad6fSeschrock 		zc->zc_nvlist_dst_size = spa_get_errlog_size(spa);
1285ea8dc4b6Seschrock 
1286ea8dc4b6Seschrock 	spa_close(spa, FTAG);
1287ea8dc4b6Seschrock 
1288ea8dc4b6Seschrock 	return (error);
1289ea8dc4b6Seschrock }
1290ea8dc4b6Seschrock 
1291ea8dc4b6Seschrock static int
1292ea8dc4b6Seschrock zfs_ioc_clear(zfs_cmd_t *zc)
1293ea8dc4b6Seschrock {
1294ea8dc4b6Seschrock 	spa_t *spa;
1295ea8dc4b6Seschrock 	vdev_t *vd;
1296ea8dc4b6Seschrock 	int error;
1297ea8dc4b6Seschrock 
1298ea8dc4b6Seschrock 	if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
1299ea8dc4b6Seschrock 		return (error);
1300ea8dc4b6Seschrock 
1301ea8dc4b6Seschrock 	spa_config_enter(spa, RW_WRITER, FTAG);
1302ea8dc4b6Seschrock 
1303*e9dbad6fSeschrock 	if (zc->zc_guid == 0) {
1304ea8dc4b6Seschrock 		vd = NULL;
1305*e9dbad6fSeschrock 	} else if ((vd = spa_lookup_by_guid(spa, zc->zc_guid)) == NULL) {
1306ea8dc4b6Seschrock 		spa_config_exit(spa, FTAG);
1307ea8dc4b6Seschrock 		spa_close(spa, FTAG);
1308ea8dc4b6Seschrock 		return (ENODEV);
1309ea8dc4b6Seschrock 	}
1310ea8dc4b6Seschrock 
1311ea8dc4b6Seschrock 	vdev_clear(spa, vd);
1312ea8dc4b6Seschrock 
1313ea8dc4b6Seschrock 	spa_config_exit(spa, FTAG);
1314ea8dc4b6Seschrock 
1315ea8dc4b6Seschrock 	spa_close(spa, FTAG);
1316ea8dc4b6Seschrock 
1317ea8dc4b6Seschrock 	return (0);
1318ea8dc4b6Seschrock }
1319ea8dc4b6Seschrock 
1320ea8dc4b6Seschrock static int
1321ea8dc4b6Seschrock zfs_ioc_bookmark_name(zfs_cmd_t *zc)
1322ea8dc4b6Seschrock {
1323ea8dc4b6Seschrock 	spa_t *spa;
1324ea8dc4b6Seschrock 	int error;
1325*e9dbad6fSeschrock 	nvlist_t *nvl;
1326ea8dc4b6Seschrock 
1327ea8dc4b6Seschrock 	if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
1328ea8dc4b6Seschrock 		return (error);
1329ea8dc4b6Seschrock 
1330*e9dbad6fSeschrock 	VERIFY(nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP) == 0);
1331*e9dbad6fSeschrock 
1332*e9dbad6fSeschrock 	error = spa_bookmark_name(spa, &zc->zc_bookmark, nvl);
1333*e9dbad6fSeschrock 	if (error == 0)
1334*e9dbad6fSeschrock 		error = put_nvlist(zc, nvl);
1335*e9dbad6fSeschrock 	nvlist_free(nvl);
1336ea8dc4b6Seschrock 
1337ea8dc4b6Seschrock 	spa_close(spa, FTAG);
1338ea8dc4b6Seschrock 
1339ea8dc4b6Seschrock 	return (error);
1340ea8dc4b6Seschrock }
1341ea8dc4b6Seschrock 
134299653d4eSeschrock static int
134399653d4eSeschrock zfs_ioc_promote(zfs_cmd_t *zc)
134499653d4eSeschrock {
13450b69c2f0Sahrens 	char *cp;
13460b69c2f0Sahrens 
13470b69c2f0Sahrens 	/*
13480b69c2f0Sahrens 	 * We don't need to unmount *all* the origin fs's snapshots, but
13490b69c2f0Sahrens 	 * it's easier.
13500b69c2f0Sahrens 	 */
1351*e9dbad6fSeschrock 	cp = strchr(zc->zc_value, '@');
13520b69c2f0Sahrens 	if (cp)
13530b69c2f0Sahrens 		*cp = '\0';
1354*e9dbad6fSeschrock 	(void) dmu_objset_find(zc->zc_value,
13550b69c2f0Sahrens 	    zfs_unmount_snap, NULL, DS_FIND_SNAPSHOTS);
135699653d4eSeschrock 	return (dsl_dataset_promote(zc->zc_name));
135799653d4eSeschrock }
135899653d4eSeschrock 
1359fa9e4066Sahrens static zfs_ioc_vec_t zfs_ioc_vec[] = {
1360fa9e4066Sahrens 	{ zfs_ioc_pool_create,		zfs_secpolicy_config,	pool_name },
1361fa9e4066Sahrens 	{ zfs_ioc_pool_destroy,		zfs_secpolicy_config,	pool_name },
1362fa9e4066Sahrens 	{ zfs_ioc_pool_import,		zfs_secpolicy_config,	pool_name },
1363fa9e4066Sahrens 	{ zfs_ioc_pool_export,		zfs_secpolicy_config,	pool_name },
1364fa9e4066Sahrens 	{ zfs_ioc_pool_configs,		zfs_secpolicy_none,	no_name },
1365fa9e4066Sahrens 	{ zfs_ioc_pool_stats,		zfs_secpolicy_read,	pool_name },
1366fa9e4066Sahrens 	{ zfs_ioc_pool_tryimport,	zfs_secpolicy_config,	no_name },
1367fa9e4066Sahrens 	{ zfs_ioc_pool_scrub,		zfs_secpolicy_config,	pool_name },
1368fa9e4066Sahrens 	{ zfs_ioc_pool_freeze,		zfs_secpolicy_config,	no_name },
1369eaca9bbdSeschrock 	{ zfs_ioc_pool_upgrade,		zfs_secpolicy_config,	pool_name },
1370fa9e4066Sahrens 	{ zfs_ioc_vdev_add,		zfs_secpolicy_config,	pool_name },
1371fa9e4066Sahrens 	{ zfs_ioc_vdev_remove,		zfs_secpolicy_config,	pool_name },
1372fa9e4066Sahrens 	{ zfs_ioc_vdev_online,		zfs_secpolicy_config,	pool_name },
1373fa9e4066Sahrens 	{ zfs_ioc_vdev_offline,		zfs_secpolicy_config,	pool_name },
1374fa9e4066Sahrens 	{ zfs_ioc_vdev_attach,		zfs_secpolicy_config,	pool_name },
1375fa9e4066Sahrens 	{ zfs_ioc_vdev_detach,		zfs_secpolicy_config,	pool_name },
1376c67d9675Seschrock 	{ zfs_ioc_vdev_setpath,		zfs_secpolicy_config,	pool_name },
1377fa9e4066Sahrens 	{ zfs_ioc_objset_stats,		zfs_secpolicy_read,	dataset_name },
1378fa9e4066Sahrens 	{ zfs_ioc_dataset_list_next,	zfs_secpolicy_read,	dataset_name },
1379fa9e4066Sahrens 	{ zfs_ioc_snapshot_list_next,	zfs_secpolicy_read,	dataset_name },
1380*e9dbad6fSeschrock 	{ zfs_ioc_set_prop,		zfs_secpolicy_write,	dataset_name },
1381fa9e4066Sahrens 	{ zfs_ioc_create_minor,		zfs_secpolicy_config,	dataset_name },
1382fa9e4066Sahrens 	{ zfs_ioc_remove_minor,		zfs_secpolicy_config,	dataset_name },
1383fa9e4066Sahrens 	{ zfs_ioc_create,		zfs_secpolicy_parent,	dataset_name },
1384fa9e4066Sahrens 	{ zfs_ioc_destroy,		zfs_secpolicy_parent,	dataset_name },
1385fa9e4066Sahrens 	{ zfs_ioc_rollback,		zfs_secpolicy_write,	dataset_name },
1386fa9e4066Sahrens 	{ zfs_ioc_rename,		zfs_secpolicy_write,	dataset_name },
1387fa9e4066Sahrens 	{ zfs_ioc_recvbackup,		zfs_secpolicy_write,	dataset_name },
1388fa9e4066Sahrens 	{ zfs_ioc_sendbackup,		zfs_secpolicy_write,	dataset_name },
1389ea8dc4b6Seschrock 	{ zfs_ioc_inject_fault,		zfs_secpolicy_inject,	no_name },
1390ea8dc4b6Seschrock 	{ zfs_ioc_clear_fault,		zfs_secpolicy_inject,	no_name },
1391ea8dc4b6Seschrock 	{ zfs_ioc_inject_list_next,	zfs_secpolicy_inject,	no_name },
1392ea8dc4b6Seschrock 	{ zfs_ioc_error_log,		zfs_secpolicy_inject,	pool_name },
1393ea8dc4b6Seschrock 	{ zfs_ioc_clear,		zfs_secpolicy_config,	pool_name },
139499653d4eSeschrock 	{ zfs_ioc_bookmark_name,	zfs_secpolicy_inject,	pool_name },
13951d452cf5Sahrens 	{ zfs_ioc_promote,		zfs_secpolicy_write,	dataset_name },
13961d452cf5Sahrens 	{ zfs_ioc_destroy_snaps,	zfs_secpolicy_write,	dataset_name },
13971d452cf5Sahrens 	{ zfs_ioc_snapshot,		zfs_secpolicy_write,	dataset_name }
1398fa9e4066Sahrens };
1399fa9e4066Sahrens 
1400fa9e4066Sahrens static int
1401fa9e4066Sahrens zfsdev_ioctl(dev_t dev, int cmd, intptr_t arg, int flag, cred_t *cr, int *rvalp)
1402fa9e4066Sahrens {
1403fa9e4066Sahrens 	zfs_cmd_t *zc;
1404fa9e4066Sahrens 	uint_t vec;
14051d452cf5Sahrens 	int error, rc;
1406fa9e4066Sahrens 
1407fa9e4066Sahrens 	if (getminor(dev) != 0)
1408fa9e4066Sahrens 		return (zvol_ioctl(dev, cmd, arg, flag, cr, rvalp));
1409fa9e4066Sahrens 
1410fa9e4066Sahrens 	vec = cmd - ZFS_IOC;
1411fa9e4066Sahrens 
1412fa9e4066Sahrens 	if (vec >= sizeof (zfs_ioc_vec) / sizeof (zfs_ioc_vec[0]))
1413fa9e4066Sahrens 		return (EINVAL);
1414fa9e4066Sahrens 
1415fa9e4066Sahrens 	zc = kmem_zalloc(sizeof (zfs_cmd_t), KM_SLEEP);
1416fa9e4066Sahrens 
1417fa9e4066Sahrens 	error = xcopyin((void *)arg, zc, sizeof (zfs_cmd_t));
1418fa9e4066Sahrens 
1419fa9e4066Sahrens 	if (error == 0) {
1420fa9e4066Sahrens 		zc->zc_cred = (uintptr_t)cr;
1421fa9e4066Sahrens 		zc->zc_dev = dev;
1422*e9dbad6fSeschrock 		error = zfs_ioc_vec[vec].zvec_secpolicy(zc->zc_name, cr);
1423fa9e4066Sahrens 	}
1424fa9e4066Sahrens 
1425fa9e4066Sahrens 	/*
1426fa9e4066Sahrens 	 * Ensure that all pool/dataset names are valid before we pass down to
1427fa9e4066Sahrens 	 * the lower layers.
1428fa9e4066Sahrens 	 */
1429fa9e4066Sahrens 	if (error == 0) {
1430fa9e4066Sahrens 		zc->zc_name[sizeof (zc->zc_name) - 1] = '\0';
1431fa9e4066Sahrens 		switch (zfs_ioc_vec[vec].zvec_namecheck) {
1432fa9e4066Sahrens 		case pool_name:
1433fa9e4066Sahrens 			if (pool_namecheck(zc->zc_name, NULL, NULL) != 0)
1434fa9e4066Sahrens 				error = EINVAL;
1435fa9e4066Sahrens 			break;
1436fa9e4066Sahrens 
1437fa9e4066Sahrens 		case dataset_name:
1438fa9e4066Sahrens 			if (dataset_namecheck(zc->zc_name, NULL, NULL) != 0)
1439fa9e4066Sahrens 				error = EINVAL;
1440fa9e4066Sahrens 			break;
1441fa9e4066Sahrens 		}
1442fa9e4066Sahrens 	}
1443fa9e4066Sahrens 
1444fa9e4066Sahrens 	if (error == 0)
1445fa9e4066Sahrens 		error = zfs_ioc_vec[vec].zvec_func(zc);
1446fa9e4066Sahrens 
14471d452cf5Sahrens 	rc = xcopyout(zc, (void *)arg, sizeof (zfs_cmd_t));
14481d452cf5Sahrens 	if (error == 0)
14491d452cf5Sahrens 		error = rc;
1450fa9e4066Sahrens 
1451fa9e4066Sahrens 	kmem_free(zc, sizeof (zfs_cmd_t));
1452fa9e4066Sahrens 	return (error);
1453fa9e4066Sahrens }
1454fa9e4066Sahrens 
1455fa9e4066Sahrens static int
1456fa9e4066Sahrens zfs_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
1457fa9e4066Sahrens {
1458fa9e4066Sahrens 	if (cmd != DDI_ATTACH)
1459fa9e4066Sahrens 		return (DDI_FAILURE);
1460fa9e4066Sahrens 
1461fa9e4066Sahrens 	if (ddi_create_minor_node(dip, "zfs", S_IFCHR, 0,
1462fa9e4066Sahrens 	    DDI_PSEUDO, 0) == DDI_FAILURE)
1463fa9e4066Sahrens 		return (DDI_FAILURE);
1464fa9e4066Sahrens 
1465fa9e4066Sahrens 	zfs_dip = dip;
1466fa9e4066Sahrens 
1467fa9e4066Sahrens 	ddi_report_dev(dip);
1468fa9e4066Sahrens 
1469fa9e4066Sahrens 	return (DDI_SUCCESS);
1470fa9e4066Sahrens }
1471fa9e4066Sahrens 
1472fa9e4066Sahrens static int
1473fa9e4066Sahrens zfs_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
1474fa9e4066Sahrens {
1475fa9e4066Sahrens 	if (spa_busy() || zfs_busy() || zvol_busy())
1476fa9e4066Sahrens 		return (DDI_FAILURE);
1477fa9e4066Sahrens 
1478fa9e4066Sahrens 	if (cmd != DDI_DETACH)
1479fa9e4066Sahrens 		return (DDI_FAILURE);
1480fa9e4066Sahrens 
1481fa9e4066Sahrens 	zfs_dip = NULL;
1482fa9e4066Sahrens 
1483fa9e4066Sahrens 	ddi_prop_remove_all(dip);
1484fa9e4066Sahrens 	ddi_remove_minor_node(dip, NULL);
1485fa9e4066Sahrens 
1486fa9e4066Sahrens 	return (DDI_SUCCESS);
1487fa9e4066Sahrens }
1488fa9e4066Sahrens 
1489fa9e4066Sahrens /*ARGSUSED*/
1490fa9e4066Sahrens static int
1491fa9e4066Sahrens zfs_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
1492fa9e4066Sahrens {
1493fa9e4066Sahrens 	switch (infocmd) {
1494fa9e4066Sahrens 	case DDI_INFO_DEVT2DEVINFO:
1495fa9e4066Sahrens 		*result = zfs_dip;
1496fa9e4066Sahrens 		return (DDI_SUCCESS);
1497fa9e4066Sahrens 
1498fa9e4066Sahrens 	case DDI_INFO_DEVT2INSTANCE:
1499a0965f35Sbonwick 		*result = (void *)0;
1500fa9e4066Sahrens 		return (DDI_SUCCESS);
1501fa9e4066Sahrens 	}
1502fa9e4066Sahrens 
1503fa9e4066Sahrens 	return (DDI_FAILURE);
1504fa9e4066Sahrens }
1505fa9e4066Sahrens 
1506fa9e4066Sahrens /*
1507fa9e4066Sahrens  * OK, so this is a little weird.
1508fa9e4066Sahrens  *
1509fa9e4066Sahrens  * /dev/zfs is the control node, i.e. minor 0.
1510fa9e4066Sahrens  * /dev/zvol/[r]dsk/pool/dataset are the zvols, minor > 0.
1511fa9e4066Sahrens  *
1512fa9e4066Sahrens  * /dev/zfs has basically nothing to do except serve up ioctls,
1513fa9e4066Sahrens  * so most of the standard driver entry points are in zvol.c.
1514fa9e4066Sahrens  */
1515fa9e4066Sahrens static struct cb_ops zfs_cb_ops = {
1516fa9e4066Sahrens 	zvol_open,	/* open */
1517fa9e4066Sahrens 	zvol_close,	/* close */
1518fa9e4066Sahrens 	zvol_strategy,	/* strategy */
1519fa9e4066Sahrens 	nodev,		/* print */
1520fa9e4066Sahrens 	nodev,		/* dump */
1521fa9e4066Sahrens 	zvol_read,	/* read */
1522fa9e4066Sahrens 	zvol_write,	/* write */
1523fa9e4066Sahrens 	zfsdev_ioctl,	/* ioctl */
1524fa9e4066Sahrens 	nodev,		/* devmap */
1525fa9e4066Sahrens 	nodev,		/* mmap */
1526fa9e4066Sahrens 	nodev,		/* segmap */
1527fa9e4066Sahrens 	nochpoll,	/* poll */
1528fa9e4066Sahrens 	ddi_prop_op,	/* prop_op */
1529fa9e4066Sahrens 	NULL,		/* streamtab */
1530fa9e4066Sahrens 	D_NEW | D_MP | D_64BIT,		/* Driver compatibility flag */
1531fa9e4066Sahrens 	CB_REV,		/* version */
1532fa9e4066Sahrens 	zvol_aread,	/* async read */
1533fa9e4066Sahrens 	zvol_awrite,	/* async write */
1534fa9e4066Sahrens };
1535fa9e4066Sahrens 
1536fa9e4066Sahrens static struct dev_ops zfs_dev_ops = {
1537fa9e4066Sahrens 	DEVO_REV,	/* version */
1538fa9e4066Sahrens 	0,		/* refcnt */
1539fa9e4066Sahrens 	zfs_info,	/* info */
1540fa9e4066Sahrens 	nulldev,	/* identify */
1541fa9e4066Sahrens 	nulldev,	/* probe */
1542fa9e4066Sahrens 	zfs_attach,	/* attach */
1543fa9e4066Sahrens 	zfs_detach,	/* detach */
1544fa9e4066Sahrens 	nodev,		/* reset */
1545fa9e4066Sahrens 	&zfs_cb_ops,	/* driver operations */
1546fa9e4066Sahrens 	NULL		/* no bus operations */
1547fa9e4066Sahrens };
1548fa9e4066Sahrens 
1549fa9e4066Sahrens static struct modldrv zfs_modldrv = {
1550*e9dbad6fSeschrock 	&mod_driverops, "ZFS storage pool version " ZFS_VERSION_STRING,
1551*e9dbad6fSeschrock 	    &zfs_dev_ops
1552fa9e4066Sahrens };
1553fa9e4066Sahrens 
1554fa9e4066Sahrens static struct modlinkage modlinkage = {
1555fa9e4066Sahrens 	MODREV_1,
1556fa9e4066Sahrens 	(void *)&zfs_modlfs,
1557fa9e4066Sahrens 	(void *)&zfs_modldrv,
1558fa9e4066Sahrens 	NULL
1559fa9e4066Sahrens };
1560fa9e4066Sahrens 
1561fa9e4066Sahrens int
1562fa9e4066Sahrens _init(void)
1563fa9e4066Sahrens {
1564fa9e4066Sahrens 	int error;
1565fa9e4066Sahrens 
1566a0965f35Sbonwick 	spa_init(FREAD | FWRITE);
1567a0965f35Sbonwick 	zfs_init();
1568a0965f35Sbonwick 	zvol_init();
1569a0965f35Sbonwick 
1570a0965f35Sbonwick 	if ((error = mod_install(&modlinkage)) != 0) {
1571a0965f35Sbonwick 		zvol_fini();
1572a0965f35Sbonwick 		zfs_fini();
1573a0965f35Sbonwick 		spa_fini();
1574fa9e4066Sahrens 		return (error);
1575a0965f35Sbonwick 	}
1576fa9e4066Sahrens 
1577fa9e4066Sahrens 	error = ldi_ident_from_mod(&modlinkage, &zfs_li);
1578fa9e4066Sahrens 	ASSERT(error == 0);
1579fa9e4066Sahrens 
1580fa9e4066Sahrens 	return (0);
1581fa9e4066Sahrens }
1582fa9e4066Sahrens 
1583fa9e4066Sahrens int
1584fa9e4066Sahrens _fini(void)
1585fa9e4066Sahrens {
1586fa9e4066Sahrens 	int error;
1587fa9e4066Sahrens 
1588ea8dc4b6Seschrock 	if (spa_busy() || zfs_busy() || zvol_busy() || zio_injection_enabled)
1589fa9e4066Sahrens 		return (EBUSY);
1590fa9e4066Sahrens 
1591fa9e4066Sahrens 	if ((error = mod_remove(&modlinkage)) != 0)
1592fa9e4066Sahrens 		return (error);
1593fa9e4066Sahrens 
1594fa9e4066Sahrens 	zvol_fini();
1595fa9e4066Sahrens 	zfs_fini();
1596fa9e4066Sahrens 	spa_fini();
1597fa9e4066Sahrens 
1598fa9e4066Sahrens 	ldi_ident_release(zfs_li);
1599fa9e4066Sahrens 	zfs_li = NULL;
1600fa9e4066Sahrens 
1601fa9e4066Sahrens 	return (error);
1602fa9e4066Sahrens }
1603fa9e4066Sahrens 
1604fa9e4066Sahrens int
1605fa9e4066Sahrens _info(struct modinfo *modinfop)
1606fa9e4066Sahrens {
1607fa9e4066Sahrens 	return (mod_info(&modlinkage, modinfop));
1608fa9e4066Sahrens }
1609