xref: /freebsd/sys/contrib/openzfs/module/zfs/zfs_ioctl.c (revision c7046f76c2c027b00c0e6ba57cfd28f1a78f5e23)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or https://opensource.org/licenses/CDDL-1.0.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Portions Copyright 2011 Martin Matuska
25  * Copyright 2015, OmniTI Computer Consulting, Inc. All rights reserved.
26  * Portions Copyright 2012 Pawel Jakub Dawidek <pawel@dawidek.net>
27  * Copyright (c) 2014, 2016 Joyent, Inc. All rights reserved.
28  * Copyright 2016 Nexenta Systems, Inc.  All rights reserved.
29  * Copyright (c) 2014, Joyent, Inc. All rights reserved.
30  * Copyright (c) 2011, 2020 by Delphix. All rights reserved.
31  * Copyright (c) 2013 by Saso Kiselkov. All rights reserved.
32  * Copyright (c) 2013 Steven Hartland. All rights reserved.
33  * Copyright (c) 2014 Integros [integros.com]
34  * Copyright 2016 Toomas Soome <tsoome@me.com>
35  * Copyright (c) 2016 Actifio, Inc. All rights reserved.
36  * Copyright (c) 2018, loli10K <ezomori.nozomu@gmail.com>. All rights reserved.
37  * Copyright 2017 RackTop Systems.
38  * Copyright (c) 2017 Open-E, Inc. All Rights Reserved.
39  * Copyright (c) 2019 Datto Inc.
40  * Copyright (c) 2019, 2020 by Christian Schwarz. All rights reserved.
41  * Copyright (c) 2019, 2021, Klara Inc.
42  * Copyright (c) 2019, Allan Jude
43  */
44 
45 /*
46  * ZFS ioctls.
47  *
48  * This file handles the ioctls to /dev/zfs, used for configuring ZFS storage
49  * pools and filesystems, e.g. with /sbin/zfs and /sbin/zpool.
50  *
51  * There are two ways that we handle ioctls: the legacy way where almost
52  * all of the logic is in the ioctl callback, and the new way where most
53  * of the marshalling is handled in the common entry point, zfsdev_ioctl().
54  *
55  * Non-legacy ioctls should be registered by calling
56  * zfs_ioctl_register() from zfs_ioctl_init().  The ioctl is invoked
57  * from userland by lzc_ioctl().
58  *
59  * The registration arguments are as follows:
60  *
61  * const char *name
62  *   The name of the ioctl.  This is used for history logging.  If the
63  *   ioctl returns successfully (the callback returns 0), and allow_log
64  *   is true, then a history log entry will be recorded with the input &
65  *   output nvlists.  The log entry can be printed with "zpool history -i".
66  *
67  * zfs_ioc_t ioc
68  *   The ioctl request number, which userland will pass to ioctl(2).
69  *   We want newer versions of libzfs and libzfs_core to run against
70  *   existing zfs kernel modules (i.e. a deferred reboot after an update).
71  *   Therefore the ioctl numbers cannot change from release to release.
72  *
73  * zfs_secpolicy_func_t *secpolicy
74  *   This function will be called before the zfs_ioc_func_t, to
75  *   determine if this operation is permitted.  It should return EPERM
76  *   on failure, and 0 on success.  Checks include determining if the
77  *   dataset is visible in this zone, and if the user has either all
78  *   zfs privileges in the zone (SYS_MOUNT), or has been granted permission
79  *   to do this operation on this dataset with "zfs allow".
80  *
81  * zfs_ioc_namecheck_t namecheck
82  *   This specifies what to expect in the zfs_cmd_t:zc_name -- a pool
83  *   name, a dataset name, or nothing.  If the name is not well-formed,
84  *   the ioctl will fail and the callback will not be called.
85  *   Therefore, the callback can assume that the name is well-formed
86  *   (e.g. is null-terminated, doesn't have more than one '@' character,
87  *   doesn't have invalid characters).
88  *
89  * zfs_ioc_poolcheck_t pool_check
90  *   This specifies requirements on the pool state.  If the pool does
91  *   not meet them (is suspended or is readonly), the ioctl will fail
92  *   and the callback will not be called.  If any checks are specified
93  *   (i.e. it is not POOL_CHECK_NONE), namecheck must not be NO_NAME.
94  *   Multiple checks can be or-ed together (e.g. POOL_CHECK_SUSPENDED |
95  *   POOL_CHECK_READONLY).
96  *
97  * zfs_ioc_key_t *nvl_keys
98  *  The list of expected/allowable innvl input keys. This list is used
99  *  to validate the nvlist input to the ioctl.
100  *
101  * boolean_t smush_outnvlist
102  *   If smush_outnvlist is true, then the output is presumed to be a
103  *   list of errors, and it will be "smushed" down to fit into the
104  *   caller's buffer, by removing some entries and replacing them with a
105  *   single "N_MORE_ERRORS" entry indicating how many were removed.  See
106  *   nvlist_smush() for details.  If smush_outnvlist is false, and the
107  *   outnvlist does not fit into the userland-provided buffer, then the
108  *   ioctl will fail with ENOMEM.
109  *
110  * zfs_ioc_func_t *func
111  *   The callback function that will perform the operation.
112  *
113  *   The callback should return 0 on success, or an error number on
114  *   failure.  If the function fails, the userland ioctl will return -1,
115  *   and errno will be set to the callback's return value.  The callback
116  *   will be called with the following arguments:
117  *
118  *   const char *name
119  *     The name of the pool or dataset to operate on, from
120  *     zfs_cmd_t:zc_name.  The 'namecheck' argument specifies the
121  *     expected type (pool, dataset, or none).
122  *
123  *   nvlist_t *innvl
124  *     The input nvlist, deserialized from zfs_cmd_t:zc_nvlist_src.  Or
125  *     NULL if no input nvlist was provided.  Changes to this nvlist are
126  *     ignored.  If the input nvlist could not be deserialized, the
127  *     ioctl will fail and the callback will not be called.
128  *
129  *   nvlist_t *outnvl
130  *     The output nvlist, initially empty.  The callback can fill it in,
131  *     and it will be returned to userland by serializing it into
132  *     zfs_cmd_t:zc_nvlist_dst.  If it is non-empty, and serialization
133  *     fails (e.g. because the caller didn't supply a large enough
134  *     buffer), then the overall ioctl will fail.  See the
135  *     'smush_nvlist' argument above for additional behaviors.
136  *
137  *     There are two typical uses of the output nvlist:
138  *       - To return state, e.g. property values.  In this case,
139  *         smush_outnvlist should be false.  If the buffer was not large
140  *         enough, the caller will reallocate a larger buffer and try
141  *         the ioctl again.
142  *
143  *       - To return multiple errors from an ioctl which makes on-disk
144  *         changes.  In this case, smush_outnvlist should be true.
145  *         Ioctls which make on-disk modifications should generally not
146  *         use the outnvl if they succeed, because the caller can not
147  *         distinguish between the operation failing, and
148  *         deserialization failing.
149  *
150  * IOCTL Interface Errors
151  *
152  * The following ioctl input errors can be returned:
153  *   ZFS_ERR_IOC_CMD_UNAVAIL	the ioctl number is not supported by kernel
154  *   ZFS_ERR_IOC_ARG_UNAVAIL	an input argument is not supported by kernel
155  *   ZFS_ERR_IOC_ARG_REQUIRED	a required input argument is missing
156  *   ZFS_ERR_IOC_ARG_BADTYPE	an input argument has an invalid type
157  */
158 
159 #include <sys/types.h>
160 #include <sys/param.h>
161 #include <sys/errno.h>
162 #include <sys/uio_impl.h>
163 #include <sys/file.h>
164 #include <sys/kmem.h>
165 #include <sys/cmn_err.h>
166 #include <sys/stat.h>
167 #include <sys/zfs_ioctl.h>
168 #include <sys/zfs_quota.h>
169 #include <sys/zfs_vfsops.h>
170 #include <sys/zfs_znode.h>
171 #include <sys/zap.h>
172 #include <sys/spa.h>
173 #include <sys/spa_impl.h>
174 #include <sys/vdev.h>
175 #include <sys/vdev_impl.h>
176 #include <sys/dmu.h>
177 #include <sys/dsl_dir.h>
178 #include <sys/dsl_dataset.h>
179 #include <sys/dsl_prop.h>
180 #include <sys/dsl_deleg.h>
181 #include <sys/dmu_objset.h>
182 #include <sys/dmu_impl.h>
183 #include <sys/dmu_redact.h>
184 #include <sys/dmu_tx.h>
185 #include <sys/sunddi.h>
186 #include <sys/policy.h>
187 #include <sys/zone.h>
188 #include <sys/nvpair.h>
189 #include <sys/pathname.h>
190 #include <sys/fs/zfs.h>
191 #include <sys/zfs_ctldir.h>
192 #include <sys/zfs_dir.h>
193 #include <sys/zfs_onexit.h>
194 #include <sys/zvol.h>
195 #include <sys/dsl_scan.h>
196 #include <sys/fm/util.h>
197 #include <sys/dsl_crypt.h>
198 #include <sys/rrwlock.h>
199 #include <sys/zfs_file.h>
200 
201 #include <sys/dmu_recv.h>
202 #include <sys/dmu_send.h>
203 #include <sys/dmu_recv.h>
204 #include <sys/dsl_destroy.h>
205 #include <sys/dsl_bookmark.h>
206 #include <sys/dsl_userhold.h>
207 #include <sys/zfeature.h>
208 #include <sys/zcp.h>
209 #include <sys/zio_checksum.h>
210 #include <sys/vdev_removal.h>
211 #include <sys/vdev_impl.h>
212 #include <sys/vdev_initialize.h>
213 #include <sys/vdev_trim.h>
214 
215 #include "zfs_namecheck.h"
216 #include "zfs_prop.h"
217 #include "zfs_deleg.h"
218 #include "zfs_comutil.h"
219 
220 #include <sys/lua/lua.h>
221 #include <sys/lua/lauxlib.h>
222 #include <sys/zfs_ioctl_impl.h>
223 
224 kmutex_t zfsdev_state_lock;
225 static zfsdev_state_t *zfsdev_state_list;
226 
227 /*
228  * Limit maximum nvlist size.  We don't want users passing in insane values
229  * for zc->zc_nvlist_src_size, since we will need to allocate that much memory.
230  * Defaults to 0=auto which is handled by platform code.
231  */
232 unsigned long zfs_max_nvlist_src_size = 0;
233 
234 /*
235  * When logging the output nvlist of an ioctl in the on-disk history, limit
236  * the logged size to this many bytes.  This must be less than DMU_MAX_ACCESS.
237  * This applies primarily to zfs_ioc_channel_program().
238  */
239 static unsigned long zfs_history_output_max = 1024 * 1024;
240 
241 uint_t zfs_fsyncer_key;
242 uint_t zfs_allow_log_key;
243 
244 /* DATA_TYPE_ANY is used when zkey_type can vary. */
245 #define	DATA_TYPE_ANY	DATA_TYPE_UNKNOWN
246 
247 typedef struct zfs_ioc_vec {
248 	zfs_ioc_legacy_func_t	*zvec_legacy_func;
249 	zfs_ioc_func_t		*zvec_func;
250 	zfs_secpolicy_func_t	*zvec_secpolicy;
251 	zfs_ioc_namecheck_t	zvec_namecheck;
252 	boolean_t		zvec_allow_log;
253 	zfs_ioc_poolcheck_t	zvec_pool_check;
254 	boolean_t		zvec_smush_outnvlist;
255 	const char		*zvec_name;
256 	const zfs_ioc_key_t	*zvec_nvl_keys;
257 	size_t			zvec_nvl_key_count;
258 } zfs_ioc_vec_t;
259 
260 /* This array is indexed by zfs_userquota_prop_t */
261 static const char *userquota_perms[] = {
262 	ZFS_DELEG_PERM_USERUSED,
263 	ZFS_DELEG_PERM_USERQUOTA,
264 	ZFS_DELEG_PERM_GROUPUSED,
265 	ZFS_DELEG_PERM_GROUPQUOTA,
266 	ZFS_DELEG_PERM_USEROBJUSED,
267 	ZFS_DELEG_PERM_USEROBJQUOTA,
268 	ZFS_DELEG_PERM_GROUPOBJUSED,
269 	ZFS_DELEG_PERM_GROUPOBJQUOTA,
270 	ZFS_DELEG_PERM_PROJECTUSED,
271 	ZFS_DELEG_PERM_PROJECTQUOTA,
272 	ZFS_DELEG_PERM_PROJECTOBJUSED,
273 	ZFS_DELEG_PERM_PROJECTOBJQUOTA,
274 };
275 
276 static int zfs_ioc_userspace_upgrade(zfs_cmd_t *zc);
277 static int zfs_ioc_id_quota_upgrade(zfs_cmd_t *zc);
278 static int zfs_check_settable(const char *name, nvpair_t *property,
279     cred_t *cr);
280 static int zfs_check_clearable(const char *dataset, nvlist_t *props,
281     nvlist_t **errors);
282 static int zfs_fill_zplprops_root(uint64_t, nvlist_t *, nvlist_t *,
283     boolean_t *);
284 int zfs_set_prop_nvlist(const char *, zprop_source_t, nvlist_t *, nvlist_t *);
285 static int get_nvlist(uint64_t nvl, uint64_t size, int iflag, nvlist_t **nvp);
286 
287 static void
288 history_str_free(char *buf)
289 {
290 	kmem_free(buf, HIS_MAX_RECORD_LEN);
291 }
292 
293 static char *
294 history_str_get(zfs_cmd_t *zc)
295 {
296 	char *buf;
297 
298 	if (zc->zc_history == 0)
299 		return (NULL);
300 
301 	buf = kmem_alloc(HIS_MAX_RECORD_LEN, KM_SLEEP);
302 	if (copyinstr((void *)(uintptr_t)zc->zc_history,
303 	    buf, HIS_MAX_RECORD_LEN, NULL) != 0) {
304 		history_str_free(buf);
305 		return (NULL);
306 	}
307 
308 	buf[HIS_MAX_RECORD_LEN -1] = '\0';
309 
310 	return (buf);
311 }
312 
313 /*
314  * Return non-zero if the spa version is less than requested version.
315  */
316 static int
317 zfs_earlier_version(const char *name, int version)
318 {
319 	spa_t *spa;
320 
321 	if (spa_open(name, &spa, FTAG) == 0) {
322 		if (spa_version(spa) < version) {
323 			spa_close(spa, FTAG);
324 			return (1);
325 		}
326 		spa_close(spa, FTAG);
327 	}
328 	return (0);
329 }
330 
331 /*
332  * Return TRUE if the ZPL version is less than requested version.
333  */
334 static boolean_t
335 zpl_earlier_version(const char *name, int version)
336 {
337 	objset_t *os;
338 	boolean_t rc = B_TRUE;
339 
340 	if (dmu_objset_hold(name, FTAG, &os) == 0) {
341 		uint64_t zplversion;
342 
343 		if (dmu_objset_type(os) != DMU_OST_ZFS) {
344 			dmu_objset_rele(os, FTAG);
345 			return (B_TRUE);
346 		}
347 		/* XXX reading from non-owned objset */
348 		if (zfs_get_zplprop(os, ZFS_PROP_VERSION, &zplversion) == 0)
349 			rc = zplversion < version;
350 		dmu_objset_rele(os, FTAG);
351 	}
352 	return (rc);
353 }
354 
355 static void
356 zfs_log_history(zfs_cmd_t *zc)
357 {
358 	spa_t *spa;
359 	char *buf;
360 
361 	if ((buf = history_str_get(zc)) == NULL)
362 		return;
363 
364 	if (spa_open(zc->zc_name, &spa, FTAG) == 0) {
365 		if (spa_version(spa) >= SPA_VERSION_ZPOOL_HISTORY)
366 			(void) spa_history_log(spa, buf);
367 		spa_close(spa, FTAG);
368 	}
369 	history_str_free(buf);
370 }
371 
372 /*
373  * Policy for top-level read operations (list pools).  Requires no privileges,
374  * and can be used in the local zone, as there is no associated dataset.
375  */
376 static int
377 zfs_secpolicy_none(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
378 {
379 	(void) zc, (void) innvl, (void) cr;
380 	return (0);
381 }
382 
383 /*
384  * Policy for dataset read operations (list children, get statistics).  Requires
385  * no privileges, but must be visible in the local zone.
386  */
387 static int
388 zfs_secpolicy_read(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
389 {
390 	(void) innvl, (void) cr;
391 	if (INGLOBALZONE(curproc) ||
392 	    zone_dataset_visible(zc->zc_name, NULL))
393 		return (0);
394 
395 	return (SET_ERROR(ENOENT));
396 }
397 
398 static int
399 zfs_dozonecheck_impl(const char *dataset, uint64_t zoned, cred_t *cr)
400 {
401 	int writable = 1;
402 
403 	/*
404 	 * The dataset must be visible by this zone -- check this first
405 	 * so they don't see EPERM on something they shouldn't know about.
406 	 */
407 	if (!INGLOBALZONE(curproc) &&
408 	    !zone_dataset_visible(dataset, &writable))
409 		return (SET_ERROR(ENOENT));
410 
411 	if (INGLOBALZONE(curproc)) {
412 		/*
413 		 * If the fs is zoned, only root can access it from the
414 		 * global zone.
415 		 */
416 		if (secpolicy_zfs(cr) && zoned)
417 			return (SET_ERROR(EPERM));
418 	} else {
419 		/*
420 		 * If we are in a local zone, the 'zoned' property must be set.
421 		 */
422 		if (!zoned)
423 			return (SET_ERROR(EPERM));
424 
425 		/* must be writable by this zone */
426 		if (!writable)
427 			return (SET_ERROR(EPERM));
428 	}
429 	return (0);
430 }
431 
432 static int
433 zfs_dozonecheck(const char *dataset, cred_t *cr)
434 {
435 	uint64_t zoned;
436 
437 	if (dsl_prop_get_integer(dataset, zfs_prop_to_name(ZFS_PROP_ZONED),
438 	    &zoned, NULL))
439 		return (SET_ERROR(ENOENT));
440 
441 	return (zfs_dozonecheck_impl(dataset, zoned, cr));
442 }
443 
444 static int
445 zfs_dozonecheck_ds(const char *dataset, dsl_dataset_t *ds, cred_t *cr)
446 {
447 	uint64_t zoned;
448 
449 	if (dsl_prop_get_int_ds(ds, zfs_prop_to_name(ZFS_PROP_ZONED), &zoned))
450 		return (SET_ERROR(ENOENT));
451 
452 	return (zfs_dozonecheck_impl(dataset, zoned, cr));
453 }
454 
455 static int
456 zfs_secpolicy_write_perms_ds(const char *name, dsl_dataset_t *ds,
457     const char *perm, cred_t *cr)
458 {
459 	int error;
460 
461 	error = zfs_dozonecheck_ds(name, ds, cr);
462 	if (error == 0) {
463 		error = secpolicy_zfs(cr);
464 		if (error != 0)
465 			error = dsl_deleg_access_impl(ds, perm, cr);
466 	}
467 	return (error);
468 }
469 
470 static int
471 zfs_secpolicy_write_perms(const char *name, const char *perm, cred_t *cr)
472 {
473 	int error;
474 	dsl_dataset_t *ds;
475 	dsl_pool_t *dp;
476 
477 	/*
478 	 * First do a quick check for root in the global zone, which
479 	 * is allowed to do all write_perms.  This ensures that zfs_ioc_*
480 	 * will get to handle nonexistent datasets.
481 	 */
482 	if (INGLOBALZONE(curproc) && secpolicy_zfs(cr) == 0)
483 		return (0);
484 
485 	error = dsl_pool_hold(name, FTAG, &dp);
486 	if (error != 0)
487 		return (error);
488 
489 	error = dsl_dataset_hold(dp, name, FTAG, &ds);
490 	if (error != 0) {
491 		dsl_pool_rele(dp, FTAG);
492 		return (error);
493 	}
494 
495 	error = zfs_secpolicy_write_perms_ds(name, ds, perm, cr);
496 
497 	dsl_dataset_rele(ds, FTAG);
498 	dsl_pool_rele(dp, FTAG);
499 	return (error);
500 }
501 
502 /*
503  * Policy for setting the security label property.
504  *
505  * Returns 0 for success, non-zero for access and other errors.
506  */
507 static int
508 zfs_set_slabel_policy(const char *name, const char *strval, cred_t *cr)
509 {
510 #ifdef HAVE_MLSLABEL
511 	char		ds_hexsl[MAXNAMELEN];
512 	bslabel_t	ds_sl, new_sl;
513 	boolean_t	new_default = FALSE;
514 	uint64_t	zoned;
515 	int		needed_priv = -1;
516 	int		error;
517 
518 	/* First get the existing dataset label. */
519 	error = dsl_prop_get(name, zfs_prop_to_name(ZFS_PROP_MLSLABEL),
520 	    1, sizeof (ds_hexsl), &ds_hexsl, NULL);
521 	if (error != 0)
522 		return (SET_ERROR(EPERM));
523 
524 	if (strcasecmp(strval, ZFS_MLSLABEL_DEFAULT) == 0)
525 		new_default = TRUE;
526 
527 	/* The label must be translatable */
528 	if (!new_default && (hexstr_to_label(strval, &new_sl) != 0))
529 		return (SET_ERROR(EINVAL));
530 
531 	/*
532 	 * In a non-global zone, disallow attempts to set a label that
533 	 * doesn't match that of the zone; otherwise no other checks
534 	 * are needed.
535 	 */
536 	if (!INGLOBALZONE(curproc)) {
537 		if (new_default || !blequal(&new_sl, CR_SL(CRED())))
538 			return (SET_ERROR(EPERM));
539 		return (0);
540 	}
541 
542 	/*
543 	 * For global-zone datasets (i.e., those whose zoned property is
544 	 * "off", verify that the specified new label is valid for the
545 	 * global zone.
546 	 */
547 	if (dsl_prop_get_integer(name,
548 	    zfs_prop_to_name(ZFS_PROP_ZONED), &zoned, NULL))
549 		return (SET_ERROR(EPERM));
550 	if (!zoned) {
551 		if (zfs_check_global_label(name, strval) != 0)
552 			return (SET_ERROR(EPERM));
553 	}
554 
555 	/*
556 	 * If the existing dataset label is nondefault, check if the
557 	 * dataset is mounted (label cannot be changed while mounted).
558 	 * Get the zfsvfs_t; if there isn't one, then the dataset isn't
559 	 * mounted (or isn't a dataset, doesn't exist, ...).
560 	 */
561 	if (strcasecmp(ds_hexsl, ZFS_MLSLABEL_DEFAULT) != 0) {
562 		objset_t *os;
563 		static const char *setsl_tag = "setsl_tag";
564 
565 		/*
566 		 * Try to own the dataset; abort if there is any error,
567 		 * (e.g., already mounted, in use, or other error).
568 		 */
569 		error = dmu_objset_own(name, DMU_OST_ZFS, B_TRUE, B_TRUE,
570 		    setsl_tag, &os);
571 		if (error != 0)
572 			return (SET_ERROR(EPERM));
573 
574 		dmu_objset_disown(os, B_TRUE, setsl_tag);
575 
576 		if (new_default) {
577 			needed_priv = PRIV_FILE_DOWNGRADE_SL;
578 			goto out_check;
579 		}
580 
581 		if (hexstr_to_label(strval, &new_sl) != 0)
582 			return (SET_ERROR(EPERM));
583 
584 		if (blstrictdom(&ds_sl, &new_sl))
585 			needed_priv = PRIV_FILE_DOWNGRADE_SL;
586 		else if (blstrictdom(&new_sl, &ds_sl))
587 			needed_priv = PRIV_FILE_UPGRADE_SL;
588 	} else {
589 		/* dataset currently has a default label */
590 		if (!new_default)
591 			needed_priv = PRIV_FILE_UPGRADE_SL;
592 	}
593 
594 out_check:
595 	if (needed_priv != -1)
596 		return (PRIV_POLICY(cr, needed_priv, B_FALSE, EPERM, NULL));
597 	return (0);
598 #else
599 	return (SET_ERROR(ENOTSUP));
600 #endif /* HAVE_MLSLABEL */
601 }
602 
603 static int
604 zfs_secpolicy_setprop(const char *dsname, zfs_prop_t prop, nvpair_t *propval,
605     cred_t *cr)
606 {
607 	char *strval;
608 
609 	/*
610 	 * Check permissions for special properties.
611 	 */
612 	switch (prop) {
613 	default:
614 		break;
615 	case ZFS_PROP_ZONED:
616 		/*
617 		 * Disallow setting of 'zoned' from within a local zone.
618 		 */
619 		if (!INGLOBALZONE(curproc))
620 			return (SET_ERROR(EPERM));
621 		break;
622 
623 	case ZFS_PROP_QUOTA:
624 	case ZFS_PROP_FILESYSTEM_LIMIT:
625 	case ZFS_PROP_SNAPSHOT_LIMIT:
626 		if (!INGLOBALZONE(curproc)) {
627 			uint64_t zoned;
628 			char setpoint[ZFS_MAX_DATASET_NAME_LEN];
629 			/*
630 			 * Unprivileged users are allowed to modify the
631 			 * limit on things *under* (ie. contained by)
632 			 * the thing they own.
633 			 */
634 			if (dsl_prop_get_integer(dsname,
635 			    zfs_prop_to_name(ZFS_PROP_ZONED), &zoned, setpoint))
636 				return (SET_ERROR(EPERM));
637 			if (!zoned || strlen(dsname) <= strlen(setpoint))
638 				return (SET_ERROR(EPERM));
639 		}
640 		break;
641 
642 	case ZFS_PROP_MLSLABEL:
643 		if (!is_system_labeled())
644 			return (SET_ERROR(EPERM));
645 
646 		if (nvpair_value_string(propval, &strval) == 0) {
647 			int err;
648 
649 			err = zfs_set_slabel_policy(dsname, strval, CRED());
650 			if (err != 0)
651 				return (err);
652 		}
653 		break;
654 	}
655 
656 	return (zfs_secpolicy_write_perms(dsname, zfs_prop_to_name(prop), cr));
657 }
658 
659 static int
660 zfs_secpolicy_set_fsacl(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
661 {
662 	/*
663 	 * permission to set permissions will be evaluated later in
664 	 * dsl_deleg_can_allow()
665 	 */
666 	(void) innvl;
667 	return (zfs_dozonecheck(zc->zc_name, cr));
668 }
669 
670 static int
671 zfs_secpolicy_rollback(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
672 {
673 	(void) innvl;
674 	return (zfs_secpolicy_write_perms(zc->zc_name,
675 	    ZFS_DELEG_PERM_ROLLBACK, cr));
676 }
677 
678 static int
679 zfs_secpolicy_send(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
680 {
681 	(void) innvl;
682 	dsl_pool_t *dp;
683 	dsl_dataset_t *ds;
684 	const char *cp;
685 	int error;
686 
687 	/*
688 	 * Generate the current snapshot name from the given objsetid, then
689 	 * use that name for the secpolicy/zone checks.
690 	 */
691 	cp = strchr(zc->zc_name, '@');
692 	if (cp == NULL)
693 		return (SET_ERROR(EINVAL));
694 	error = dsl_pool_hold(zc->zc_name, FTAG, &dp);
695 	if (error != 0)
696 		return (error);
697 
698 	error = dsl_dataset_hold_obj(dp, zc->zc_sendobj, FTAG, &ds);
699 	if (error != 0) {
700 		dsl_pool_rele(dp, FTAG);
701 		return (error);
702 	}
703 
704 	dsl_dataset_name(ds, zc->zc_name);
705 
706 	error = zfs_secpolicy_write_perms_ds(zc->zc_name, ds,
707 	    ZFS_DELEG_PERM_SEND, cr);
708 	dsl_dataset_rele(ds, FTAG);
709 	dsl_pool_rele(dp, FTAG);
710 
711 	return (error);
712 }
713 
714 static int
715 zfs_secpolicy_send_new(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
716 {
717 	(void) innvl;
718 	return (zfs_secpolicy_write_perms(zc->zc_name,
719 	    ZFS_DELEG_PERM_SEND, cr));
720 }
721 
722 static int
723 zfs_secpolicy_share(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
724 {
725 	(void) zc, (void) innvl, (void) cr;
726 	return (SET_ERROR(ENOTSUP));
727 }
728 
729 static int
730 zfs_secpolicy_smb_acl(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
731 {
732 	(void) zc, (void) innvl, (void) cr;
733 	return (SET_ERROR(ENOTSUP));
734 }
735 
736 static int
737 zfs_get_parent(const char *datasetname, char *parent, int parentsize)
738 {
739 	char *cp;
740 
741 	/*
742 	 * Remove the @bla or /bla from the end of the name to get the parent.
743 	 */
744 	(void) strncpy(parent, datasetname, parentsize);
745 	cp = strrchr(parent, '@');
746 	if (cp != NULL) {
747 		cp[0] = '\0';
748 	} else {
749 		cp = strrchr(parent, '/');
750 		if (cp == NULL)
751 			return (SET_ERROR(ENOENT));
752 		cp[0] = '\0';
753 	}
754 
755 	return (0);
756 }
757 
758 int
759 zfs_secpolicy_destroy_perms(const char *name, cred_t *cr)
760 {
761 	int error;
762 
763 	if ((error = zfs_secpolicy_write_perms(name,
764 	    ZFS_DELEG_PERM_MOUNT, cr)) != 0)
765 		return (error);
766 
767 	return (zfs_secpolicy_write_perms(name, ZFS_DELEG_PERM_DESTROY, cr));
768 }
769 
770 static int
771 zfs_secpolicy_destroy(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
772 {
773 	(void) innvl;
774 	return (zfs_secpolicy_destroy_perms(zc->zc_name, cr));
775 }
776 
777 /*
778  * Destroying snapshots with delegated permissions requires
779  * descendant mount and destroy permissions.
780  */
781 static int
782 zfs_secpolicy_destroy_snaps(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
783 {
784 	(void) zc;
785 	nvlist_t *snaps;
786 	nvpair_t *pair, *nextpair;
787 	int error = 0;
788 
789 	snaps = fnvlist_lookup_nvlist(innvl, "snaps");
790 
791 	for (pair = nvlist_next_nvpair(snaps, NULL); pair != NULL;
792 	    pair = nextpair) {
793 		nextpair = nvlist_next_nvpair(snaps, pair);
794 		error = zfs_secpolicy_destroy_perms(nvpair_name(pair), cr);
795 		if (error == ENOENT) {
796 			/*
797 			 * Ignore any snapshots that don't exist (we consider
798 			 * them "already destroyed").  Remove the name from the
799 			 * nvl here in case the snapshot is created between
800 			 * now and when we try to destroy it (in which case
801 			 * we don't want to destroy it since we haven't
802 			 * checked for permission).
803 			 */
804 			fnvlist_remove_nvpair(snaps, pair);
805 			error = 0;
806 		}
807 		if (error != 0)
808 			break;
809 	}
810 
811 	return (error);
812 }
813 
814 int
815 zfs_secpolicy_rename_perms(const char *from, const char *to, cred_t *cr)
816 {
817 	char	parentname[ZFS_MAX_DATASET_NAME_LEN];
818 	int	error;
819 
820 	if ((error = zfs_secpolicy_write_perms(from,
821 	    ZFS_DELEG_PERM_RENAME, cr)) != 0)
822 		return (error);
823 
824 	if ((error = zfs_secpolicy_write_perms(from,
825 	    ZFS_DELEG_PERM_MOUNT, cr)) != 0)
826 		return (error);
827 
828 	if ((error = zfs_get_parent(to, parentname,
829 	    sizeof (parentname))) != 0)
830 		return (error);
831 
832 	if ((error = zfs_secpolicy_write_perms(parentname,
833 	    ZFS_DELEG_PERM_CREATE, cr)) != 0)
834 		return (error);
835 
836 	if ((error = zfs_secpolicy_write_perms(parentname,
837 	    ZFS_DELEG_PERM_MOUNT, cr)) != 0)
838 		return (error);
839 
840 	return (error);
841 }
842 
843 static int
844 zfs_secpolicy_rename(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
845 {
846 	(void) innvl;
847 	return (zfs_secpolicy_rename_perms(zc->zc_name, zc->zc_value, cr));
848 }
849 
850 static int
851 zfs_secpolicy_promote(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
852 {
853 	(void) innvl;
854 	dsl_pool_t *dp;
855 	dsl_dataset_t *clone;
856 	int error;
857 
858 	error = zfs_secpolicy_write_perms(zc->zc_name,
859 	    ZFS_DELEG_PERM_PROMOTE, cr);
860 	if (error != 0)
861 		return (error);
862 
863 	error = dsl_pool_hold(zc->zc_name, FTAG, &dp);
864 	if (error != 0)
865 		return (error);
866 
867 	error = dsl_dataset_hold(dp, zc->zc_name, FTAG, &clone);
868 
869 	if (error == 0) {
870 		char parentname[ZFS_MAX_DATASET_NAME_LEN];
871 		dsl_dataset_t *origin = NULL;
872 		dsl_dir_t *dd;
873 		dd = clone->ds_dir;
874 
875 		error = dsl_dataset_hold_obj(dd->dd_pool,
876 		    dsl_dir_phys(dd)->dd_origin_obj, FTAG, &origin);
877 		if (error != 0) {
878 			dsl_dataset_rele(clone, FTAG);
879 			dsl_pool_rele(dp, FTAG);
880 			return (error);
881 		}
882 
883 		error = zfs_secpolicy_write_perms_ds(zc->zc_name, clone,
884 		    ZFS_DELEG_PERM_MOUNT, cr);
885 
886 		dsl_dataset_name(origin, parentname);
887 		if (error == 0) {
888 			error = zfs_secpolicy_write_perms_ds(parentname, origin,
889 			    ZFS_DELEG_PERM_PROMOTE, cr);
890 		}
891 		dsl_dataset_rele(clone, FTAG);
892 		dsl_dataset_rele(origin, FTAG);
893 	}
894 	dsl_pool_rele(dp, FTAG);
895 	return (error);
896 }
897 
898 static int
899 zfs_secpolicy_recv(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
900 {
901 	(void) innvl;
902 	int error;
903 
904 	if ((error = zfs_secpolicy_write_perms(zc->zc_name,
905 	    ZFS_DELEG_PERM_RECEIVE, cr)) != 0)
906 		return (error);
907 
908 	if ((error = zfs_secpolicy_write_perms(zc->zc_name,
909 	    ZFS_DELEG_PERM_MOUNT, cr)) != 0)
910 		return (error);
911 
912 	return (zfs_secpolicy_write_perms(zc->zc_name,
913 	    ZFS_DELEG_PERM_CREATE, cr));
914 }
915 
916 int
917 zfs_secpolicy_snapshot_perms(const char *name, cred_t *cr)
918 {
919 	return (zfs_secpolicy_write_perms(name,
920 	    ZFS_DELEG_PERM_SNAPSHOT, cr));
921 }
922 
923 /*
924  * Check for permission to create each snapshot in the nvlist.
925  */
926 static int
927 zfs_secpolicy_snapshot(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
928 {
929 	(void) zc;
930 	nvlist_t *snaps;
931 	int error = 0;
932 	nvpair_t *pair;
933 
934 	snaps = fnvlist_lookup_nvlist(innvl, "snaps");
935 
936 	for (pair = nvlist_next_nvpair(snaps, NULL); pair != NULL;
937 	    pair = nvlist_next_nvpair(snaps, pair)) {
938 		char *name = nvpair_name(pair);
939 		char *atp = strchr(name, '@');
940 
941 		if (atp == NULL) {
942 			error = SET_ERROR(EINVAL);
943 			break;
944 		}
945 		*atp = '\0';
946 		error = zfs_secpolicy_snapshot_perms(name, cr);
947 		*atp = '@';
948 		if (error != 0)
949 			break;
950 	}
951 	return (error);
952 }
953 
954 /*
955  * Check for permission to create each bookmark in the nvlist.
956  */
957 static int
958 zfs_secpolicy_bookmark(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
959 {
960 	(void) zc;
961 	int error = 0;
962 
963 	for (nvpair_t *pair = nvlist_next_nvpair(innvl, NULL);
964 	    pair != NULL; pair = nvlist_next_nvpair(innvl, pair)) {
965 		char *name = nvpair_name(pair);
966 		char *hashp = strchr(name, '#');
967 
968 		if (hashp == NULL) {
969 			error = SET_ERROR(EINVAL);
970 			break;
971 		}
972 		*hashp = '\0';
973 		error = zfs_secpolicy_write_perms(name,
974 		    ZFS_DELEG_PERM_BOOKMARK, cr);
975 		*hashp = '#';
976 		if (error != 0)
977 			break;
978 	}
979 	return (error);
980 }
981 
982 static int
983 zfs_secpolicy_destroy_bookmarks(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
984 {
985 	(void) zc;
986 	nvpair_t *pair, *nextpair;
987 	int error = 0;
988 
989 	for (pair = nvlist_next_nvpair(innvl, NULL); pair != NULL;
990 	    pair = nextpair) {
991 		char *name = nvpair_name(pair);
992 		char *hashp = strchr(name, '#');
993 		nextpair = nvlist_next_nvpair(innvl, pair);
994 
995 		if (hashp == NULL) {
996 			error = SET_ERROR(EINVAL);
997 			break;
998 		}
999 
1000 		*hashp = '\0';
1001 		error = zfs_secpolicy_write_perms(name,
1002 		    ZFS_DELEG_PERM_DESTROY, cr);
1003 		*hashp = '#';
1004 		if (error == ENOENT) {
1005 			/*
1006 			 * Ignore any filesystems that don't exist (we consider
1007 			 * their bookmarks "already destroyed").  Remove
1008 			 * the name from the nvl here in case the filesystem
1009 			 * is created between now and when we try to destroy
1010 			 * the bookmark (in which case we don't want to
1011 			 * destroy it since we haven't checked for permission).
1012 			 */
1013 			fnvlist_remove_nvpair(innvl, pair);
1014 			error = 0;
1015 		}
1016 		if (error != 0)
1017 			break;
1018 	}
1019 
1020 	return (error);
1021 }
1022 
1023 static int
1024 zfs_secpolicy_log_history(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
1025 {
1026 	(void) zc, (void) innvl, (void) cr;
1027 	/*
1028 	 * Even root must have a proper TSD so that we know what pool
1029 	 * to log to.
1030 	 */
1031 	if (tsd_get(zfs_allow_log_key) == NULL)
1032 		return (SET_ERROR(EPERM));
1033 	return (0);
1034 }
1035 
1036 static int
1037 zfs_secpolicy_create_clone(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
1038 {
1039 	char	parentname[ZFS_MAX_DATASET_NAME_LEN];
1040 	int	error;
1041 	char	*origin;
1042 
1043 	if ((error = zfs_get_parent(zc->zc_name, parentname,
1044 	    sizeof (parentname))) != 0)
1045 		return (error);
1046 
1047 	if (nvlist_lookup_string(innvl, "origin", &origin) == 0 &&
1048 	    (error = zfs_secpolicy_write_perms(origin,
1049 	    ZFS_DELEG_PERM_CLONE, cr)) != 0)
1050 		return (error);
1051 
1052 	if ((error = zfs_secpolicy_write_perms(parentname,
1053 	    ZFS_DELEG_PERM_CREATE, cr)) != 0)
1054 		return (error);
1055 
1056 	return (zfs_secpolicy_write_perms(parentname,
1057 	    ZFS_DELEG_PERM_MOUNT, cr));
1058 }
1059 
1060 /*
1061  * Policy for pool operations - create/destroy pools, add vdevs, etc.  Requires
1062  * SYS_CONFIG privilege, which is not available in a local zone.
1063  */
1064 int
1065 zfs_secpolicy_config(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
1066 {
1067 	(void) zc, (void) innvl;
1068 
1069 	if (secpolicy_sys_config(cr, B_FALSE) != 0)
1070 		return (SET_ERROR(EPERM));
1071 
1072 	return (0);
1073 }
1074 
1075 /*
1076  * Policy for object to name lookups.
1077  */
1078 static int
1079 zfs_secpolicy_diff(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
1080 {
1081 	(void) innvl;
1082 	int error;
1083 
1084 	if ((error = secpolicy_sys_config(cr, B_FALSE)) == 0)
1085 		return (0);
1086 
1087 	error = zfs_secpolicy_write_perms(zc->zc_name, ZFS_DELEG_PERM_DIFF, cr);
1088 	return (error);
1089 }
1090 
1091 /*
1092  * Policy for fault injection.  Requires all privileges.
1093  */
1094 static int
1095 zfs_secpolicy_inject(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
1096 {
1097 	(void) zc, (void) innvl;
1098 	return (secpolicy_zinject(cr));
1099 }
1100 
1101 static int
1102 zfs_secpolicy_inherit_prop(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
1103 {
1104 	(void) innvl;
1105 	zfs_prop_t prop = zfs_name_to_prop(zc->zc_value);
1106 
1107 	if (prop == ZPROP_USERPROP) {
1108 		if (!zfs_prop_user(zc->zc_value))
1109 			return (SET_ERROR(EINVAL));
1110 		return (zfs_secpolicy_write_perms(zc->zc_name,
1111 		    ZFS_DELEG_PERM_USERPROP, cr));
1112 	} else {
1113 		return (zfs_secpolicy_setprop(zc->zc_name, prop,
1114 		    NULL, cr));
1115 	}
1116 }
1117 
1118 static int
1119 zfs_secpolicy_userspace_one(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
1120 {
1121 	int err = zfs_secpolicy_read(zc, innvl, cr);
1122 	if (err)
1123 		return (err);
1124 
1125 	if (zc->zc_objset_type >= ZFS_NUM_USERQUOTA_PROPS)
1126 		return (SET_ERROR(EINVAL));
1127 
1128 	if (zc->zc_value[0] == 0) {
1129 		/*
1130 		 * They are asking about a posix uid/gid.  If it's
1131 		 * themself, allow it.
1132 		 */
1133 		if (zc->zc_objset_type == ZFS_PROP_USERUSED ||
1134 		    zc->zc_objset_type == ZFS_PROP_USERQUOTA ||
1135 		    zc->zc_objset_type == ZFS_PROP_USEROBJUSED ||
1136 		    zc->zc_objset_type == ZFS_PROP_USEROBJQUOTA) {
1137 			if (zc->zc_guid == crgetuid(cr))
1138 				return (0);
1139 		} else if (zc->zc_objset_type == ZFS_PROP_GROUPUSED ||
1140 		    zc->zc_objset_type == ZFS_PROP_GROUPQUOTA ||
1141 		    zc->zc_objset_type == ZFS_PROP_GROUPOBJUSED ||
1142 		    zc->zc_objset_type == ZFS_PROP_GROUPOBJQUOTA) {
1143 			if (groupmember(zc->zc_guid, cr))
1144 				return (0);
1145 		}
1146 		/* else is for project quota/used */
1147 	}
1148 
1149 	return (zfs_secpolicy_write_perms(zc->zc_name,
1150 	    userquota_perms[zc->zc_objset_type], cr));
1151 }
1152 
1153 static int
1154 zfs_secpolicy_userspace_many(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
1155 {
1156 	int err = zfs_secpolicy_read(zc, innvl, cr);
1157 	if (err)
1158 		return (err);
1159 
1160 	if (zc->zc_objset_type >= ZFS_NUM_USERQUOTA_PROPS)
1161 		return (SET_ERROR(EINVAL));
1162 
1163 	return (zfs_secpolicy_write_perms(zc->zc_name,
1164 	    userquota_perms[zc->zc_objset_type], cr));
1165 }
1166 
1167 static int
1168 zfs_secpolicy_userspace_upgrade(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
1169 {
1170 	(void) innvl;
1171 	return (zfs_secpolicy_setprop(zc->zc_name, ZFS_PROP_VERSION,
1172 	    NULL, cr));
1173 }
1174 
1175 static int
1176 zfs_secpolicy_hold(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
1177 {
1178 	(void) zc;
1179 	nvpair_t *pair;
1180 	nvlist_t *holds;
1181 	int error;
1182 
1183 	holds = fnvlist_lookup_nvlist(innvl, "holds");
1184 
1185 	for (pair = nvlist_next_nvpair(holds, NULL); pair != NULL;
1186 	    pair = nvlist_next_nvpair(holds, pair)) {
1187 		char fsname[ZFS_MAX_DATASET_NAME_LEN];
1188 		error = dmu_fsname(nvpair_name(pair), fsname);
1189 		if (error != 0)
1190 			return (error);
1191 		error = zfs_secpolicy_write_perms(fsname,
1192 		    ZFS_DELEG_PERM_HOLD, cr);
1193 		if (error != 0)
1194 			return (error);
1195 	}
1196 	return (0);
1197 }
1198 
1199 static int
1200 zfs_secpolicy_release(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
1201 {
1202 	(void) zc;
1203 	nvpair_t *pair;
1204 	int error;
1205 
1206 	for (pair = nvlist_next_nvpair(innvl, NULL); pair != NULL;
1207 	    pair = nvlist_next_nvpair(innvl, pair)) {
1208 		char fsname[ZFS_MAX_DATASET_NAME_LEN];
1209 		error = dmu_fsname(nvpair_name(pair), fsname);
1210 		if (error != 0)
1211 			return (error);
1212 		error = zfs_secpolicy_write_perms(fsname,
1213 		    ZFS_DELEG_PERM_RELEASE, cr);
1214 		if (error != 0)
1215 			return (error);
1216 	}
1217 	return (0);
1218 }
1219 
1220 /*
1221  * Policy for allowing temporary snapshots to be taken or released
1222  */
1223 static int
1224 zfs_secpolicy_tmp_snapshot(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
1225 {
1226 	/*
1227 	 * A temporary snapshot is the same as a snapshot,
1228 	 * hold, destroy and release all rolled into one.
1229 	 * Delegated diff alone is sufficient that we allow this.
1230 	 */
1231 	int error;
1232 
1233 	if ((error = zfs_secpolicy_write_perms(zc->zc_name,
1234 	    ZFS_DELEG_PERM_DIFF, cr)) == 0)
1235 		return (0);
1236 
1237 	error = zfs_secpolicy_snapshot_perms(zc->zc_name, cr);
1238 
1239 	if (innvl != NULL) {
1240 		if (error == 0)
1241 			error = zfs_secpolicy_hold(zc, innvl, cr);
1242 		if (error == 0)
1243 			error = zfs_secpolicy_release(zc, innvl, cr);
1244 		if (error == 0)
1245 			error = zfs_secpolicy_destroy(zc, innvl, cr);
1246 	}
1247 	return (error);
1248 }
1249 
1250 static int
1251 zfs_secpolicy_load_key(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
1252 {
1253 	return (zfs_secpolicy_write_perms(zc->zc_name,
1254 	    ZFS_DELEG_PERM_LOAD_KEY, cr));
1255 }
1256 
1257 static int
1258 zfs_secpolicy_change_key(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
1259 {
1260 	return (zfs_secpolicy_write_perms(zc->zc_name,
1261 	    ZFS_DELEG_PERM_CHANGE_KEY, cr));
1262 }
1263 
1264 /*
1265  * Returns the nvlist as specified by the user in the zfs_cmd_t.
1266  */
1267 static int
1268 get_nvlist(uint64_t nvl, uint64_t size, int iflag, nvlist_t **nvp)
1269 {
1270 	char *packed;
1271 	int error;
1272 	nvlist_t *list = NULL;
1273 
1274 	/*
1275 	 * Read in and unpack the user-supplied nvlist.
1276 	 */
1277 	if (size == 0)
1278 		return (SET_ERROR(EINVAL));
1279 
1280 	packed = vmem_alloc(size, KM_SLEEP);
1281 
1282 	if ((error = ddi_copyin((void *)(uintptr_t)nvl, packed, size,
1283 	    iflag)) != 0) {
1284 		vmem_free(packed, size);
1285 		return (SET_ERROR(EFAULT));
1286 	}
1287 
1288 	if ((error = nvlist_unpack(packed, size, &list, 0)) != 0) {
1289 		vmem_free(packed, size);
1290 		return (error);
1291 	}
1292 
1293 	vmem_free(packed, size);
1294 
1295 	*nvp = list;
1296 	return (0);
1297 }
1298 
1299 /*
1300  * Reduce the size of this nvlist until it can be serialized in 'max' bytes.
1301  * Entries will be removed from the end of the nvlist, and one int32 entry
1302  * named "N_MORE_ERRORS" will be added indicating how many entries were
1303  * removed.
1304  */
1305 static int
1306 nvlist_smush(nvlist_t *errors, size_t max)
1307 {
1308 	size_t size;
1309 
1310 	size = fnvlist_size(errors);
1311 
1312 	if (size > max) {
1313 		nvpair_t *more_errors;
1314 		int n = 0;
1315 
1316 		if (max < 1024)
1317 			return (SET_ERROR(ENOMEM));
1318 
1319 		fnvlist_add_int32(errors, ZPROP_N_MORE_ERRORS, 0);
1320 		more_errors = nvlist_prev_nvpair(errors, NULL);
1321 
1322 		do {
1323 			nvpair_t *pair = nvlist_prev_nvpair(errors,
1324 			    more_errors);
1325 			fnvlist_remove_nvpair(errors, pair);
1326 			n++;
1327 			size = fnvlist_size(errors);
1328 		} while (size > max);
1329 
1330 		fnvlist_remove_nvpair(errors, more_errors);
1331 		fnvlist_add_int32(errors, ZPROP_N_MORE_ERRORS, n);
1332 		ASSERT3U(fnvlist_size(errors), <=, max);
1333 	}
1334 
1335 	return (0);
1336 }
1337 
1338 static int
1339 put_nvlist(zfs_cmd_t *zc, nvlist_t *nvl)
1340 {
1341 	char *packed = NULL;
1342 	int error = 0;
1343 	size_t size;
1344 
1345 	size = fnvlist_size(nvl);
1346 
1347 	if (size > zc->zc_nvlist_dst_size) {
1348 		error = SET_ERROR(ENOMEM);
1349 	} else {
1350 		packed = fnvlist_pack(nvl, &size);
1351 		if (ddi_copyout(packed, (void *)(uintptr_t)zc->zc_nvlist_dst,
1352 		    size, zc->zc_iflags) != 0)
1353 			error = SET_ERROR(EFAULT);
1354 		fnvlist_pack_free(packed, size);
1355 	}
1356 
1357 	zc->zc_nvlist_dst_size = size;
1358 	zc->zc_nvlist_dst_filled = B_TRUE;
1359 	return (error);
1360 }
1361 
1362 int
1363 getzfsvfs_impl(objset_t *os, zfsvfs_t **zfvp)
1364 {
1365 	int error = 0;
1366 	if (dmu_objset_type(os) != DMU_OST_ZFS) {
1367 		return (SET_ERROR(EINVAL));
1368 	}
1369 
1370 	mutex_enter(&os->os_user_ptr_lock);
1371 	*zfvp = dmu_objset_get_user(os);
1372 	/* bump s_active only when non-zero to prevent umount race */
1373 	error = zfs_vfs_ref(zfvp);
1374 	mutex_exit(&os->os_user_ptr_lock);
1375 	return (error);
1376 }
1377 
1378 int
1379 getzfsvfs(const char *dsname, zfsvfs_t **zfvp)
1380 {
1381 	objset_t *os;
1382 	int error;
1383 
1384 	error = dmu_objset_hold(dsname, FTAG, &os);
1385 	if (error != 0)
1386 		return (error);
1387 
1388 	error = getzfsvfs_impl(os, zfvp);
1389 	dmu_objset_rele(os, FTAG);
1390 	return (error);
1391 }
1392 
1393 /*
1394  * Find a zfsvfs_t for a mounted filesystem, or create our own, in which
1395  * case its z_sb will be NULL, and it will be opened as the owner.
1396  * If 'writer' is set, the z_teardown_lock will be held for RW_WRITER,
1397  * which prevents all inode ops from running.
1398  */
1399 static int
1400 zfsvfs_hold(const char *name, const void *tag, zfsvfs_t **zfvp,
1401     boolean_t writer)
1402 {
1403 	int error = 0;
1404 
1405 	if (getzfsvfs(name, zfvp) != 0)
1406 		error = zfsvfs_create(name, B_FALSE, zfvp);
1407 	if (error == 0) {
1408 		if (writer)
1409 			ZFS_TEARDOWN_ENTER_WRITE(*zfvp, tag);
1410 		else
1411 			ZFS_TEARDOWN_ENTER_READ(*zfvp, tag);
1412 		if ((*zfvp)->z_unmounted) {
1413 			/*
1414 			 * XXX we could probably try again, since the unmounting
1415 			 * thread should be just about to disassociate the
1416 			 * objset from the zfsvfs.
1417 			 */
1418 			ZFS_TEARDOWN_EXIT(*zfvp, tag);
1419 			return (SET_ERROR(EBUSY));
1420 		}
1421 	}
1422 	return (error);
1423 }
1424 
1425 static void
1426 zfsvfs_rele(zfsvfs_t *zfsvfs, const void *tag)
1427 {
1428 	ZFS_TEARDOWN_EXIT(zfsvfs, tag);
1429 
1430 	if (zfs_vfs_held(zfsvfs)) {
1431 		zfs_vfs_rele(zfsvfs);
1432 	} else {
1433 		dmu_objset_disown(zfsvfs->z_os, B_TRUE, zfsvfs);
1434 		zfsvfs_free(zfsvfs);
1435 	}
1436 }
1437 
1438 static int
1439 zfs_ioc_pool_create(zfs_cmd_t *zc)
1440 {
1441 	int error;
1442 	nvlist_t *config, *props = NULL;
1443 	nvlist_t *rootprops = NULL;
1444 	nvlist_t *zplprops = NULL;
1445 	dsl_crypto_params_t *dcp = NULL;
1446 	const char *spa_name = zc->zc_name;
1447 	boolean_t unload_wkey = B_TRUE;
1448 
1449 	if ((error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size,
1450 	    zc->zc_iflags, &config)))
1451 		return (error);
1452 
1453 	if (zc->zc_nvlist_src_size != 0 && (error =
1454 	    get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
1455 	    zc->zc_iflags, &props))) {
1456 		nvlist_free(config);
1457 		return (error);
1458 	}
1459 
1460 	if (props) {
1461 		nvlist_t *nvl = NULL;
1462 		nvlist_t *hidden_args = NULL;
1463 		uint64_t version = SPA_VERSION;
1464 		char *tname;
1465 
1466 		(void) nvlist_lookup_uint64(props,
1467 		    zpool_prop_to_name(ZPOOL_PROP_VERSION), &version);
1468 		if (!SPA_VERSION_IS_SUPPORTED(version)) {
1469 			error = SET_ERROR(EINVAL);
1470 			goto pool_props_bad;
1471 		}
1472 		(void) nvlist_lookup_nvlist(props, ZPOOL_ROOTFS_PROPS, &nvl);
1473 		if (nvl) {
1474 			error = nvlist_dup(nvl, &rootprops, KM_SLEEP);
1475 			if (error != 0)
1476 				goto pool_props_bad;
1477 			(void) nvlist_remove_all(props, ZPOOL_ROOTFS_PROPS);
1478 		}
1479 
1480 		(void) nvlist_lookup_nvlist(props, ZPOOL_HIDDEN_ARGS,
1481 		    &hidden_args);
1482 		error = dsl_crypto_params_create_nvlist(DCP_CMD_NONE,
1483 		    rootprops, hidden_args, &dcp);
1484 		if (error != 0)
1485 			goto pool_props_bad;
1486 		(void) nvlist_remove_all(props, ZPOOL_HIDDEN_ARGS);
1487 
1488 		VERIFY(nvlist_alloc(&zplprops, NV_UNIQUE_NAME, KM_SLEEP) == 0);
1489 		error = zfs_fill_zplprops_root(version, rootprops,
1490 		    zplprops, NULL);
1491 		if (error != 0)
1492 			goto pool_props_bad;
1493 
1494 		if (nvlist_lookup_string(props,
1495 		    zpool_prop_to_name(ZPOOL_PROP_TNAME), &tname) == 0)
1496 			spa_name = tname;
1497 	}
1498 
1499 	error = spa_create(zc->zc_name, config, props, zplprops, dcp);
1500 
1501 	/*
1502 	 * Set the remaining root properties
1503 	 */
1504 	if (!error && (error = zfs_set_prop_nvlist(spa_name,
1505 	    ZPROP_SRC_LOCAL, rootprops, NULL)) != 0) {
1506 		(void) spa_destroy(spa_name);
1507 		unload_wkey = B_FALSE; /* spa_destroy() unloads wrapping keys */
1508 	}
1509 
1510 pool_props_bad:
1511 	nvlist_free(rootprops);
1512 	nvlist_free(zplprops);
1513 	nvlist_free(config);
1514 	nvlist_free(props);
1515 	dsl_crypto_params_free(dcp, unload_wkey && !!error);
1516 
1517 	return (error);
1518 }
1519 
1520 static int
1521 zfs_ioc_pool_destroy(zfs_cmd_t *zc)
1522 {
1523 	int error;
1524 	zfs_log_history(zc);
1525 	error = spa_destroy(zc->zc_name);
1526 
1527 	return (error);
1528 }
1529 
1530 static int
1531 zfs_ioc_pool_import(zfs_cmd_t *zc)
1532 {
1533 	nvlist_t *config, *props = NULL;
1534 	uint64_t guid;
1535 	int error;
1536 
1537 	if ((error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size,
1538 	    zc->zc_iflags, &config)) != 0)
1539 		return (error);
1540 
1541 	if (zc->zc_nvlist_src_size != 0 && (error =
1542 	    get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
1543 	    zc->zc_iflags, &props))) {
1544 		nvlist_free(config);
1545 		return (error);
1546 	}
1547 
1548 	if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, &guid) != 0 ||
1549 	    guid != zc->zc_guid)
1550 		error = SET_ERROR(EINVAL);
1551 	else
1552 		error = spa_import(zc->zc_name, config, props, zc->zc_cookie);
1553 
1554 	if (zc->zc_nvlist_dst != 0) {
1555 		int err;
1556 
1557 		if ((err = put_nvlist(zc, config)) != 0)
1558 			error = err;
1559 	}
1560 
1561 	nvlist_free(config);
1562 	nvlist_free(props);
1563 
1564 	return (error);
1565 }
1566 
1567 static int
1568 zfs_ioc_pool_export(zfs_cmd_t *zc)
1569 {
1570 	int error;
1571 	boolean_t force = (boolean_t)zc->zc_cookie;
1572 	boolean_t hardforce = (boolean_t)zc->zc_guid;
1573 
1574 	zfs_log_history(zc);
1575 	error = spa_export(zc->zc_name, NULL, force, hardforce);
1576 
1577 	return (error);
1578 }
1579 
1580 static int
1581 zfs_ioc_pool_configs(zfs_cmd_t *zc)
1582 {
1583 	nvlist_t *configs;
1584 	int error;
1585 
1586 	if ((configs = spa_all_configs(&zc->zc_cookie)) == NULL)
1587 		return (SET_ERROR(EEXIST));
1588 
1589 	error = put_nvlist(zc, configs);
1590 
1591 	nvlist_free(configs);
1592 
1593 	return (error);
1594 }
1595 
1596 /*
1597  * inputs:
1598  * zc_name		name of the pool
1599  *
1600  * outputs:
1601  * zc_cookie		real errno
1602  * zc_nvlist_dst	config nvlist
1603  * zc_nvlist_dst_size	size of config nvlist
1604  */
1605 static int
1606 zfs_ioc_pool_stats(zfs_cmd_t *zc)
1607 {
1608 	nvlist_t *config;
1609 	int error;
1610 	int ret = 0;
1611 
1612 	error = spa_get_stats(zc->zc_name, &config, zc->zc_value,
1613 	    sizeof (zc->zc_value));
1614 
1615 	if (config != NULL) {
1616 		ret = put_nvlist(zc, config);
1617 		nvlist_free(config);
1618 
1619 		/*
1620 		 * The config may be present even if 'error' is non-zero.
1621 		 * In this case we return success, and preserve the real errno
1622 		 * in 'zc_cookie'.
1623 		 */
1624 		zc->zc_cookie = error;
1625 	} else {
1626 		ret = error;
1627 	}
1628 
1629 	return (ret);
1630 }
1631 
1632 /*
1633  * Try to import the given pool, returning pool stats as appropriate so that
1634  * user land knows which devices are available and overall pool health.
1635  */
1636 static int
1637 zfs_ioc_pool_tryimport(zfs_cmd_t *zc)
1638 {
1639 	nvlist_t *tryconfig, *config = NULL;
1640 	int error;
1641 
1642 	if ((error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size,
1643 	    zc->zc_iflags, &tryconfig)) != 0)
1644 		return (error);
1645 
1646 	config = spa_tryimport(tryconfig);
1647 
1648 	nvlist_free(tryconfig);
1649 
1650 	if (config == NULL)
1651 		return (SET_ERROR(EINVAL));
1652 
1653 	error = put_nvlist(zc, config);
1654 	nvlist_free(config);
1655 
1656 	return (error);
1657 }
1658 
1659 /*
1660  * inputs:
1661  * zc_name              name of the pool
1662  * zc_cookie            scan func (pool_scan_func_t)
1663  * zc_flags             scrub pause/resume flag (pool_scrub_cmd_t)
1664  */
1665 static int
1666 zfs_ioc_pool_scan(zfs_cmd_t *zc)
1667 {
1668 	spa_t *spa;
1669 	int error;
1670 
1671 	if (zc->zc_flags >= POOL_SCRUB_FLAGS_END)
1672 		return (SET_ERROR(EINVAL));
1673 
1674 	if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
1675 		return (error);
1676 
1677 	if (zc->zc_flags == POOL_SCRUB_PAUSE)
1678 		error = spa_scrub_pause_resume(spa, POOL_SCRUB_PAUSE);
1679 	else if (zc->zc_cookie == POOL_SCAN_NONE)
1680 		error = spa_scan_stop(spa);
1681 	else
1682 		error = spa_scan(spa, zc->zc_cookie);
1683 
1684 	spa_close(spa, FTAG);
1685 
1686 	return (error);
1687 }
1688 
1689 static int
1690 zfs_ioc_pool_freeze(zfs_cmd_t *zc)
1691 {
1692 	spa_t *spa;
1693 	int error;
1694 
1695 	error = spa_open(zc->zc_name, &spa, FTAG);
1696 	if (error == 0) {
1697 		spa_freeze(spa);
1698 		spa_close(spa, FTAG);
1699 	}
1700 	return (error);
1701 }
1702 
1703 static int
1704 zfs_ioc_pool_upgrade(zfs_cmd_t *zc)
1705 {
1706 	spa_t *spa;
1707 	int error;
1708 
1709 	if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
1710 		return (error);
1711 
1712 	if (zc->zc_cookie < spa_version(spa) ||
1713 	    !SPA_VERSION_IS_SUPPORTED(zc->zc_cookie)) {
1714 		spa_close(spa, FTAG);
1715 		return (SET_ERROR(EINVAL));
1716 	}
1717 
1718 	spa_upgrade(spa, zc->zc_cookie);
1719 	spa_close(spa, FTAG);
1720 
1721 	return (error);
1722 }
1723 
1724 static int
1725 zfs_ioc_pool_get_history(zfs_cmd_t *zc)
1726 {
1727 	spa_t *spa;
1728 	char *hist_buf;
1729 	uint64_t size;
1730 	int error;
1731 
1732 	if ((size = zc->zc_history_len) == 0)
1733 		return (SET_ERROR(EINVAL));
1734 
1735 	if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
1736 		return (error);
1737 
1738 	if (spa_version(spa) < SPA_VERSION_ZPOOL_HISTORY) {
1739 		spa_close(spa, FTAG);
1740 		return (SET_ERROR(ENOTSUP));
1741 	}
1742 
1743 	hist_buf = vmem_alloc(size, KM_SLEEP);
1744 	if ((error = spa_history_get(spa, &zc->zc_history_offset,
1745 	    &zc->zc_history_len, hist_buf)) == 0) {
1746 		error = ddi_copyout(hist_buf,
1747 		    (void *)(uintptr_t)zc->zc_history,
1748 		    zc->zc_history_len, zc->zc_iflags);
1749 	}
1750 
1751 	spa_close(spa, FTAG);
1752 	vmem_free(hist_buf, size);
1753 	return (error);
1754 }
1755 
1756 static int
1757 zfs_ioc_pool_reguid(zfs_cmd_t *zc)
1758 {
1759 	spa_t *spa;
1760 	int error;
1761 
1762 	error = spa_open(zc->zc_name, &spa, FTAG);
1763 	if (error == 0) {
1764 		error = spa_change_guid(spa);
1765 		spa_close(spa, FTAG);
1766 	}
1767 	return (error);
1768 }
1769 
1770 static int
1771 zfs_ioc_dsobj_to_dsname(zfs_cmd_t *zc)
1772 {
1773 	return (dsl_dsobj_to_dsname(zc->zc_name, zc->zc_obj, zc->zc_value));
1774 }
1775 
1776 /*
1777  * inputs:
1778  * zc_name		name of filesystem
1779  * zc_obj		object to find
1780  *
1781  * outputs:
1782  * zc_value		name of object
1783  */
1784 static int
1785 zfs_ioc_obj_to_path(zfs_cmd_t *zc)
1786 {
1787 	objset_t *os;
1788 	int error;
1789 
1790 	/* XXX reading from objset not owned */
1791 	if ((error = dmu_objset_hold_flags(zc->zc_name, B_TRUE,
1792 	    FTAG, &os)) != 0)
1793 		return (error);
1794 	if (dmu_objset_type(os) != DMU_OST_ZFS) {
1795 		dmu_objset_rele_flags(os, B_TRUE, FTAG);
1796 		return (SET_ERROR(EINVAL));
1797 	}
1798 	error = zfs_obj_to_path(os, zc->zc_obj, zc->zc_value,
1799 	    sizeof (zc->zc_value));
1800 	dmu_objset_rele_flags(os, B_TRUE, FTAG);
1801 
1802 	return (error);
1803 }
1804 
1805 /*
1806  * inputs:
1807  * zc_name		name of filesystem
1808  * zc_obj		object to find
1809  *
1810  * outputs:
1811  * zc_stat		stats on object
1812  * zc_value		path to object
1813  */
1814 static int
1815 zfs_ioc_obj_to_stats(zfs_cmd_t *zc)
1816 {
1817 	objset_t *os;
1818 	int error;
1819 
1820 	/* XXX reading from objset not owned */
1821 	if ((error = dmu_objset_hold_flags(zc->zc_name, B_TRUE,
1822 	    FTAG, &os)) != 0)
1823 		return (error);
1824 	if (dmu_objset_type(os) != DMU_OST_ZFS) {
1825 		dmu_objset_rele_flags(os, B_TRUE, FTAG);
1826 		return (SET_ERROR(EINVAL));
1827 	}
1828 	error = zfs_obj_to_stats(os, zc->zc_obj, &zc->zc_stat, zc->zc_value,
1829 	    sizeof (zc->zc_value));
1830 	dmu_objset_rele_flags(os, B_TRUE, FTAG);
1831 
1832 	return (error);
1833 }
1834 
1835 static int
1836 zfs_ioc_vdev_add(zfs_cmd_t *zc)
1837 {
1838 	spa_t *spa;
1839 	int error;
1840 	nvlist_t *config;
1841 
1842 	error = spa_open(zc->zc_name, &spa, FTAG);
1843 	if (error != 0)
1844 		return (error);
1845 
1846 	error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size,
1847 	    zc->zc_iflags, &config);
1848 	if (error == 0) {
1849 		error = spa_vdev_add(spa, config);
1850 		nvlist_free(config);
1851 	}
1852 	spa_close(spa, FTAG);
1853 	return (error);
1854 }
1855 
1856 /*
1857  * inputs:
1858  * zc_name		name of the pool
1859  * zc_guid		guid of vdev to remove
1860  * zc_cookie		cancel removal
1861  */
1862 static int
1863 zfs_ioc_vdev_remove(zfs_cmd_t *zc)
1864 {
1865 	spa_t *spa;
1866 	int error;
1867 
1868 	error = spa_open(zc->zc_name, &spa, FTAG);
1869 	if (error != 0)
1870 		return (error);
1871 	if (zc->zc_cookie != 0) {
1872 		error = spa_vdev_remove_cancel(spa);
1873 	} else {
1874 		error = spa_vdev_remove(spa, zc->zc_guid, B_FALSE);
1875 	}
1876 	spa_close(spa, FTAG);
1877 	return (error);
1878 }
1879 
1880 static int
1881 zfs_ioc_vdev_set_state(zfs_cmd_t *zc)
1882 {
1883 	spa_t *spa;
1884 	int error;
1885 	vdev_state_t newstate = VDEV_STATE_UNKNOWN;
1886 
1887 	if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
1888 		return (error);
1889 	switch (zc->zc_cookie) {
1890 	case VDEV_STATE_ONLINE:
1891 		error = vdev_online(spa, zc->zc_guid, zc->zc_obj, &newstate);
1892 		break;
1893 
1894 	case VDEV_STATE_OFFLINE:
1895 		error = vdev_offline(spa, zc->zc_guid, zc->zc_obj);
1896 		break;
1897 
1898 	case VDEV_STATE_FAULTED:
1899 		if (zc->zc_obj != VDEV_AUX_ERR_EXCEEDED &&
1900 		    zc->zc_obj != VDEV_AUX_EXTERNAL &&
1901 		    zc->zc_obj != VDEV_AUX_EXTERNAL_PERSIST)
1902 			zc->zc_obj = VDEV_AUX_ERR_EXCEEDED;
1903 
1904 		error = vdev_fault(spa, zc->zc_guid, zc->zc_obj);
1905 		break;
1906 
1907 	case VDEV_STATE_DEGRADED:
1908 		if (zc->zc_obj != VDEV_AUX_ERR_EXCEEDED &&
1909 		    zc->zc_obj != VDEV_AUX_EXTERNAL)
1910 			zc->zc_obj = VDEV_AUX_ERR_EXCEEDED;
1911 
1912 		error = vdev_degrade(spa, zc->zc_guid, zc->zc_obj);
1913 		break;
1914 
1915 	default:
1916 		error = SET_ERROR(EINVAL);
1917 	}
1918 	zc->zc_cookie = newstate;
1919 	spa_close(spa, FTAG);
1920 	return (error);
1921 }
1922 
1923 static int
1924 zfs_ioc_vdev_attach(zfs_cmd_t *zc)
1925 {
1926 	spa_t *spa;
1927 	nvlist_t *config;
1928 	int replacing = zc->zc_cookie;
1929 	int rebuild = zc->zc_simple;
1930 	int error;
1931 
1932 	if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
1933 		return (error);
1934 
1935 	if ((error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size,
1936 	    zc->zc_iflags, &config)) == 0) {
1937 		error = spa_vdev_attach(spa, zc->zc_guid, config, replacing,
1938 		    rebuild);
1939 		nvlist_free(config);
1940 	}
1941 
1942 	spa_close(spa, FTAG);
1943 	return (error);
1944 }
1945 
1946 static int
1947 zfs_ioc_vdev_detach(zfs_cmd_t *zc)
1948 {
1949 	spa_t *spa;
1950 	int error;
1951 
1952 	if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
1953 		return (error);
1954 
1955 	error = spa_vdev_detach(spa, zc->zc_guid, 0, B_FALSE);
1956 
1957 	spa_close(spa, FTAG);
1958 	return (error);
1959 }
1960 
1961 static int
1962 zfs_ioc_vdev_split(zfs_cmd_t *zc)
1963 {
1964 	spa_t *spa;
1965 	nvlist_t *config, *props = NULL;
1966 	int error;
1967 	boolean_t exp = !!(zc->zc_cookie & ZPOOL_EXPORT_AFTER_SPLIT);
1968 
1969 	if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
1970 		return (error);
1971 
1972 	if ((error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size,
1973 	    zc->zc_iflags, &config))) {
1974 		spa_close(spa, FTAG);
1975 		return (error);
1976 	}
1977 
1978 	if (zc->zc_nvlist_src_size != 0 && (error =
1979 	    get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
1980 	    zc->zc_iflags, &props))) {
1981 		spa_close(spa, FTAG);
1982 		nvlist_free(config);
1983 		return (error);
1984 	}
1985 
1986 	error = spa_vdev_split_mirror(spa, zc->zc_string, config, props, exp);
1987 
1988 	spa_close(spa, FTAG);
1989 
1990 	nvlist_free(config);
1991 	nvlist_free(props);
1992 
1993 	return (error);
1994 }
1995 
1996 static int
1997 zfs_ioc_vdev_setpath(zfs_cmd_t *zc)
1998 {
1999 	spa_t *spa;
2000 	const char *path = zc->zc_value;
2001 	uint64_t guid = zc->zc_guid;
2002 	int error;
2003 
2004 	error = spa_open(zc->zc_name, &spa, FTAG);
2005 	if (error != 0)
2006 		return (error);
2007 
2008 	error = spa_vdev_setpath(spa, guid, path);
2009 	spa_close(spa, FTAG);
2010 	return (error);
2011 }
2012 
2013 static int
2014 zfs_ioc_vdev_setfru(zfs_cmd_t *zc)
2015 {
2016 	spa_t *spa;
2017 	const char *fru = zc->zc_value;
2018 	uint64_t guid = zc->zc_guid;
2019 	int error;
2020 
2021 	error = spa_open(zc->zc_name, &spa, FTAG);
2022 	if (error != 0)
2023 		return (error);
2024 
2025 	error = spa_vdev_setfru(spa, guid, fru);
2026 	spa_close(spa, FTAG);
2027 	return (error);
2028 }
2029 
2030 static int
2031 zfs_ioc_objset_stats_impl(zfs_cmd_t *zc, objset_t *os)
2032 {
2033 	int error = 0;
2034 	nvlist_t *nv;
2035 
2036 	dmu_objset_fast_stat(os, &zc->zc_objset_stats);
2037 
2038 	if (zc->zc_nvlist_dst != 0 &&
2039 	    (error = dsl_prop_get_all(os, &nv)) == 0) {
2040 		dmu_objset_stats(os, nv);
2041 		/*
2042 		 * NB: zvol_get_stats() will read the objset contents,
2043 		 * which we aren't supposed to do with a
2044 		 * DS_MODE_USER hold, because it could be
2045 		 * inconsistent.  So this is a bit of a workaround...
2046 		 * XXX reading without owning
2047 		 */
2048 		if (!zc->zc_objset_stats.dds_inconsistent &&
2049 		    dmu_objset_type(os) == DMU_OST_ZVOL) {
2050 			error = zvol_get_stats(os, nv);
2051 			if (error == EIO) {
2052 				nvlist_free(nv);
2053 				return (error);
2054 			}
2055 			VERIFY0(error);
2056 		}
2057 		if (error == 0)
2058 			error = put_nvlist(zc, nv);
2059 		nvlist_free(nv);
2060 	}
2061 
2062 	return (error);
2063 }
2064 
2065 /*
2066  * inputs:
2067  * zc_name		name of filesystem
2068  * zc_nvlist_dst_size	size of buffer for property nvlist
2069  *
2070  * outputs:
2071  * zc_objset_stats	stats
2072  * zc_nvlist_dst	property nvlist
2073  * zc_nvlist_dst_size	size of property nvlist
2074  */
2075 static int
2076 zfs_ioc_objset_stats(zfs_cmd_t *zc)
2077 {
2078 	objset_t *os;
2079 	int error;
2080 
2081 	error = dmu_objset_hold(zc->zc_name, FTAG, &os);
2082 	if (error == 0) {
2083 		error = zfs_ioc_objset_stats_impl(zc, os);
2084 		dmu_objset_rele(os, FTAG);
2085 	}
2086 
2087 	return (error);
2088 }
2089 
2090 /*
2091  * inputs:
2092  * zc_name		name of filesystem
2093  * zc_nvlist_dst_size	size of buffer for property nvlist
2094  *
2095  * outputs:
2096  * zc_nvlist_dst	received property nvlist
2097  * zc_nvlist_dst_size	size of received property nvlist
2098  *
2099  * Gets received properties (distinct from local properties on or after
2100  * SPA_VERSION_RECVD_PROPS) for callers who want to differentiate received from
2101  * local property values.
2102  */
2103 static int
2104 zfs_ioc_objset_recvd_props(zfs_cmd_t *zc)
2105 {
2106 	int error = 0;
2107 	nvlist_t *nv;
2108 
2109 	/*
2110 	 * Without this check, we would return local property values if the
2111 	 * caller has not already received properties on or after
2112 	 * SPA_VERSION_RECVD_PROPS.
2113 	 */
2114 	if (!dsl_prop_get_hasrecvd(zc->zc_name))
2115 		return (SET_ERROR(ENOTSUP));
2116 
2117 	if (zc->zc_nvlist_dst != 0 &&
2118 	    (error = dsl_prop_get_received(zc->zc_name, &nv)) == 0) {
2119 		error = put_nvlist(zc, nv);
2120 		nvlist_free(nv);
2121 	}
2122 
2123 	return (error);
2124 }
2125 
2126 static int
2127 nvl_add_zplprop(objset_t *os, nvlist_t *props, zfs_prop_t prop)
2128 {
2129 	uint64_t value;
2130 	int error;
2131 
2132 	/*
2133 	 * zfs_get_zplprop() will either find a value or give us
2134 	 * the default value (if there is one).
2135 	 */
2136 	if ((error = zfs_get_zplprop(os, prop, &value)) != 0)
2137 		return (error);
2138 	VERIFY(nvlist_add_uint64(props, zfs_prop_to_name(prop), value) == 0);
2139 	return (0);
2140 }
2141 
2142 /*
2143  * inputs:
2144  * zc_name		name of filesystem
2145  * zc_nvlist_dst_size	size of buffer for zpl property nvlist
2146  *
2147  * outputs:
2148  * zc_nvlist_dst	zpl property nvlist
2149  * zc_nvlist_dst_size	size of zpl property nvlist
2150  */
2151 static int
2152 zfs_ioc_objset_zplprops(zfs_cmd_t *zc)
2153 {
2154 	objset_t *os;
2155 	int err;
2156 
2157 	/* XXX reading without owning */
2158 	if ((err = dmu_objset_hold(zc->zc_name, FTAG, &os)))
2159 		return (err);
2160 
2161 	dmu_objset_fast_stat(os, &zc->zc_objset_stats);
2162 
2163 	/*
2164 	 * NB: nvl_add_zplprop() will read the objset contents,
2165 	 * which we aren't supposed to do with a DS_MODE_USER
2166 	 * hold, because it could be inconsistent.
2167 	 */
2168 	if (zc->zc_nvlist_dst != 0 &&
2169 	    !zc->zc_objset_stats.dds_inconsistent &&
2170 	    dmu_objset_type(os) == DMU_OST_ZFS) {
2171 		nvlist_t *nv;
2172 
2173 		VERIFY(nvlist_alloc(&nv, NV_UNIQUE_NAME, KM_SLEEP) == 0);
2174 		if ((err = nvl_add_zplprop(os, nv, ZFS_PROP_VERSION)) == 0 &&
2175 		    (err = nvl_add_zplprop(os, nv, ZFS_PROP_NORMALIZE)) == 0 &&
2176 		    (err = nvl_add_zplprop(os, nv, ZFS_PROP_UTF8ONLY)) == 0 &&
2177 		    (err = nvl_add_zplprop(os, nv, ZFS_PROP_CASE)) == 0)
2178 			err = put_nvlist(zc, nv);
2179 		nvlist_free(nv);
2180 	} else {
2181 		err = SET_ERROR(ENOENT);
2182 	}
2183 	dmu_objset_rele(os, FTAG);
2184 	return (err);
2185 }
2186 
2187 /*
2188  * inputs:
2189  * zc_name		name of filesystem
2190  * zc_cookie		zap cursor
2191  * zc_nvlist_dst_size	size of buffer for property nvlist
2192  *
2193  * outputs:
2194  * zc_name		name of next filesystem
2195  * zc_cookie		zap cursor
2196  * zc_objset_stats	stats
2197  * zc_nvlist_dst	property nvlist
2198  * zc_nvlist_dst_size	size of property nvlist
2199  */
2200 static int
2201 zfs_ioc_dataset_list_next(zfs_cmd_t *zc)
2202 {
2203 	objset_t *os;
2204 	int error;
2205 	char *p;
2206 	size_t orig_len = strlen(zc->zc_name);
2207 
2208 top:
2209 	if ((error = dmu_objset_hold(zc->zc_name, FTAG, &os))) {
2210 		if (error == ENOENT)
2211 			error = SET_ERROR(ESRCH);
2212 		return (error);
2213 	}
2214 
2215 	p = strrchr(zc->zc_name, '/');
2216 	if (p == NULL || p[1] != '\0')
2217 		(void) strlcat(zc->zc_name, "/", sizeof (zc->zc_name));
2218 	p = zc->zc_name + strlen(zc->zc_name);
2219 
2220 	do {
2221 		error = dmu_dir_list_next(os,
2222 		    sizeof (zc->zc_name) - (p - zc->zc_name), p,
2223 		    NULL, &zc->zc_cookie);
2224 		if (error == ENOENT)
2225 			error = SET_ERROR(ESRCH);
2226 	} while (error == 0 && zfs_dataset_name_hidden(zc->zc_name));
2227 	dmu_objset_rele(os, FTAG);
2228 
2229 	/*
2230 	 * If it's an internal dataset (ie. with a '$' in its name),
2231 	 * don't try to get stats for it, otherwise we'll return ENOENT.
2232 	 */
2233 	if (error == 0 && strchr(zc->zc_name, '$') == NULL) {
2234 		error = zfs_ioc_objset_stats(zc); /* fill in the stats */
2235 		if (error == ENOENT) {
2236 			/* We lost a race with destroy, get the next one. */
2237 			zc->zc_name[orig_len] = '\0';
2238 			goto top;
2239 		}
2240 	}
2241 	return (error);
2242 }
2243 
2244 /*
2245  * inputs:
2246  * zc_name		name of filesystem
2247  * zc_cookie		zap cursor
2248  * zc_nvlist_src	iteration range nvlist
2249  * zc_nvlist_src_size	size of iteration range nvlist
2250  *
2251  * outputs:
2252  * zc_name		name of next snapshot
2253  * zc_objset_stats	stats
2254  * zc_nvlist_dst	property nvlist
2255  * zc_nvlist_dst_size	size of property nvlist
2256  */
2257 static int
2258 zfs_ioc_snapshot_list_next(zfs_cmd_t *zc)
2259 {
2260 	int error;
2261 	objset_t *os, *ossnap;
2262 	dsl_dataset_t *ds;
2263 	uint64_t min_txg = 0, max_txg = 0;
2264 
2265 	if (zc->zc_nvlist_src_size != 0) {
2266 		nvlist_t *props = NULL;
2267 		error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
2268 		    zc->zc_iflags, &props);
2269 		if (error != 0)
2270 			return (error);
2271 		(void) nvlist_lookup_uint64(props, SNAP_ITER_MIN_TXG,
2272 		    &min_txg);
2273 		(void) nvlist_lookup_uint64(props, SNAP_ITER_MAX_TXG,
2274 		    &max_txg);
2275 		nvlist_free(props);
2276 	}
2277 
2278 	error = dmu_objset_hold(zc->zc_name, FTAG, &os);
2279 	if (error != 0) {
2280 		return (error == ENOENT ? SET_ERROR(ESRCH) : error);
2281 	}
2282 
2283 	/*
2284 	 * A dataset name of maximum length cannot have any snapshots,
2285 	 * so exit immediately.
2286 	 */
2287 	if (strlcat(zc->zc_name, "@", sizeof (zc->zc_name)) >=
2288 	    ZFS_MAX_DATASET_NAME_LEN) {
2289 		dmu_objset_rele(os, FTAG);
2290 		return (SET_ERROR(ESRCH));
2291 	}
2292 
2293 	while (error == 0) {
2294 		if (issig(JUSTLOOKING) && issig(FORREAL)) {
2295 			error = SET_ERROR(EINTR);
2296 			break;
2297 		}
2298 
2299 		error = dmu_snapshot_list_next(os,
2300 		    sizeof (zc->zc_name) - strlen(zc->zc_name),
2301 		    zc->zc_name + strlen(zc->zc_name), &zc->zc_obj,
2302 		    &zc->zc_cookie, NULL);
2303 		if (error == ENOENT) {
2304 			error = SET_ERROR(ESRCH);
2305 			break;
2306 		} else if (error != 0) {
2307 			break;
2308 		}
2309 
2310 		error = dsl_dataset_hold_obj(dmu_objset_pool(os), zc->zc_obj,
2311 		    FTAG, &ds);
2312 		if (error != 0)
2313 			break;
2314 
2315 		if ((min_txg != 0 && dsl_get_creationtxg(ds) < min_txg) ||
2316 		    (max_txg != 0 && dsl_get_creationtxg(ds) > max_txg)) {
2317 			dsl_dataset_rele(ds, FTAG);
2318 			/* undo snapshot name append */
2319 			*(strchr(zc->zc_name, '@') + 1) = '\0';
2320 			/* skip snapshot */
2321 			continue;
2322 		}
2323 
2324 		if (zc->zc_simple) {
2325 			zc->zc_objset_stats.dds_creation_txg =
2326 			    dsl_get_creationtxg(ds);
2327 			dsl_dataset_rele(ds, FTAG);
2328 			break;
2329 		}
2330 
2331 		if ((error = dmu_objset_from_ds(ds, &ossnap)) != 0) {
2332 			dsl_dataset_rele(ds, FTAG);
2333 			break;
2334 		}
2335 		if ((error = zfs_ioc_objset_stats_impl(zc, ossnap)) != 0) {
2336 			dsl_dataset_rele(ds, FTAG);
2337 			break;
2338 		}
2339 		dsl_dataset_rele(ds, FTAG);
2340 		break;
2341 	}
2342 
2343 	dmu_objset_rele(os, FTAG);
2344 	/* if we failed, undo the @ that we tacked on to zc_name */
2345 	if (error != 0)
2346 		*strchr(zc->zc_name, '@') = '\0';
2347 	return (error);
2348 }
2349 
2350 static int
2351 zfs_prop_set_userquota(const char *dsname, nvpair_t *pair)
2352 {
2353 	const char *propname = nvpair_name(pair);
2354 	uint64_t *valary;
2355 	unsigned int vallen;
2356 	const char *dash, *domain;
2357 	zfs_userquota_prop_t type;
2358 	uint64_t rid;
2359 	uint64_t quota;
2360 	zfsvfs_t *zfsvfs;
2361 	int err;
2362 
2363 	if (nvpair_type(pair) == DATA_TYPE_NVLIST) {
2364 		nvlist_t *attrs;
2365 		VERIFY(nvpair_value_nvlist(pair, &attrs) == 0);
2366 		if (nvlist_lookup_nvpair(attrs, ZPROP_VALUE,
2367 		    &pair) != 0)
2368 			return (SET_ERROR(EINVAL));
2369 	}
2370 
2371 	/*
2372 	 * A correctly constructed propname is encoded as
2373 	 * userquota@<rid>-<domain>.
2374 	 */
2375 	if ((dash = strchr(propname, '-')) == NULL ||
2376 	    nvpair_value_uint64_array(pair, &valary, &vallen) != 0 ||
2377 	    vallen != 3)
2378 		return (SET_ERROR(EINVAL));
2379 
2380 	domain = dash + 1;
2381 	type = valary[0];
2382 	rid = valary[1];
2383 	quota = valary[2];
2384 
2385 	err = zfsvfs_hold(dsname, FTAG, &zfsvfs, B_FALSE);
2386 	if (err == 0) {
2387 		err = zfs_set_userquota(zfsvfs, type, domain, rid, quota);
2388 		zfsvfs_rele(zfsvfs, FTAG);
2389 	}
2390 
2391 	return (err);
2392 }
2393 
2394 /*
2395  * If the named property is one that has a special function to set its value,
2396  * return 0 on success and a positive error code on failure; otherwise if it is
2397  * not one of the special properties handled by this function, return -1.
2398  *
2399  * XXX: It would be better for callers of the property interface if we handled
2400  * these special cases in dsl_prop.c (in the dsl layer).
2401  */
2402 static int
2403 zfs_prop_set_special(const char *dsname, zprop_source_t source,
2404     nvpair_t *pair)
2405 {
2406 	const char *propname = nvpair_name(pair);
2407 	zfs_prop_t prop = zfs_name_to_prop(propname);
2408 	uint64_t intval = 0;
2409 	const char *strval = NULL;
2410 	int err = -1;
2411 
2412 	if (prop == ZPROP_USERPROP) {
2413 		if (zfs_prop_userquota(propname))
2414 			return (zfs_prop_set_userquota(dsname, pair));
2415 		return (-1);
2416 	}
2417 
2418 	if (nvpair_type(pair) == DATA_TYPE_NVLIST) {
2419 		nvlist_t *attrs;
2420 		VERIFY(nvpair_value_nvlist(pair, &attrs) == 0);
2421 		VERIFY(nvlist_lookup_nvpair(attrs, ZPROP_VALUE,
2422 		    &pair) == 0);
2423 	}
2424 
2425 	/* all special properties are numeric except for keylocation */
2426 	if (zfs_prop_get_type(prop) == PROP_TYPE_STRING) {
2427 		strval = fnvpair_value_string(pair);
2428 	} else {
2429 		intval = fnvpair_value_uint64(pair);
2430 	}
2431 
2432 	switch (prop) {
2433 	case ZFS_PROP_QUOTA:
2434 		err = dsl_dir_set_quota(dsname, source, intval);
2435 		break;
2436 	case ZFS_PROP_REFQUOTA:
2437 		err = dsl_dataset_set_refquota(dsname, source, intval);
2438 		break;
2439 	case ZFS_PROP_FILESYSTEM_LIMIT:
2440 	case ZFS_PROP_SNAPSHOT_LIMIT:
2441 		if (intval == UINT64_MAX) {
2442 			/* clearing the limit, just do it */
2443 			err = 0;
2444 		} else {
2445 			err = dsl_dir_activate_fs_ss_limit(dsname);
2446 		}
2447 		/*
2448 		 * Set err to -1 to force the zfs_set_prop_nvlist code down the
2449 		 * default path to set the value in the nvlist.
2450 		 */
2451 		if (err == 0)
2452 			err = -1;
2453 		break;
2454 	case ZFS_PROP_KEYLOCATION:
2455 		err = dsl_crypto_can_set_keylocation(dsname, strval);
2456 
2457 		/*
2458 		 * Set err to -1 to force the zfs_set_prop_nvlist code down the
2459 		 * default path to set the value in the nvlist.
2460 		 */
2461 		if (err == 0)
2462 			err = -1;
2463 		break;
2464 	case ZFS_PROP_RESERVATION:
2465 		err = dsl_dir_set_reservation(dsname, source, intval);
2466 		break;
2467 	case ZFS_PROP_REFRESERVATION:
2468 		err = dsl_dataset_set_refreservation(dsname, source, intval);
2469 		break;
2470 	case ZFS_PROP_COMPRESSION:
2471 		err = dsl_dataset_set_compression(dsname, source, intval);
2472 		/*
2473 		 * Set err to -1 to force the zfs_set_prop_nvlist code down the
2474 		 * default path to set the value in the nvlist.
2475 		 */
2476 		if (err == 0)
2477 			err = -1;
2478 		break;
2479 	case ZFS_PROP_VOLSIZE:
2480 		err = zvol_set_volsize(dsname, intval);
2481 		break;
2482 	case ZFS_PROP_SNAPDEV:
2483 		err = zvol_set_snapdev(dsname, source, intval);
2484 		break;
2485 	case ZFS_PROP_VOLMODE:
2486 		err = zvol_set_volmode(dsname, source, intval);
2487 		break;
2488 	case ZFS_PROP_VERSION:
2489 	{
2490 		zfsvfs_t *zfsvfs;
2491 
2492 		if ((err = zfsvfs_hold(dsname, FTAG, &zfsvfs, B_TRUE)) != 0)
2493 			break;
2494 
2495 		err = zfs_set_version(zfsvfs, intval);
2496 		zfsvfs_rele(zfsvfs, FTAG);
2497 
2498 		if (err == 0 && intval >= ZPL_VERSION_USERSPACE) {
2499 			zfs_cmd_t *zc;
2500 
2501 			zc = kmem_zalloc(sizeof (zfs_cmd_t), KM_SLEEP);
2502 			(void) strlcpy(zc->zc_name, dsname,
2503 			    sizeof (zc->zc_name));
2504 			(void) zfs_ioc_userspace_upgrade(zc);
2505 			(void) zfs_ioc_id_quota_upgrade(zc);
2506 			kmem_free(zc, sizeof (zfs_cmd_t));
2507 		}
2508 		break;
2509 	}
2510 	default:
2511 		err = -1;
2512 	}
2513 
2514 	return (err);
2515 }
2516 
2517 static boolean_t
2518 zfs_is_namespace_prop(zfs_prop_t prop)
2519 {
2520 	switch (prop) {
2521 
2522 	case ZFS_PROP_ATIME:
2523 	case ZFS_PROP_RELATIME:
2524 	case ZFS_PROP_DEVICES:
2525 	case ZFS_PROP_EXEC:
2526 	case ZFS_PROP_SETUID:
2527 	case ZFS_PROP_READONLY:
2528 	case ZFS_PROP_XATTR:
2529 	case ZFS_PROP_NBMAND:
2530 		return (B_TRUE);
2531 
2532 	default:
2533 		return (B_FALSE);
2534 	}
2535 }
2536 
2537 /*
2538  * This function is best effort. If it fails to set any of the given properties,
2539  * it continues to set as many as it can and returns the last error
2540  * encountered. If the caller provides a non-NULL errlist, it will be filled in
2541  * with the list of names of all the properties that failed along with the
2542  * corresponding error numbers.
2543  *
2544  * If every property is set successfully, zero is returned and errlist is not
2545  * modified.
2546  */
2547 int
2548 zfs_set_prop_nvlist(const char *dsname, zprop_source_t source, nvlist_t *nvl,
2549     nvlist_t *errlist)
2550 {
2551 	nvpair_t *pair;
2552 	nvpair_t *propval;
2553 	int rv = 0;
2554 	int err;
2555 	uint64_t intval;
2556 	const char *strval;
2557 	boolean_t should_update_mount_cache = B_FALSE;
2558 
2559 	nvlist_t *genericnvl = fnvlist_alloc();
2560 	nvlist_t *retrynvl = fnvlist_alloc();
2561 retry:
2562 	pair = NULL;
2563 	while ((pair = nvlist_next_nvpair(nvl, pair)) != NULL) {
2564 		const char *propname = nvpair_name(pair);
2565 		zfs_prop_t prop = zfs_name_to_prop(propname);
2566 		err = 0;
2567 
2568 		/* decode the property value */
2569 		propval = pair;
2570 		if (nvpair_type(pair) == DATA_TYPE_NVLIST) {
2571 			nvlist_t *attrs;
2572 			attrs = fnvpair_value_nvlist(pair);
2573 			if (nvlist_lookup_nvpair(attrs, ZPROP_VALUE,
2574 			    &propval) != 0)
2575 				err = SET_ERROR(EINVAL);
2576 		}
2577 
2578 		/* Validate value type */
2579 		if (err == 0 && source == ZPROP_SRC_INHERITED) {
2580 			/* inherited properties are expected to be booleans */
2581 			if (nvpair_type(propval) != DATA_TYPE_BOOLEAN)
2582 				err = SET_ERROR(EINVAL);
2583 		} else if (err == 0 && prop == ZPROP_USERPROP) {
2584 			if (zfs_prop_user(propname)) {
2585 				if (nvpair_type(propval) != DATA_TYPE_STRING)
2586 					err = SET_ERROR(EINVAL);
2587 			} else if (zfs_prop_userquota(propname)) {
2588 				if (nvpair_type(propval) !=
2589 				    DATA_TYPE_UINT64_ARRAY)
2590 					err = SET_ERROR(EINVAL);
2591 			} else {
2592 				err = SET_ERROR(EINVAL);
2593 			}
2594 		} else if (err == 0) {
2595 			if (nvpair_type(propval) == DATA_TYPE_STRING) {
2596 				if (zfs_prop_get_type(prop) != PROP_TYPE_STRING)
2597 					err = SET_ERROR(EINVAL);
2598 			} else if (nvpair_type(propval) == DATA_TYPE_UINT64) {
2599 				const char *unused;
2600 
2601 				intval = fnvpair_value_uint64(propval);
2602 
2603 				switch (zfs_prop_get_type(prop)) {
2604 				case PROP_TYPE_NUMBER:
2605 					break;
2606 				case PROP_TYPE_STRING:
2607 					err = SET_ERROR(EINVAL);
2608 					break;
2609 				case PROP_TYPE_INDEX:
2610 					if (zfs_prop_index_to_string(prop,
2611 					    intval, &unused) != 0)
2612 						err =
2613 						    SET_ERROR(ZFS_ERR_BADPROP);
2614 					break;
2615 				default:
2616 					cmn_err(CE_PANIC,
2617 					    "unknown property type");
2618 				}
2619 			} else {
2620 				err = SET_ERROR(EINVAL);
2621 			}
2622 		}
2623 
2624 		/* Validate permissions */
2625 		if (err == 0)
2626 			err = zfs_check_settable(dsname, pair, CRED());
2627 
2628 		if (err == 0) {
2629 			if (source == ZPROP_SRC_INHERITED)
2630 				err = -1; /* does not need special handling */
2631 			else
2632 				err = zfs_prop_set_special(dsname, source,
2633 				    pair);
2634 			if (err == -1) {
2635 				/*
2636 				 * For better performance we build up a list of
2637 				 * properties to set in a single transaction.
2638 				 */
2639 				err = nvlist_add_nvpair(genericnvl, pair);
2640 			} else if (err != 0 && nvl != retrynvl) {
2641 				/*
2642 				 * This may be a spurious error caused by
2643 				 * receiving quota and reservation out of order.
2644 				 * Try again in a second pass.
2645 				 */
2646 				err = nvlist_add_nvpair(retrynvl, pair);
2647 			}
2648 		}
2649 
2650 		if (err != 0) {
2651 			if (errlist != NULL)
2652 				fnvlist_add_int32(errlist, propname, err);
2653 			rv = err;
2654 		}
2655 
2656 		if (zfs_is_namespace_prop(prop))
2657 			should_update_mount_cache = B_TRUE;
2658 	}
2659 
2660 	if (nvl != retrynvl && !nvlist_empty(retrynvl)) {
2661 		nvl = retrynvl;
2662 		goto retry;
2663 	}
2664 
2665 	if (nvlist_empty(genericnvl))
2666 		goto out;
2667 
2668 	/*
2669 	 * Try to set them all in one batch.
2670 	 */
2671 	err = dsl_props_set(dsname, source, genericnvl);
2672 	if (err == 0)
2673 		goto out;
2674 
2675 	/*
2676 	 * If batching fails, we still want to set as many properties as we
2677 	 * can, so try setting them individually.
2678 	 */
2679 	pair = NULL;
2680 	while ((pair = nvlist_next_nvpair(genericnvl, pair)) != NULL) {
2681 		const char *propname = nvpair_name(pair);
2682 		err = 0;
2683 
2684 		propval = pair;
2685 		if (nvpair_type(pair) == DATA_TYPE_NVLIST) {
2686 			nvlist_t *attrs;
2687 			attrs = fnvpair_value_nvlist(pair);
2688 			propval = fnvlist_lookup_nvpair(attrs, ZPROP_VALUE);
2689 		}
2690 
2691 		if (nvpair_type(propval) == DATA_TYPE_STRING) {
2692 			strval = fnvpair_value_string(propval);
2693 			err = dsl_prop_set_string(dsname, propname,
2694 			    source, strval);
2695 		} else if (nvpair_type(propval) == DATA_TYPE_BOOLEAN) {
2696 			err = dsl_prop_inherit(dsname, propname, source);
2697 		} else {
2698 			intval = fnvpair_value_uint64(propval);
2699 			err = dsl_prop_set_int(dsname, propname, source,
2700 			    intval);
2701 		}
2702 
2703 		if (err != 0) {
2704 			if (errlist != NULL) {
2705 				fnvlist_add_int32(errlist, propname, err);
2706 			}
2707 			rv = err;
2708 		}
2709 	}
2710 
2711 out:
2712 	if (should_update_mount_cache)
2713 		zfs_ioctl_update_mount_cache(dsname);
2714 
2715 	nvlist_free(genericnvl);
2716 	nvlist_free(retrynvl);
2717 
2718 	return (rv);
2719 }
2720 
2721 /*
2722  * Check that all the properties are valid user properties.
2723  */
2724 static int
2725 zfs_check_userprops(nvlist_t *nvl)
2726 {
2727 	nvpair_t *pair = NULL;
2728 
2729 	while ((pair = nvlist_next_nvpair(nvl, pair)) != NULL) {
2730 		const char *propname = nvpair_name(pair);
2731 
2732 		if (!zfs_prop_user(propname) ||
2733 		    nvpair_type(pair) != DATA_TYPE_STRING)
2734 			return (SET_ERROR(EINVAL));
2735 
2736 		if (strlen(propname) >= ZAP_MAXNAMELEN)
2737 			return (SET_ERROR(ENAMETOOLONG));
2738 
2739 		if (strlen(fnvpair_value_string(pair)) >= ZAP_MAXVALUELEN)
2740 			return (SET_ERROR(E2BIG));
2741 	}
2742 	return (0);
2743 }
2744 
2745 static void
2746 props_skip(nvlist_t *props, nvlist_t *skipped, nvlist_t **newprops)
2747 {
2748 	nvpair_t *pair;
2749 
2750 	VERIFY(nvlist_alloc(newprops, NV_UNIQUE_NAME, KM_SLEEP) == 0);
2751 
2752 	pair = NULL;
2753 	while ((pair = nvlist_next_nvpair(props, pair)) != NULL) {
2754 		if (nvlist_exists(skipped, nvpair_name(pair)))
2755 			continue;
2756 
2757 		VERIFY(nvlist_add_nvpair(*newprops, pair) == 0);
2758 	}
2759 }
2760 
2761 static int
2762 clear_received_props(const char *dsname, nvlist_t *props,
2763     nvlist_t *skipped)
2764 {
2765 	int err = 0;
2766 	nvlist_t *cleared_props = NULL;
2767 	props_skip(props, skipped, &cleared_props);
2768 	if (!nvlist_empty(cleared_props)) {
2769 		/*
2770 		 * Acts on local properties until the dataset has received
2771 		 * properties at least once on or after SPA_VERSION_RECVD_PROPS.
2772 		 */
2773 		zprop_source_t flags = (ZPROP_SRC_NONE |
2774 		    (dsl_prop_get_hasrecvd(dsname) ? ZPROP_SRC_RECEIVED : 0));
2775 		err = zfs_set_prop_nvlist(dsname, flags, cleared_props, NULL);
2776 	}
2777 	nvlist_free(cleared_props);
2778 	return (err);
2779 }
2780 
2781 /*
2782  * inputs:
2783  * zc_name		name of filesystem
2784  * zc_value		name of property to set
2785  * zc_nvlist_src{_size}	nvlist of properties to apply
2786  * zc_cookie		received properties flag
2787  *
2788  * outputs:
2789  * zc_nvlist_dst{_size} error for each unapplied received property
2790  */
2791 static int
2792 zfs_ioc_set_prop(zfs_cmd_t *zc)
2793 {
2794 	nvlist_t *nvl;
2795 	boolean_t received = zc->zc_cookie;
2796 	zprop_source_t source = (received ? ZPROP_SRC_RECEIVED :
2797 	    ZPROP_SRC_LOCAL);
2798 	nvlist_t *errors;
2799 	int error;
2800 
2801 	if ((error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
2802 	    zc->zc_iflags, &nvl)) != 0)
2803 		return (error);
2804 
2805 	if (received) {
2806 		nvlist_t *origprops;
2807 
2808 		if (dsl_prop_get_received(zc->zc_name, &origprops) == 0) {
2809 			(void) clear_received_props(zc->zc_name,
2810 			    origprops, nvl);
2811 			nvlist_free(origprops);
2812 		}
2813 
2814 		error = dsl_prop_set_hasrecvd(zc->zc_name);
2815 	}
2816 
2817 	errors = fnvlist_alloc();
2818 	if (error == 0)
2819 		error = zfs_set_prop_nvlist(zc->zc_name, source, nvl, errors);
2820 
2821 	if (zc->zc_nvlist_dst != 0 && errors != NULL) {
2822 		(void) put_nvlist(zc, errors);
2823 	}
2824 
2825 	nvlist_free(errors);
2826 	nvlist_free(nvl);
2827 	return (error);
2828 }
2829 
2830 /*
2831  * inputs:
2832  * zc_name		name of filesystem
2833  * zc_value		name of property to inherit
2834  * zc_cookie		revert to received value if TRUE
2835  *
2836  * outputs:		none
2837  */
2838 static int
2839 zfs_ioc_inherit_prop(zfs_cmd_t *zc)
2840 {
2841 	const char *propname = zc->zc_value;
2842 	zfs_prop_t prop = zfs_name_to_prop(propname);
2843 	boolean_t received = zc->zc_cookie;
2844 	zprop_source_t source = (received
2845 	    ? ZPROP_SRC_NONE		/* revert to received value, if any */
2846 	    : ZPROP_SRC_INHERITED);	/* explicitly inherit */
2847 	nvlist_t *dummy;
2848 	nvpair_t *pair;
2849 	zprop_type_t type;
2850 	int err;
2851 
2852 	if (!received) {
2853 		/*
2854 		 * Only check this in the non-received case. We want to allow
2855 		 * 'inherit -S' to revert non-inheritable properties like quota
2856 		 * and reservation to the received or default values even though
2857 		 * they are not considered inheritable.
2858 		 */
2859 		if (prop != ZPROP_USERPROP && !zfs_prop_inheritable(prop))
2860 			return (SET_ERROR(EINVAL));
2861 	}
2862 
2863 	if (prop == ZPROP_USERPROP) {
2864 		if (!zfs_prop_user(propname))
2865 			return (SET_ERROR(EINVAL));
2866 
2867 		type = PROP_TYPE_STRING;
2868 	} else if (prop == ZFS_PROP_VOLSIZE || prop == ZFS_PROP_VERSION) {
2869 		return (SET_ERROR(EINVAL));
2870 	} else {
2871 		type = zfs_prop_get_type(prop);
2872 	}
2873 
2874 	/*
2875 	 * zfs_prop_set_special() expects properties in the form of an
2876 	 * nvpair with type info.
2877 	 */
2878 	dummy = fnvlist_alloc();
2879 
2880 	switch (type) {
2881 	case PROP_TYPE_STRING:
2882 		VERIFY(0 == nvlist_add_string(dummy, propname, ""));
2883 		break;
2884 	case PROP_TYPE_NUMBER:
2885 	case PROP_TYPE_INDEX:
2886 		VERIFY(0 == nvlist_add_uint64(dummy, propname, 0));
2887 		break;
2888 	default:
2889 		err = SET_ERROR(EINVAL);
2890 		goto errout;
2891 	}
2892 
2893 	pair = nvlist_next_nvpair(dummy, NULL);
2894 	if (pair == NULL) {
2895 		err = SET_ERROR(EINVAL);
2896 	} else {
2897 		err = zfs_prop_set_special(zc->zc_name, source, pair);
2898 		if (err == -1) /* property is not "special", needs handling */
2899 			err = dsl_prop_inherit(zc->zc_name, zc->zc_value,
2900 			    source);
2901 	}
2902 
2903 errout:
2904 	nvlist_free(dummy);
2905 	return (err);
2906 }
2907 
2908 static int
2909 zfs_ioc_pool_set_props(zfs_cmd_t *zc)
2910 {
2911 	nvlist_t *props;
2912 	spa_t *spa;
2913 	int error;
2914 	nvpair_t *pair;
2915 
2916 	if ((error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
2917 	    zc->zc_iflags, &props)))
2918 		return (error);
2919 
2920 	/*
2921 	 * If the only property is the configfile, then just do a spa_lookup()
2922 	 * to handle the faulted case.
2923 	 */
2924 	pair = nvlist_next_nvpair(props, NULL);
2925 	if (pair != NULL && strcmp(nvpair_name(pair),
2926 	    zpool_prop_to_name(ZPOOL_PROP_CACHEFILE)) == 0 &&
2927 	    nvlist_next_nvpair(props, pair) == NULL) {
2928 		mutex_enter(&spa_namespace_lock);
2929 		if ((spa = spa_lookup(zc->zc_name)) != NULL) {
2930 			spa_configfile_set(spa, props, B_FALSE);
2931 			spa_write_cachefile(spa, B_FALSE, B_TRUE);
2932 		}
2933 		mutex_exit(&spa_namespace_lock);
2934 		if (spa != NULL) {
2935 			nvlist_free(props);
2936 			return (0);
2937 		}
2938 	}
2939 
2940 	if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0) {
2941 		nvlist_free(props);
2942 		return (error);
2943 	}
2944 
2945 	error = spa_prop_set(spa, props);
2946 
2947 	nvlist_free(props);
2948 	spa_close(spa, FTAG);
2949 
2950 	return (error);
2951 }
2952 
2953 static int
2954 zfs_ioc_pool_get_props(zfs_cmd_t *zc)
2955 {
2956 	spa_t *spa;
2957 	int error;
2958 	nvlist_t *nvp = NULL;
2959 
2960 	if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0) {
2961 		/*
2962 		 * If the pool is faulted, there may be properties we can still
2963 		 * get (such as altroot and cachefile), so attempt to get them
2964 		 * anyway.
2965 		 */
2966 		mutex_enter(&spa_namespace_lock);
2967 		if ((spa = spa_lookup(zc->zc_name)) != NULL)
2968 			error = spa_prop_get(spa, &nvp);
2969 		mutex_exit(&spa_namespace_lock);
2970 	} else {
2971 		error = spa_prop_get(spa, &nvp);
2972 		spa_close(spa, FTAG);
2973 	}
2974 
2975 	if (error == 0 && zc->zc_nvlist_dst != 0)
2976 		error = put_nvlist(zc, nvp);
2977 	else
2978 		error = SET_ERROR(EFAULT);
2979 
2980 	nvlist_free(nvp);
2981 	return (error);
2982 }
2983 
2984 /*
2985  * innvl: {
2986  *     "vdevprops_set_vdev" -> guid
2987  *     "vdevprops_set_props" -> { prop -> value }
2988  * }
2989  *
2990  * outnvl: propname -> error code (int32)
2991  */
2992 static const zfs_ioc_key_t zfs_keys_vdev_set_props[] = {
2993 	{ZPOOL_VDEV_PROPS_SET_VDEV,	DATA_TYPE_UINT64,	0},
2994 	{ZPOOL_VDEV_PROPS_SET_PROPS,	DATA_TYPE_NVLIST,	0}
2995 };
2996 
2997 static int
2998 zfs_ioc_vdev_set_props(const char *poolname, nvlist_t *innvl, nvlist_t *outnvl)
2999 {
3000 	spa_t *spa;
3001 	int error;
3002 	vdev_t *vd;
3003 	uint64_t vdev_guid;
3004 
3005 	/* Early validation */
3006 	if (nvlist_lookup_uint64(innvl, ZPOOL_VDEV_PROPS_SET_VDEV,
3007 	    &vdev_guid) != 0)
3008 		return (SET_ERROR(EINVAL));
3009 
3010 	if (outnvl == NULL)
3011 		return (SET_ERROR(EINVAL));
3012 
3013 	if ((error = spa_open(poolname, &spa, FTAG)) != 0)
3014 		return (error);
3015 
3016 	ASSERT(spa_writeable(spa));
3017 
3018 	if ((vd = spa_lookup_by_guid(spa, vdev_guid, B_TRUE)) == NULL) {
3019 		spa_close(spa, FTAG);
3020 		return (SET_ERROR(ENOENT));
3021 	}
3022 
3023 	error = vdev_prop_set(vd, innvl, outnvl);
3024 
3025 	spa_close(spa, FTAG);
3026 
3027 	return (error);
3028 }
3029 
3030 /*
3031  * innvl: {
3032  *     "vdevprops_get_vdev" -> guid
3033  *     (optional) "vdevprops_get_props" -> { propname -> propid }
3034  * }
3035  *
3036  * outnvl: propname -> value
3037  */
3038 static const zfs_ioc_key_t zfs_keys_vdev_get_props[] = {
3039 	{ZPOOL_VDEV_PROPS_GET_VDEV,	DATA_TYPE_UINT64,	0},
3040 	{ZPOOL_VDEV_PROPS_GET_PROPS,	DATA_TYPE_NVLIST,	ZK_OPTIONAL}
3041 };
3042 
3043 static int
3044 zfs_ioc_vdev_get_props(const char *poolname, nvlist_t *innvl, nvlist_t *outnvl)
3045 {
3046 	spa_t *spa;
3047 	int error;
3048 	vdev_t *vd;
3049 	uint64_t vdev_guid;
3050 
3051 	/* Early validation */
3052 	if (nvlist_lookup_uint64(innvl, ZPOOL_VDEV_PROPS_GET_VDEV,
3053 	    &vdev_guid) != 0)
3054 		return (SET_ERROR(EINVAL));
3055 
3056 	if (outnvl == NULL)
3057 		return (SET_ERROR(EINVAL));
3058 
3059 	if ((error = spa_open(poolname, &spa, FTAG)) != 0)
3060 		return (error);
3061 
3062 	if ((vd = spa_lookup_by_guid(spa, vdev_guid, B_TRUE)) == NULL) {
3063 		spa_close(spa, FTAG);
3064 		return (SET_ERROR(ENOENT));
3065 	}
3066 
3067 	error = vdev_prop_get(vd, innvl, outnvl);
3068 
3069 	spa_close(spa, FTAG);
3070 
3071 	return (error);
3072 }
3073 
3074 /*
3075  * inputs:
3076  * zc_name		name of filesystem
3077  * zc_nvlist_src{_size}	nvlist of delegated permissions
3078  * zc_perm_action	allow/unallow flag
3079  *
3080  * outputs:		none
3081  */
3082 static int
3083 zfs_ioc_set_fsacl(zfs_cmd_t *zc)
3084 {
3085 	int error;
3086 	nvlist_t *fsaclnv = NULL;
3087 
3088 	if ((error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
3089 	    zc->zc_iflags, &fsaclnv)) != 0)
3090 		return (error);
3091 
3092 	/*
3093 	 * Verify nvlist is constructed correctly
3094 	 */
3095 	if ((error = zfs_deleg_verify_nvlist(fsaclnv)) != 0) {
3096 		nvlist_free(fsaclnv);
3097 		return (SET_ERROR(EINVAL));
3098 	}
3099 
3100 	/*
3101 	 * If we don't have PRIV_SYS_MOUNT, then validate
3102 	 * that user is allowed to hand out each permission in
3103 	 * the nvlist(s)
3104 	 */
3105 
3106 	error = secpolicy_zfs(CRED());
3107 	if (error != 0) {
3108 		if (zc->zc_perm_action == B_FALSE) {
3109 			error = dsl_deleg_can_allow(zc->zc_name,
3110 			    fsaclnv, CRED());
3111 		} else {
3112 			error = dsl_deleg_can_unallow(zc->zc_name,
3113 			    fsaclnv, CRED());
3114 		}
3115 	}
3116 
3117 	if (error == 0)
3118 		error = dsl_deleg_set(zc->zc_name, fsaclnv, zc->zc_perm_action);
3119 
3120 	nvlist_free(fsaclnv);
3121 	return (error);
3122 }
3123 
3124 /*
3125  * inputs:
3126  * zc_name		name of filesystem
3127  *
3128  * outputs:
3129  * zc_nvlist_src{_size}	nvlist of delegated permissions
3130  */
3131 static int
3132 zfs_ioc_get_fsacl(zfs_cmd_t *zc)
3133 {
3134 	nvlist_t *nvp;
3135 	int error;
3136 
3137 	if ((error = dsl_deleg_get(zc->zc_name, &nvp)) == 0) {
3138 		error = put_nvlist(zc, nvp);
3139 		nvlist_free(nvp);
3140 	}
3141 
3142 	return (error);
3143 }
3144 
3145 static void
3146 zfs_create_cb(objset_t *os, void *arg, cred_t *cr, dmu_tx_t *tx)
3147 {
3148 	zfs_creat_t *zct = arg;
3149 
3150 	zfs_create_fs(os, cr, zct->zct_zplprops, tx);
3151 }
3152 
3153 #define	ZFS_PROP_UNDEFINED	((uint64_t)-1)
3154 
3155 /*
3156  * inputs:
3157  * os			parent objset pointer (NULL if root fs)
3158  * fuids_ok		fuids allowed in this version of the spa?
3159  * sa_ok		SAs allowed in this version of the spa?
3160  * createprops		list of properties requested by creator
3161  *
3162  * outputs:
3163  * zplprops	values for the zplprops we attach to the master node object
3164  * is_ci	true if requested file system will be purely case-insensitive
3165  *
3166  * Determine the settings for utf8only, normalization and
3167  * casesensitivity.  Specific values may have been requested by the
3168  * creator and/or we can inherit values from the parent dataset.  If
3169  * the file system is of too early a vintage, a creator can not
3170  * request settings for these properties, even if the requested
3171  * setting is the default value.  We don't actually want to create dsl
3172  * properties for these, so remove them from the source nvlist after
3173  * processing.
3174  */
3175 static int
3176 zfs_fill_zplprops_impl(objset_t *os, uint64_t zplver,
3177     boolean_t fuids_ok, boolean_t sa_ok, nvlist_t *createprops,
3178     nvlist_t *zplprops, boolean_t *is_ci)
3179 {
3180 	uint64_t sense = ZFS_PROP_UNDEFINED;
3181 	uint64_t norm = ZFS_PROP_UNDEFINED;
3182 	uint64_t u8 = ZFS_PROP_UNDEFINED;
3183 	int error;
3184 
3185 	ASSERT(zplprops != NULL);
3186 
3187 	/* parent dataset must be a filesystem */
3188 	if (os != NULL && os->os_phys->os_type != DMU_OST_ZFS)
3189 		return (SET_ERROR(ZFS_ERR_WRONG_PARENT));
3190 
3191 	/*
3192 	 * Pull out creator prop choices, if any.
3193 	 */
3194 	if (createprops) {
3195 		(void) nvlist_lookup_uint64(createprops,
3196 		    zfs_prop_to_name(ZFS_PROP_VERSION), &zplver);
3197 		(void) nvlist_lookup_uint64(createprops,
3198 		    zfs_prop_to_name(ZFS_PROP_NORMALIZE), &norm);
3199 		(void) nvlist_remove_all(createprops,
3200 		    zfs_prop_to_name(ZFS_PROP_NORMALIZE));
3201 		(void) nvlist_lookup_uint64(createprops,
3202 		    zfs_prop_to_name(ZFS_PROP_UTF8ONLY), &u8);
3203 		(void) nvlist_remove_all(createprops,
3204 		    zfs_prop_to_name(ZFS_PROP_UTF8ONLY));
3205 		(void) nvlist_lookup_uint64(createprops,
3206 		    zfs_prop_to_name(ZFS_PROP_CASE), &sense);
3207 		(void) nvlist_remove_all(createprops,
3208 		    zfs_prop_to_name(ZFS_PROP_CASE));
3209 	}
3210 
3211 	/*
3212 	 * If the zpl version requested is whacky or the file system
3213 	 * or pool is version is too "young" to support normalization
3214 	 * and the creator tried to set a value for one of the props,
3215 	 * error out.
3216 	 */
3217 	if ((zplver < ZPL_VERSION_INITIAL || zplver > ZPL_VERSION) ||
3218 	    (zplver >= ZPL_VERSION_FUID && !fuids_ok) ||
3219 	    (zplver >= ZPL_VERSION_SA && !sa_ok) ||
3220 	    (zplver < ZPL_VERSION_NORMALIZATION &&
3221 	    (norm != ZFS_PROP_UNDEFINED || u8 != ZFS_PROP_UNDEFINED ||
3222 	    sense != ZFS_PROP_UNDEFINED)))
3223 		return (SET_ERROR(ENOTSUP));
3224 
3225 	/*
3226 	 * Put the version in the zplprops
3227 	 */
3228 	VERIFY(nvlist_add_uint64(zplprops,
3229 	    zfs_prop_to_name(ZFS_PROP_VERSION), zplver) == 0);
3230 
3231 	if (norm == ZFS_PROP_UNDEFINED &&
3232 	    (error = zfs_get_zplprop(os, ZFS_PROP_NORMALIZE, &norm)) != 0)
3233 		return (error);
3234 	VERIFY(nvlist_add_uint64(zplprops,
3235 	    zfs_prop_to_name(ZFS_PROP_NORMALIZE), norm) == 0);
3236 
3237 	/*
3238 	 * If we're normalizing, names must always be valid UTF-8 strings.
3239 	 */
3240 	if (norm)
3241 		u8 = 1;
3242 	if (u8 == ZFS_PROP_UNDEFINED &&
3243 	    (error = zfs_get_zplprop(os, ZFS_PROP_UTF8ONLY, &u8)) != 0)
3244 		return (error);
3245 	VERIFY(nvlist_add_uint64(zplprops,
3246 	    zfs_prop_to_name(ZFS_PROP_UTF8ONLY), u8) == 0);
3247 
3248 	if (sense == ZFS_PROP_UNDEFINED &&
3249 	    (error = zfs_get_zplprop(os, ZFS_PROP_CASE, &sense)) != 0)
3250 		return (error);
3251 	VERIFY(nvlist_add_uint64(zplprops,
3252 	    zfs_prop_to_name(ZFS_PROP_CASE), sense) == 0);
3253 
3254 	if (is_ci)
3255 		*is_ci = (sense == ZFS_CASE_INSENSITIVE);
3256 
3257 	return (0);
3258 }
3259 
3260 static int
3261 zfs_fill_zplprops(const char *dataset, nvlist_t *createprops,
3262     nvlist_t *zplprops, boolean_t *is_ci)
3263 {
3264 	boolean_t fuids_ok, sa_ok;
3265 	uint64_t zplver = ZPL_VERSION;
3266 	objset_t *os = NULL;
3267 	char parentname[ZFS_MAX_DATASET_NAME_LEN];
3268 	spa_t *spa;
3269 	uint64_t spa_vers;
3270 	int error;
3271 
3272 	zfs_get_parent(dataset, parentname, sizeof (parentname));
3273 
3274 	if ((error = spa_open(dataset, &spa, FTAG)) != 0)
3275 		return (error);
3276 
3277 	spa_vers = spa_version(spa);
3278 	spa_close(spa, FTAG);
3279 
3280 	zplver = zfs_zpl_version_map(spa_vers);
3281 	fuids_ok = (zplver >= ZPL_VERSION_FUID);
3282 	sa_ok = (zplver >= ZPL_VERSION_SA);
3283 
3284 	/*
3285 	 * Open parent object set so we can inherit zplprop values.
3286 	 */
3287 	if ((error = dmu_objset_hold(parentname, FTAG, &os)) != 0)
3288 		return (error);
3289 
3290 	error = zfs_fill_zplprops_impl(os, zplver, fuids_ok, sa_ok, createprops,
3291 	    zplprops, is_ci);
3292 	dmu_objset_rele(os, FTAG);
3293 	return (error);
3294 }
3295 
3296 static int
3297 zfs_fill_zplprops_root(uint64_t spa_vers, nvlist_t *createprops,
3298     nvlist_t *zplprops, boolean_t *is_ci)
3299 {
3300 	boolean_t fuids_ok;
3301 	boolean_t sa_ok;
3302 	uint64_t zplver = ZPL_VERSION;
3303 	int error;
3304 
3305 	zplver = zfs_zpl_version_map(spa_vers);
3306 	fuids_ok = (zplver >= ZPL_VERSION_FUID);
3307 	sa_ok = (zplver >= ZPL_VERSION_SA);
3308 
3309 	error = zfs_fill_zplprops_impl(NULL, zplver, fuids_ok, sa_ok,
3310 	    createprops, zplprops, is_ci);
3311 	return (error);
3312 }
3313 
3314 /*
3315  * innvl: {
3316  *     "type" -> dmu_objset_type_t (int32)
3317  *     (optional) "props" -> { prop -> value }
3318  *     (optional) "hidden_args" -> { "wkeydata" -> value }
3319  *         raw uint8_t array of encryption wrapping key data (32 bytes)
3320  * }
3321  *
3322  * outnvl: propname -> error code (int32)
3323  */
3324 
3325 static const zfs_ioc_key_t zfs_keys_create[] = {
3326 	{"type",	DATA_TYPE_INT32,	0},
3327 	{"props",	DATA_TYPE_NVLIST,	ZK_OPTIONAL},
3328 	{"hidden_args",	DATA_TYPE_NVLIST,	ZK_OPTIONAL},
3329 };
3330 
3331 static int
3332 zfs_ioc_create(const char *fsname, nvlist_t *innvl, nvlist_t *outnvl)
3333 {
3334 	int error = 0;
3335 	zfs_creat_t zct = { 0 };
3336 	nvlist_t *nvprops = NULL;
3337 	nvlist_t *hidden_args = NULL;
3338 	void (*cbfunc)(objset_t *os, void *arg, cred_t *cr, dmu_tx_t *tx);
3339 	dmu_objset_type_t type;
3340 	boolean_t is_insensitive = B_FALSE;
3341 	dsl_crypto_params_t *dcp = NULL;
3342 
3343 	type = (dmu_objset_type_t)fnvlist_lookup_int32(innvl, "type");
3344 	(void) nvlist_lookup_nvlist(innvl, "props", &nvprops);
3345 	(void) nvlist_lookup_nvlist(innvl, ZPOOL_HIDDEN_ARGS, &hidden_args);
3346 
3347 	switch (type) {
3348 	case DMU_OST_ZFS:
3349 		cbfunc = zfs_create_cb;
3350 		break;
3351 
3352 	case DMU_OST_ZVOL:
3353 		cbfunc = zvol_create_cb;
3354 		break;
3355 
3356 	default:
3357 		cbfunc = NULL;
3358 		break;
3359 	}
3360 	if (strchr(fsname, '@') ||
3361 	    strchr(fsname, '%'))
3362 		return (SET_ERROR(EINVAL));
3363 
3364 	zct.zct_props = nvprops;
3365 
3366 	if (cbfunc == NULL)
3367 		return (SET_ERROR(EINVAL));
3368 
3369 	if (type == DMU_OST_ZVOL) {
3370 		uint64_t volsize, volblocksize;
3371 
3372 		if (nvprops == NULL)
3373 			return (SET_ERROR(EINVAL));
3374 		if (nvlist_lookup_uint64(nvprops,
3375 		    zfs_prop_to_name(ZFS_PROP_VOLSIZE), &volsize) != 0)
3376 			return (SET_ERROR(EINVAL));
3377 
3378 		if ((error = nvlist_lookup_uint64(nvprops,
3379 		    zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE),
3380 		    &volblocksize)) != 0 && error != ENOENT)
3381 			return (SET_ERROR(EINVAL));
3382 
3383 		if (error != 0)
3384 			volblocksize = zfs_prop_default_numeric(
3385 			    ZFS_PROP_VOLBLOCKSIZE);
3386 
3387 		if ((error = zvol_check_volblocksize(fsname,
3388 		    volblocksize)) != 0 ||
3389 		    (error = zvol_check_volsize(volsize,
3390 		    volblocksize)) != 0)
3391 			return (error);
3392 	} else if (type == DMU_OST_ZFS) {
3393 		int error;
3394 
3395 		/*
3396 		 * We have to have normalization and
3397 		 * case-folding flags correct when we do the
3398 		 * file system creation, so go figure them out
3399 		 * now.
3400 		 */
3401 		VERIFY(nvlist_alloc(&zct.zct_zplprops,
3402 		    NV_UNIQUE_NAME, KM_SLEEP) == 0);
3403 		error = zfs_fill_zplprops(fsname, nvprops,
3404 		    zct.zct_zplprops, &is_insensitive);
3405 		if (error != 0) {
3406 			nvlist_free(zct.zct_zplprops);
3407 			return (error);
3408 		}
3409 	}
3410 
3411 	error = dsl_crypto_params_create_nvlist(DCP_CMD_NONE, nvprops,
3412 	    hidden_args, &dcp);
3413 	if (error != 0) {
3414 		nvlist_free(zct.zct_zplprops);
3415 		return (error);
3416 	}
3417 
3418 	error = dmu_objset_create(fsname, type,
3419 	    is_insensitive ? DS_FLAG_CI_DATASET : 0, dcp, cbfunc, &zct);
3420 
3421 	nvlist_free(zct.zct_zplprops);
3422 	dsl_crypto_params_free(dcp, !!error);
3423 
3424 	/*
3425 	 * It would be nice to do this atomically.
3426 	 */
3427 	if (error == 0) {
3428 		error = zfs_set_prop_nvlist(fsname, ZPROP_SRC_LOCAL,
3429 		    nvprops, outnvl);
3430 		if (error != 0) {
3431 			spa_t *spa;
3432 			int error2;
3433 
3434 			/*
3435 			 * Volumes will return EBUSY and cannot be destroyed
3436 			 * until all asynchronous minor handling (e.g. from
3437 			 * setting the volmode property) has completed. Wait for
3438 			 * the spa_zvol_taskq to drain then retry.
3439 			 */
3440 			error2 = dsl_destroy_head(fsname);
3441 			while ((error2 == EBUSY) && (type == DMU_OST_ZVOL)) {
3442 				error2 = spa_open(fsname, &spa, FTAG);
3443 				if (error2 == 0) {
3444 					taskq_wait(spa->spa_zvol_taskq);
3445 					spa_close(spa, FTAG);
3446 				}
3447 				error2 = dsl_destroy_head(fsname);
3448 			}
3449 		}
3450 	}
3451 	return (error);
3452 }
3453 
3454 /*
3455  * innvl: {
3456  *     "origin" -> name of origin snapshot
3457  *     (optional) "props" -> { prop -> value }
3458  *     (optional) "hidden_args" -> { "wkeydata" -> value }
3459  *         raw uint8_t array of encryption wrapping key data (32 bytes)
3460  * }
3461  *
3462  * outputs:
3463  * outnvl: propname -> error code (int32)
3464  */
3465 static const zfs_ioc_key_t zfs_keys_clone[] = {
3466 	{"origin",	DATA_TYPE_STRING,	0},
3467 	{"props",	DATA_TYPE_NVLIST,	ZK_OPTIONAL},
3468 	{"hidden_args",	DATA_TYPE_NVLIST,	ZK_OPTIONAL},
3469 };
3470 
3471 static int
3472 zfs_ioc_clone(const char *fsname, nvlist_t *innvl, nvlist_t *outnvl)
3473 {
3474 	int error = 0;
3475 	nvlist_t *nvprops = NULL;
3476 	const char *origin_name;
3477 
3478 	origin_name = fnvlist_lookup_string(innvl, "origin");
3479 	(void) nvlist_lookup_nvlist(innvl, "props", &nvprops);
3480 
3481 	if (strchr(fsname, '@') ||
3482 	    strchr(fsname, '%'))
3483 		return (SET_ERROR(EINVAL));
3484 
3485 	if (dataset_namecheck(origin_name, NULL, NULL) != 0)
3486 		return (SET_ERROR(EINVAL));
3487 
3488 	error = dmu_objset_clone(fsname, origin_name);
3489 
3490 	/*
3491 	 * It would be nice to do this atomically.
3492 	 */
3493 	if (error == 0) {
3494 		error = zfs_set_prop_nvlist(fsname, ZPROP_SRC_LOCAL,
3495 		    nvprops, outnvl);
3496 		if (error != 0)
3497 			(void) dsl_destroy_head(fsname);
3498 	}
3499 	return (error);
3500 }
3501 
3502 static const zfs_ioc_key_t zfs_keys_remap[] = {
3503 	/* no nvl keys */
3504 };
3505 
3506 static int
3507 zfs_ioc_remap(const char *fsname, nvlist_t *innvl, nvlist_t *outnvl)
3508 {
3509 	/* This IOCTL is no longer supported. */
3510 	(void) fsname, (void) innvl, (void) outnvl;
3511 	return (0);
3512 }
3513 
3514 /*
3515  * innvl: {
3516  *     "snaps" -> { snapshot1, snapshot2 }
3517  *     (optional) "props" -> { prop -> value (string) }
3518  * }
3519  *
3520  * outnvl: snapshot -> error code (int32)
3521  */
3522 static const zfs_ioc_key_t zfs_keys_snapshot[] = {
3523 	{"snaps",	DATA_TYPE_NVLIST,	0},
3524 	{"props",	DATA_TYPE_NVLIST,	ZK_OPTIONAL},
3525 };
3526 
3527 static int
3528 zfs_ioc_snapshot(const char *poolname, nvlist_t *innvl, nvlist_t *outnvl)
3529 {
3530 	nvlist_t *snaps;
3531 	nvlist_t *props = NULL;
3532 	int error, poollen;
3533 	nvpair_t *pair;
3534 
3535 	(void) nvlist_lookup_nvlist(innvl, "props", &props);
3536 	if (!nvlist_empty(props) &&
3537 	    zfs_earlier_version(poolname, SPA_VERSION_SNAP_PROPS))
3538 		return (SET_ERROR(ENOTSUP));
3539 	if ((error = zfs_check_userprops(props)) != 0)
3540 		return (error);
3541 
3542 	snaps = fnvlist_lookup_nvlist(innvl, "snaps");
3543 	poollen = strlen(poolname);
3544 	for (pair = nvlist_next_nvpair(snaps, NULL); pair != NULL;
3545 	    pair = nvlist_next_nvpair(snaps, pair)) {
3546 		const char *name = nvpair_name(pair);
3547 		char *cp = strchr(name, '@');
3548 
3549 		/*
3550 		 * The snap name must contain an @, and the part after it must
3551 		 * contain only valid characters.
3552 		 */
3553 		if (cp == NULL ||
3554 		    zfs_component_namecheck(cp + 1, NULL, NULL) != 0)
3555 			return (SET_ERROR(EINVAL));
3556 
3557 		/*
3558 		 * The snap must be in the specified pool.
3559 		 */
3560 		if (strncmp(name, poolname, poollen) != 0 ||
3561 		    (name[poollen] != '/' && name[poollen] != '@'))
3562 			return (SET_ERROR(EXDEV));
3563 
3564 		/*
3565 		 * Check for permission to set the properties on the fs.
3566 		 */
3567 		if (!nvlist_empty(props)) {
3568 			*cp = '\0';
3569 			error = zfs_secpolicy_write_perms(name,
3570 			    ZFS_DELEG_PERM_USERPROP, CRED());
3571 			*cp = '@';
3572 			if (error != 0)
3573 				return (error);
3574 		}
3575 
3576 		/* This must be the only snap of this fs. */
3577 		for (nvpair_t *pair2 = nvlist_next_nvpair(snaps, pair);
3578 		    pair2 != NULL; pair2 = nvlist_next_nvpair(snaps, pair2)) {
3579 			if (strncmp(name, nvpair_name(pair2), cp - name + 1)
3580 			    == 0) {
3581 				return (SET_ERROR(EXDEV));
3582 			}
3583 		}
3584 	}
3585 
3586 	error = dsl_dataset_snapshot(snaps, props, outnvl);
3587 
3588 	return (error);
3589 }
3590 
3591 /*
3592  * innvl: "message" -> string
3593  */
3594 static const zfs_ioc_key_t zfs_keys_log_history[] = {
3595 	{"message",	DATA_TYPE_STRING,	0},
3596 };
3597 
3598 static int
3599 zfs_ioc_log_history(const char *unused, nvlist_t *innvl, nvlist_t *outnvl)
3600 {
3601 	(void) unused, (void) outnvl;
3602 	const char *message;
3603 	char *poolname;
3604 	spa_t *spa;
3605 	int error;
3606 
3607 	/*
3608 	 * The poolname in the ioctl is not set, we get it from the TSD,
3609 	 * which was set at the end of the last successful ioctl that allows
3610 	 * logging.  The secpolicy func already checked that it is set.
3611 	 * Only one log ioctl is allowed after each successful ioctl, so
3612 	 * we clear the TSD here.
3613 	 */
3614 	poolname = tsd_get(zfs_allow_log_key);
3615 	if (poolname == NULL)
3616 		return (SET_ERROR(EINVAL));
3617 	(void) tsd_set(zfs_allow_log_key, NULL);
3618 	error = spa_open(poolname, &spa, FTAG);
3619 	kmem_strfree(poolname);
3620 	if (error != 0)
3621 		return (error);
3622 
3623 	message = fnvlist_lookup_string(innvl, "message");
3624 
3625 	if (spa_version(spa) < SPA_VERSION_ZPOOL_HISTORY) {
3626 		spa_close(spa, FTAG);
3627 		return (SET_ERROR(ENOTSUP));
3628 	}
3629 
3630 	error = spa_history_log(spa, message);
3631 	spa_close(spa, FTAG);
3632 	return (error);
3633 }
3634 
3635 /*
3636  * This ioctl is used to set the bootenv configuration on the current
3637  * pool. This configuration is stored in the second padding area of the label,
3638  * and it is used by the bootloader(s) to store the bootloader and/or system
3639  * specific data.
3640  * The data is stored as nvlist data stream, and is protected by
3641  * an embedded checksum.
3642  * The version can have two possible values:
3643  * VB_RAW: nvlist should have key GRUB_ENVMAP, value DATA_TYPE_STRING.
3644  * VB_NVLIST: nvlist with arbitrary <key, value> pairs.
3645  */
3646 static const zfs_ioc_key_t zfs_keys_set_bootenv[] = {
3647 	{"version",	DATA_TYPE_UINT64,	0},
3648 	{"<keys>",	DATA_TYPE_ANY, ZK_OPTIONAL | ZK_WILDCARDLIST},
3649 };
3650 
3651 static int
3652 zfs_ioc_set_bootenv(const char *name, nvlist_t *innvl, nvlist_t *outnvl)
3653 {
3654 	int error;
3655 	spa_t *spa;
3656 
3657 	if ((error = spa_open(name, &spa, FTAG)) != 0)
3658 		return (error);
3659 	spa_vdev_state_enter(spa, SCL_ALL);
3660 	error = vdev_label_write_bootenv(spa->spa_root_vdev, innvl);
3661 	(void) spa_vdev_state_exit(spa, NULL, 0);
3662 	spa_close(spa, FTAG);
3663 	return (error);
3664 }
3665 
3666 static const zfs_ioc_key_t zfs_keys_get_bootenv[] = {
3667 	/* no nvl keys */
3668 };
3669 
3670 static int
3671 zfs_ioc_get_bootenv(const char *name, nvlist_t *innvl, nvlist_t *outnvl)
3672 {
3673 	spa_t *spa;
3674 	int error;
3675 
3676 	if ((error = spa_open(name, &spa, FTAG)) != 0)
3677 		return (error);
3678 	spa_vdev_state_enter(spa, SCL_ALL);
3679 	error = vdev_label_read_bootenv(spa->spa_root_vdev, outnvl);
3680 	(void) spa_vdev_state_exit(spa, NULL, 0);
3681 	spa_close(spa, FTAG);
3682 	return (error);
3683 }
3684 
3685 /*
3686  * The dp_config_rwlock must not be held when calling this, because the
3687  * unmount may need to write out data.
3688  *
3689  * This function is best-effort.  Callers must deal gracefully if it
3690  * remains mounted (or is remounted after this call).
3691  *
3692  * Returns 0 if the argument is not a snapshot, or it is not currently a
3693  * filesystem, or we were able to unmount it.  Returns error code otherwise.
3694  */
3695 void
3696 zfs_unmount_snap(const char *snapname)
3697 {
3698 	if (strchr(snapname, '@') == NULL)
3699 		return;
3700 
3701 	(void) zfsctl_snapshot_unmount(snapname, MNT_FORCE);
3702 }
3703 
3704 static int
3705 zfs_unmount_snap_cb(const char *snapname, void *arg)
3706 {
3707 	(void) arg;
3708 	zfs_unmount_snap(snapname);
3709 	return (0);
3710 }
3711 
3712 /*
3713  * When a clone is destroyed, its origin may also need to be destroyed,
3714  * in which case it must be unmounted.  This routine will do that unmount
3715  * if necessary.
3716  */
3717 void
3718 zfs_destroy_unmount_origin(const char *fsname)
3719 {
3720 	int error;
3721 	objset_t *os;
3722 	dsl_dataset_t *ds;
3723 
3724 	error = dmu_objset_hold(fsname, FTAG, &os);
3725 	if (error != 0)
3726 		return;
3727 	ds = dmu_objset_ds(os);
3728 	if (dsl_dir_is_clone(ds->ds_dir) && DS_IS_DEFER_DESTROY(ds->ds_prev)) {
3729 		char originname[ZFS_MAX_DATASET_NAME_LEN];
3730 		dsl_dataset_name(ds->ds_prev, originname);
3731 		dmu_objset_rele(os, FTAG);
3732 		zfs_unmount_snap(originname);
3733 	} else {
3734 		dmu_objset_rele(os, FTAG);
3735 	}
3736 }
3737 
3738 /*
3739  * innvl: {
3740  *     "snaps" -> { snapshot1, snapshot2 }
3741  *     (optional boolean) "defer"
3742  * }
3743  *
3744  * outnvl: snapshot -> error code (int32)
3745  */
3746 static const zfs_ioc_key_t zfs_keys_destroy_snaps[] = {
3747 	{"snaps",	DATA_TYPE_NVLIST,	0},
3748 	{"defer",	DATA_TYPE_BOOLEAN,	ZK_OPTIONAL},
3749 };
3750 
3751 static int
3752 zfs_ioc_destroy_snaps(const char *poolname, nvlist_t *innvl, nvlist_t *outnvl)
3753 {
3754 	int poollen;
3755 	nvlist_t *snaps;
3756 	nvpair_t *pair;
3757 	boolean_t defer;
3758 	spa_t *spa;
3759 
3760 	snaps = fnvlist_lookup_nvlist(innvl, "snaps");
3761 	defer = nvlist_exists(innvl, "defer");
3762 
3763 	poollen = strlen(poolname);
3764 	for (pair = nvlist_next_nvpair(snaps, NULL); pair != NULL;
3765 	    pair = nvlist_next_nvpair(snaps, pair)) {
3766 		const char *name = nvpair_name(pair);
3767 
3768 		/*
3769 		 * The snap must be in the specified pool to prevent the
3770 		 * invalid removal of zvol minors below.
3771 		 */
3772 		if (strncmp(name, poolname, poollen) != 0 ||
3773 		    (name[poollen] != '/' && name[poollen] != '@'))
3774 			return (SET_ERROR(EXDEV));
3775 
3776 		zfs_unmount_snap(nvpair_name(pair));
3777 		if (spa_open(name, &spa, FTAG) == 0) {
3778 			zvol_remove_minors(spa, name, B_TRUE);
3779 			spa_close(spa, FTAG);
3780 		}
3781 	}
3782 
3783 	return (dsl_destroy_snapshots_nvl(snaps, defer, outnvl));
3784 }
3785 
3786 /*
3787  * Create bookmarks. The bookmark names are of the form <fs>#<bmark>.
3788  * All bookmarks and snapshots must be in the same pool.
3789  * dsl_bookmark_create_nvl_validate describes the nvlist schema in more detail.
3790  *
3791  * innvl: {
3792  *     new_bookmark1 -> existing_snapshot,
3793  *     new_bookmark2 -> existing_bookmark,
3794  * }
3795  *
3796  * outnvl: bookmark -> error code (int32)
3797  *
3798  */
3799 static const zfs_ioc_key_t zfs_keys_bookmark[] = {
3800 	{"<bookmark>...",	DATA_TYPE_STRING,	ZK_WILDCARDLIST},
3801 };
3802 
3803 static int
3804 zfs_ioc_bookmark(const char *poolname, nvlist_t *innvl, nvlist_t *outnvl)
3805 {
3806 	(void) poolname;
3807 	return (dsl_bookmark_create(innvl, outnvl));
3808 }
3809 
3810 /*
3811  * innvl: {
3812  *     property 1, property 2, ...
3813  * }
3814  *
3815  * outnvl: {
3816  *     bookmark name 1 -> { property 1, property 2, ... },
3817  *     bookmark name 2 -> { property 1, property 2, ... }
3818  * }
3819  *
3820  */
3821 static const zfs_ioc_key_t zfs_keys_get_bookmarks[] = {
3822 	{"<property>...", DATA_TYPE_BOOLEAN, ZK_WILDCARDLIST | ZK_OPTIONAL},
3823 };
3824 
3825 static int
3826 zfs_ioc_get_bookmarks(const char *fsname, nvlist_t *innvl, nvlist_t *outnvl)
3827 {
3828 	return (dsl_get_bookmarks(fsname, innvl, outnvl));
3829 }
3830 
3831 /*
3832  * innvl is not used.
3833  *
3834  * outnvl: {
3835  *     property 1, property 2, ...
3836  * }
3837  *
3838  */
3839 static const zfs_ioc_key_t zfs_keys_get_bookmark_props[] = {
3840 	/* no nvl keys */
3841 };
3842 
3843 static int
3844 zfs_ioc_get_bookmark_props(const char *bookmark, nvlist_t *innvl,
3845     nvlist_t *outnvl)
3846 {
3847 	(void) innvl;
3848 	char fsname[ZFS_MAX_DATASET_NAME_LEN];
3849 	char *bmname;
3850 
3851 	bmname = strchr(bookmark, '#');
3852 	if (bmname == NULL)
3853 		return (SET_ERROR(EINVAL));
3854 	bmname++;
3855 
3856 	(void) strlcpy(fsname, bookmark, sizeof (fsname));
3857 	*(strchr(fsname, '#')) = '\0';
3858 
3859 	return (dsl_get_bookmark_props(fsname, bmname, outnvl));
3860 }
3861 
3862 /*
3863  * innvl: {
3864  *     bookmark name 1, bookmark name 2
3865  * }
3866  *
3867  * outnvl: bookmark -> error code (int32)
3868  *
3869  */
3870 static const zfs_ioc_key_t zfs_keys_destroy_bookmarks[] = {
3871 	{"<bookmark>...",	DATA_TYPE_BOOLEAN,	ZK_WILDCARDLIST},
3872 };
3873 
3874 static int
3875 zfs_ioc_destroy_bookmarks(const char *poolname, nvlist_t *innvl,
3876     nvlist_t *outnvl)
3877 {
3878 	int error, poollen;
3879 
3880 	poollen = strlen(poolname);
3881 	for (nvpair_t *pair = nvlist_next_nvpair(innvl, NULL);
3882 	    pair != NULL; pair = nvlist_next_nvpair(innvl, pair)) {
3883 		const char *name = nvpair_name(pair);
3884 		const char *cp = strchr(name, '#');
3885 
3886 		/*
3887 		 * The bookmark name must contain an #, and the part after it
3888 		 * must contain only valid characters.
3889 		 */
3890 		if (cp == NULL ||
3891 		    zfs_component_namecheck(cp + 1, NULL, NULL) != 0)
3892 			return (SET_ERROR(EINVAL));
3893 
3894 		/*
3895 		 * The bookmark must be in the specified pool.
3896 		 */
3897 		if (strncmp(name, poolname, poollen) != 0 ||
3898 		    (name[poollen] != '/' && name[poollen] != '#'))
3899 			return (SET_ERROR(EXDEV));
3900 	}
3901 
3902 	error = dsl_bookmark_destroy(innvl, outnvl);
3903 	return (error);
3904 }
3905 
3906 static const zfs_ioc_key_t zfs_keys_channel_program[] = {
3907 	{"program",	DATA_TYPE_STRING,		0},
3908 	{"arg",		DATA_TYPE_ANY,			0},
3909 	{"sync",	DATA_TYPE_BOOLEAN_VALUE,	ZK_OPTIONAL},
3910 	{"instrlimit",	DATA_TYPE_UINT64,		ZK_OPTIONAL},
3911 	{"memlimit",	DATA_TYPE_UINT64,		ZK_OPTIONAL},
3912 };
3913 
3914 static int
3915 zfs_ioc_channel_program(const char *poolname, nvlist_t *innvl,
3916     nvlist_t *outnvl)
3917 {
3918 	char *program;
3919 	uint64_t instrlimit, memlimit;
3920 	boolean_t sync_flag;
3921 	nvpair_t *nvarg = NULL;
3922 
3923 	program = fnvlist_lookup_string(innvl, ZCP_ARG_PROGRAM);
3924 	if (0 != nvlist_lookup_boolean_value(innvl, ZCP_ARG_SYNC, &sync_flag)) {
3925 		sync_flag = B_TRUE;
3926 	}
3927 	if (0 != nvlist_lookup_uint64(innvl, ZCP_ARG_INSTRLIMIT, &instrlimit)) {
3928 		instrlimit = ZCP_DEFAULT_INSTRLIMIT;
3929 	}
3930 	if (0 != nvlist_lookup_uint64(innvl, ZCP_ARG_MEMLIMIT, &memlimit)) {
3931 		memlimit = ZCP_DEFAULT_MEMLIMIT;
3932 	}
3933 	nvarg = fnvlist_lookup_nvpair(innvl, ZCP_ARG_ARGLIST);
3934 
3935 	if (instrlimit == 0 || instrlimit > zfs_lua_max_instrlimit)
3936 		return (SET_ERROR(EINVAL));
3937 	if (memlimit == 0 || memlimit > zfs_lua_max_memlimit)
3938 		return (SET_ERROR(EINVAL));
3939 
3940 	return (zcp_eval(poolname, program, sync_flag, instrlimit, memlimit,
3941 	    nvarg, outnvl));
3942 }
3943 
3944 /*
3945  * innvl: unused
3946  * outnvl: empty
3947  */
3948 static const zfs_ioc_key_t zfs_keys_pool_checkpoint[] = {
3949 	/* no nvl keys */
3950 };
3951 
3952 static int
3953 zfs_ioc_pool_checkpoint(const char *poolname, nvlist_t *innvl, nvlist_t *outnvl)
3954 {
3955 	(void) innvl, (void) outnvl;
3956 	return (spa_checkpoint(poolname));
3957 }
3958 
3959 /*
3960  * innvl: unused
3961  * outnvl: empty
3962  */
3963 static const zfs_ioc_key_t zfs_keys_pool_discard_checkpoint[] = {
3964 	/* no nvl keys */
3965 };
3966 
3967 static int
3968 zfs_ioc_pool_discard_checkpoint(const char *poolname, nvlist_t *innvl,
3969     nvlist_t *outnvl)
3970 {
3971 	(void) innvl, (void) outnvl;
3972 	return (spa_checkpoint_discard(poolname));
3973 }
3974 
3975 /*
3976  * inputs:
3977  * zc_name		name of dataset to destroy
3978  * zc_defer_destroy	mark for deferred destroy
3979  *
3980  * outputs:		none
3981  */
3982 static int
3983 zfs_ioc_destroy(zfs_cmd_t *zc)
3984 {
3985 	objset_t *os;
3986 	dmu_objset_type_t ost;
3987 	int err;
3988 
3989 	err = dmu_objset_hold(zc->zc_name, FTAG, &os);
3990 	if (err != 0)
3991 		return (err);
3992 	ost = dmu_objset_type(os);
3993 	dmu_objset_rele(os, FTAG);
3994 
3995 	if (ost == DMU_OST_ZFS)
3996 		zfs_unmount_snap(zc->zc_name);
3997 
3998 	if (strchr(zc->zc_name, '@')) {
3999 		err = dsl_destroy_snapshot(zc->zc_name, zc->zc_defer_destroy);
4000 	} else {
4001 		err = dsl_destroy_head(zc->zc_name);
4002 		if (err == EEXIST) {
4003 			/*
4004 			 * It is possible that the given DS may have
4005 			 * hidden child (%recv) datasets - "leftovers"
4006 			 * resulting from the previously interrupted
4007 			 * 'zfs receive'.
4008 			 *
4009 			 * 6 extra bytes for /%recv
4010 			 */
4011 			char namebuf[ZFS_MAX_DATASET_NAME_LEN + 6];
4012 
4013 			if (snprintf(namebuf, sizeof (namebuf), "%s/%s",
4014 			    zc->zc_name, recv_clone_name) >=
4015 			    sizeof (namebuf))
4016 				return (SET_ERROR(EINVAL));
4017 
4018 			/*
4019 			 * Try to remove the hidden child (%recv) and after
4020 			 * that try to remove the target dataset.
4021 			 * If the hidden child (%recv) does not exist
4022 			 * the original error (EEXIST) will be returned
4023 			 */
4024 			err = dsl_destroy_head(namebuf);
4025 			if (err == 0)
4026 				err = dsl_destroy_head(zc->zc_name);
4027 			else if (err == ENOENT)
4028 				err = SET_ERROR(EEXIST);
4029 		}
4030 	}
4031 
4032 	return (err);
4033 }
4034 
4035 /*
4036  * innvl: {
4037  *     "initialize_command" -> POOL_INITIALIZE_{CANCEL|START|SUSPEND} (uint64)
4038  *     "initialize_vdevs": { -> guids to initialize (nvlist)
4039  *         "vdev_path_1": vdev_guid_1, (uint64),
4040  *         "vdev_path_2": vdev_guid_2, (uint64),
4041  *         ...
4042  *     },
4043  * }
4044  *
4045  * outnvl: {
4046  *     "initialize_vdevs": { -> initialization errors (nvlist)
4047  *         "vdev_path_1": errno, see function body for possible errnos (uint64)
4048  *         "vdev_path_2": errno, ... (uint64)
4049  *         ...
4050  *     }
4051  * }
4052  *
4053  * EINVAL is returned for an unknown commands or if any of the provided vdev
4054  * guids have be specified with a type other than uint64.
4055  */
4056 static const zfs_ioc_key_t zfs_keys_pool_initialize[] = {
4057 	{ZPOOL_INITIALIZE_COMMAND,	DATA_TYPE_UINT64,	0},
4058 	{ZPOOL_INITIALIZE_VDEVS,	DATA_TYPE_NVLIST,	0}
4059 };
4060 
4061 static int
4062 zfs_ioc_pool_initialize(const char *poolname, nvlist_t *innvl, nvlist_t *outnvl)
4063 {
4064 	uint64_t cmd_type;
4065 	if (nvlist_lookup_uint64(innvl, ZPOOL_INITIALIZE_COMMAND,
4066 	    &cmd_type) != 0) {
4067 		return (SET_ERROR(EINVAL));
4068 	}
4069 
4070 	if (!(cmd_type == POOL_INITIALIZE_CANCEL ||
4071 	    cmd_type == POOL_INITIALIZE_START ||
4072 	    cmd_type == POOL_INITIALIZE_SUSPEND)) {
4073 		return (SET_ERROR(EINVAL));
4074 	}
4075 
4076 	nvlist_t *vdev_guids;
4077 	if (nvlist_lookup_nvlist(innvl, ZPOOL_INITIALIZE_VDEVS,
4078 	    &vdev_guids) != 0) {
4079 		return (SET_ERROR(EINVAL));
4080 	}
4081 
4082 	for (nvpair_t *pair = nvlist_next_nvpair(vdev_guids, NULL);
4083 	    pair != NULL; pair = nvlist_next_nvpair(vdev_guids, pair)) {
4084 		uint64_t vdev_guid;
4085 		if (nvpair_value_uint64(pair, &vdev_guid) != 0) {
4086 			return (SET_ERROR(EINVAL));
4087 		}
4088 	}
4089 
4090 	spa_t *spa;
4091 	int error = spa_open(poolname, &spa, FTAG);
4092 	if (error != 0)
4093 		return (error);
4094 
4095 	nvlist_t *vdev_errlist = fnvlist_alloc();
4096 	int total_errors = spa_vdev_initialize(spa, vdev_guids, cmd_type,
4097 	    vdev_errlist);
4098 
4099 	if (fnvlist_size(vdev_errlist) > 0) {
4100 		fnvlist_add_nvlist(outnvl, ZPOOL_INITIALIZE_VDEVS,
4101 		    vdev_errlist);
4102 	}
4103 	fnvlist_free(vdev_errlist);
4104 
4105 	spa_close(spa, FTAG);
4106 	return (total_errors > 0 ? SET_ERROR(EINVAL) : 0);
4107 }
4108 
4109 /*
4110  * innvl: {
4111  *     "trim_command" -> POOL_TRIM_{CANCEL|START|SUSPEND} (uint64)
4112  *     "trim_vdevs": { -> guids to TRIM (nvlist)
4113  *         "vdev_path_1": vdev_guid_1, (uint64),
4114  *         "vdev_path_2": vdev_guid_2, (uint64),
4115  *         ...
4116  *     },
4117  *     "trim_rate" -> Target TRIM rate in bytes/sec.
4118  *     "trim_secure" -> Set to request a secure TRIM.
4119  * }
4120  *
4121  * outnvl: {
4122  *     "trim_vdevs": { -> TRIM errors (nvlist)
4123  *         "vdev_path_1": errno, see function body for possible errnos (uint64)
4124  *         "vdev_path_2": errno, ... (uint64)
4125  *         ...
4126  *     }
4127  * }
4128  *
4129  * EINVAL is returned for an unknown commands or if any of the provided vdev
4130  * guids have be specified with a type other than uint64.
4131  */
4132 static const zfs_ioc_key_t zfs_keys_pool_trim[] = {
4133 	{ZPOOL_TRIM_COMMAND,	DATA_TYPE_UINT64,		0},
4134 	{ZPOOL_TRIM_VDEVS,	DATA_TYPE_NVLIST,		0},
4135 	{ZPOOL_TRIM_RATE,	DATA_TYPE_UINT64,		ZK_OPTIONAL},
4136 	{ZPOOL_TRIM_SECURE,	DATA_TYPE_BOOLEAN_VALUE,	ZK_OPTIONAL},
4137 };
4138 
4139 static int
4140 zfs_ioc_pool_trim(const char *poolname, nvlist_t *innvl, nvlist_t *outnvl)
4141 {
4142 	uint64_t cmd_type;
4143 	if (nvlist_lookup_uint64(innvl, ZPOOL_TRIM_COMMAND, &cmd_type) != 0)
4144 		return (SET_ERROR(EINVAL));
4145 
4146 	if (!(cmd_type == POOL_TRIM_CANCEL ||
4147 	    cmd_type == POOL_TRIM_START ||
4148 	    cmd_type == POOL_TRIM_SUSPEND)) {
4149 		return (SET_ERROR(EINVAL));
4150 	}
4151 
4152 	nvlist_t *vdev_guids;
4153 	if (nvlist_lookup_nvlist(innvl, ZPOOL_TRIM_VDEVS, &vdev_guids) != 0)
4154 		return (SET_ERROR(EINVAL));
4155 
4156 	for (nvpair_t *pair = nvlist_next_nvpair(vdev_guids, NULL);
4157 	    pair != NULL; pair = nvlist_next_nvpair(vdev_guids, pair)) {
4158 		uint64_t vdev_guid;
4159 		if (nvpair_value_uint64(pair, &vdev_guid) != 0) {
4160 			return (SET_ERROR(EINVAL));
4161 		}
4162 	}
4163 
4164 	/* Optional, defaults to maximum rate when not provided */
4165 	uint64_t rate;
4166 	if (nvlist_lookup_uint64(innvl, ZPOOL_TRIM_RATE, &rate) != 0)
4167 		rate = 0;
4168 
4169 	/* Optional, defaults to standard TRIM when not provided */
4170 	boolean_t secure;
4171 	if (nvlist_lookup_boolean_value(innvl, ZPOOL_TRIM_SECURE,
4172 	    &secure) != 0) {
4173 		secure = B_FALSE;
4174 	}
4175 
4176 	spa_t *spa;
4177 	int error = spa_open(poolname, &spa, FTAG);
4178 	if (error != 0)
4179 		return (error);
4180 
4181 	nvlist_t *vdev_errlist = fnvlist_alloc();
4182 	int total_errors = spa_vdev_trim(spa, vdev_guids, cmd_type,
4183 	    rate, !!zfs_trim_metaslab_skip, secure, vdev_errlist);
4184 
4185 	if (fnvlist_size(vdev_errlist) > 0)
4186 		fnvlist_add_nvlist(outnvl, ZPOOL_TRIM_VDEVS, vdev_errlist);
4187 
4188 	fnvlist_free(vdev_errlist);
4189 
4190 	spa_close(spa, FTAG);
4191 	return (total_errors > 0 ? SET_ERROR(EINVAL) : 0);
4192 }
4193 
4194 /*
4195  * This ioctl waits for activity of a particular type to complete. If there is
4196  * no activity of that type in progress, it returns immediately, and the
4197  * returned value "waited" is false. If there is activity in progress, and no
4198  * tag is passed in, the ioctl blocks until all activity of that type is
4199  * complete, and then returns with "waited" set to true.
4200  *
4201  * If a tag is provided, it identifies a particular instance of an activity to
4202  * wait for. Currently, this is only valid for use with 'initialize', because
4203  * that is the only activity for which there can be multiple instances running
4204  * concurrently. In the case of 'initialize', the tag corresponds to the guid of
4205  * the vdev on which to wait.
4206  *
4207  * If a thread waiting in the ioctl receives a signal, the call will return
4208  * immediately, and the return value will be EINTR.
4209  *
4210  * innvl: {
4211  *     "wait_activity" -> int32_t
4212  *     (optional) "wait_tag" -> uint64_t
4213  * }
4214  *
4215  * outnvl: "waited" -> boolean_t
4216  */
4217 static const zfs_ioc_key_t zfs_keys_pool_wait[] = {
4218 	{ZPOOL_WAIT_ACTIVITY,	DATA_TYPE_INT32,		0},
4219 	{ZPOOL_WAIT_TAG,	DATA_TYPE_UINT64,		ZK_OPTIONAL},
4220 };
4221 
4222 static int
4223 zfs_ioc_wait(const char *name, nvlist_t *innvl, nvlist_t *outnvl)
4224 {
4225 	int32_t activity;
4226 	uint64_t tag;
4227 	boolean_t waited;
4228 	int error;
4229 
4230 	if (nvlist_lookup_int32(innvl, ZPOOL_WAIT_ACTIVITY, &activity) != 0)
4231 		return (EINVAL);
4232 
4233 	if (nvlist_lookup_uint64(innvl, ZPOOL_WAIT_TAG, &tag) == 0)
4234 		error = spa_wait_tag(name, activity, tag, &waited);
4235 	else
4236 		error = spa_wait(name, activity, &waited);
4237 
4238 	if (error == 0)
4239 		fnvlist_add_boolean_value(outnvl, ZPOOL_WAIT_WAITED, waited);
4240 
4241 	return (error);
4242 }
4243 
4244 /*
4245  * This ioctl waits for activity of a particular type to complete. If there is
4246  * no activity of that type in progress, it returns immediately, and the
4247  * returned value "waited" is false. If there is activity in progress, and no
4248  * tag is passed in, the ioctl blocks until all activity of that type is
4249  * complete, and then returns with "waited" set to true.
4250  *
4251  * If a thread waiting in the ioctl receives a signal, the call will return
4252  * immediately, and the return value will be EINTR.
4253  *
4254  * innvl: {
4255  *     "wait_activity" -> int32_t
4256  * }
4257  *
4258  * outnvl: "waited" -> boolean_t
4259  */
4260 static const zfs_ioc_key_t zfs_keys_fs_wait[] = {
4261 	{ZFS_WAIT_ACTIVITY,	DATA_TYPE_INT32,		0},
4262 };
4263 
4264 static int
4265 zfs_ioc_wait_fs(const char *name, nvlist_t *innvl, nvlist_t *outnvl)
4266 {
4267 	int32_t activity;
4268 	boolean_t waited = B_FALSE;
4269 	int error;
4270 	dsl_pool_t *dp;
4271 	dsl_dir_t *dd;
4272 	dsl_dataset_t *ds;
4273 
4274 	if (nvlist_lookup_int32(innvl, ZFS_WAIT_ACTIVITY, &activity) != 0)
4275 		return (SET_ERROR(EINVAL));
4276 
4277 	if (activity >= ZFS_WAIT_NUM_ACTIVITIES || activity < 0)
4278 		return (SET_ERROR(EINVAL));
4279 
4280 	if ((error = dsl_pool_hold(name, FTAG, &dp)) != 0)
4281 		return (error);
4282 
4283 	if ((error = dsl_dataset_hold(dp, name, FTAG, &ds)) != 0) {
4284 		dsl_pool_rele(dp, FTAG);
4285 		return (error);
4286 	}
4287 
4288 	dd = ds->ds_dir;
4289 	mutex_enter(&dd->dd_activity_lock);
4290 	dd->dd_activity_waiters++;
4291 
4292 	/*
4293 	 * We get a long-hold here so that the dsl_dataset_t and dsl_dir_t
4294 	 * aren't evicted while we're waiting. Normally this is prevented by
4295 	 * holding the pool, but we can't do that while we're waiting since
4296 	 * that would prevent TXGs from syncing out. Some of the functionality
4297 	 * of long-holds (e.g. preventing deletion) is unnecessary for this
4298 	 * case, since we would cancel the waiters before proceeding with a
4299 	 * deletion. An alternative mechanism for keeping the dataset around
4300 	 * could be developed but this is simpler.
4301 	 */
4302 	dsl_dataset_long_hold(ds, FTAG);
4303 	dsl_pool_rele(dp, FTAG);
4304 
4305 	error = dsl_dir_wait(dd, ds, activity, &waited);
4306 
4307 	dsl_dataset_long_rele(ds, FTAG);
4308 	dd->dd_activity_waiters--;
4309 	if (dd->dd_activity_waiters == 0)
4310 		cv_signal(&dd->dd_activity_cv);
4311 	mutex_exit(&dd->dd_activity_lock);
4312 
4313 	dsl_dataset_rele(ds, FTAG);
4314 
4315 	if (error == 0)
4316 		fnvlist_add_boolean_value(outnvl, ZFS_WAIT_WAITED, waited);
4317 
4318 	return (error);
4319 }
4320 
4321 /*
4322  * fsname is name of dataset to rollback (to most recent snapshot)
4323  *
4324  * innvl may contain name of expected target snapshot
4325  *
4326  * outnvl: "target" -> name of most recent snapshot
4327  * }
4328  */
4329 static const zfs_ioc_key_t zfs_keys_rollback[] = {
4330 	{"target",	DATA_TYPE_STRING,	ZK_OPTIONAL},
4331 };
4332 
4333 static int
4334 zfs_ioc_rollback(const char *fsname, nvlist_t *innvl, nvlist_t *outnvl)
4335 {
4336 	zfsvfs_t *zfsvfs;
4337 	zvol_state_handle_t *zv;
4338 	char *target = NULL;
4339 	int error;
4340 
4341 	(void) nvlist_lookup_string(innvl, "target", &target);
4342 	if (target != NULL) {
4343 		const char *cp = strchr(target, '@');
4344 
4345 		/*
4346 		 * The snap name must contain an @, and the part after it must
4347 		 * contain only valid characters.
4348 		 */
4349 		if (cp == NULL ||
4350 		    zfs_component_namecheck(cp + 1, NULL, NULL) != 0)
4351 			return (SET_ERROR(EINVAL));
4352 	}
4353 
4354 	if (getzfsvfs(fsname, &zfsvfs) == 0) {
4355 		dsl_dataset_t *ds;
4356 
4357 		ds = dmu_objset_ds(zfsvfs->z_os);
4358 		error = zfs_suspend_fs(zfsvfs);
4359 		if (error == 0) {
4360 			int resume_err;
4361 
4362 			error = dsl_dataset_rollback(fsname, target, zfsvfs,
4363 			    outnvl);
4364 			resume_err = zfs_resume_fs(zfsvfs, ds);
4365 			error = error ? error : resume_err;
4366 		}
4367 		zfs_vfs_rele(zfsvfs);
4368 	} else if ((zv = zvol_suspend(fsname)) != NULL) {
4369 		error = dsl_dataset_rollback(fsname, target, zvol_tag(zv),
4370 		    outnvl);
4371 		zvol_resume(zv);
4372 	} else {
4373 		error = dsl_dataset_rollback(fsname, target, NULL, outnvl);
4374 	}
4375 	return (error);
4376 }
4377 
4378 static int
4379 recursive_unmount(const char *fsname, void *arg)
4380 {
4381 	const char *snapname = arg;
4382 	char *fullname;
4383 
4384 	fullname = kmem_asprintf("%s@%s", fsname, snapname);
4385 	zfs_unmount_snap(fullname);
4386 	kmem_strfree(fullname);
4387 
4388 	return (0);
4389 }
4390 
4391 /*
4392  *
4393  * snapname is the snapshot to redact.
4394  * innvl: {
4395  *     "bookname" -> (string)
4396  *         shortname of the redaction bookmark to generate
4397  *     "snapnv" -> (nvlist, values ignored)
4398  *         snapshots to redact snapname with respect to
4399  * }
4400  *
4401  * outnvl is unused
4402  */
4403 
4404 static const zfs_ioc_key_t zfs_keys_redact[] = {
4405 	{"bookname",		DATA_TYPE_STRING,	0},
4406 	{"snapnv",		DATA_TYPE_NVLIST,	0},
4407 };
4408 
4409 static int
4410 zfs_ioc_redact(const char *snapname, nvlist_t *innvl, nvlist_t *outnvl)
4411 {
4412 	(void) outnvl;
4413 	nvlist_t *redactnvl = NULL;
4414 	char *redactbook = NULL;
4415 
4416 	if (nvlist_lookup_nvlist(innvl, "snapnv", &redactnvl) != 0)
4417 		return (SET_ERROR(EINVAL));
4418 	if (fnvlist_num_pairs(redactnvl) == 0)
4419 		return (SET_ERROR(ENXIO));
4420 	if (nvlist_lookup_string(innvl, "bookname", &redactbook) != 0)
4421 		return (SET_ERROR(EINVAL));
4422 
4423 	return (dmu_redact_snap(snapname, redactnvl, redactbook));
4424 }
4425 
4426 /*
4427  * inputs:
4428  * zc_name	old name of dataset
4429  * zc_value	new name of dataset
4430  * zc_cookie	recursive flag (only valid for snapshots)
4431  *
4432  * outputs:	none
4433  */
4434 static int
4435 zfs_ioc_rename(zfs_cmd_t *zc)
4436 {
4437 	objset_t *os;
4438 	dmu_objset_type_t ost;
4439 	boolean_t recursive = zc->zc_cookie & 1;
4440 	boolean_t nounmount = !!(zc->zc_cookie & 2);
4441 	char *at;
4442 	int err;
4443 
4444 	/* "zfs rename" from and to ...%recv datasets should both fail */
4445 	zc->zc_name[sizeof (zc->zc_name) - 1] = '\0';
4446 	zc->zc_value[sizeof (zc->zc_value) - 1] = '\0';
4447 	if (dataset_namecheck(zc->zc_name, NULL, NULL) != 0 ||
4448 	    dataset_namecheck(zc->zc_value, NULL, NULL) != 0 ||
4449 	    strchr(zc->zc_name, '%') || strchr(zc->zc_value, '%'))
4450 		return (SET_ERROR(EINVAL));
4451 
4452 	err = dmu_objset_hold(zc->zc_name, FTAG, &os);
4453 	if (err != 0)
4454 		return (err);
4455 	ost = dmu_objset_type(os);
4456 	dmu_objset_rele(os, FTAG);
4457 
4458 	at = strchr(zc->zc_name, '@');
4459 	if (at != NULL) {
4460 		/* snaps must be in same fs */
4461 		int error;
4462 
4463 		if (strncmp(zc->zc_name, zc->zc_value, at - zc->zc_name + 1))
4464 			return (SET_ERROR(EXDEV));
4465 		*at = '\0';
4466 		if (ost == DMU_OST_ZFS && !nounmount) {
4467 			error = dmu_objset_find(zc->zc_name,
4468 			    recursive_unmount, at + 1,
4469 			    recursive ? DS_FIND_CHILDREN : 0);
4470 			if (error != 0) {
4471 				*at = '@';
4472 				return (error);
4473 			}
4474 		}
4475 		error = dsl_dataset_rename_snapshot(zc->zc_name,
4476 		    at + 1, strchr(zc->zc_value, '@') + 1, recursive);
4477 		*at = '@';
4478 
4479 		return (error);
4480 	} else {
4481 		return (dsl_dir_rename(zc->zc_name, zc->zc_value));
4482 	}
4483 }
4484 
4485 static int
4486 zfs_check_settable(const char *dsname, nvpair_t *pair, cred_t *cr)
4487 {
4488 	const char *propname = nvpair_name(pair);
4489 	boolean_t issnap = (strchr(dsname, '@') != NULL);
4490 	zfs_prop_t prop = zfs_name_to_prop(propname);
4491 	uint64_t intval, compval;
4492 	int err;
4493 
4494 	if (prop == ZPROP_USERPROP) {
4495 		if (zfs_prop_user(propname)) {
4496 			if ((err = zfs_secpolicy_write_perms(dsname,
4497 			    ZFS_DELEG_PERM_USERPROP, cr)))
4498 				return (err);
4499 			return (0);
4500 		}
4501 
4502 		if (!issnap && zfs_prop_userquota(propname)) {
4503 			const char *perm = NULL;
4504 			const char *uq_prefix =
4505 			    zfs_userquota_prop_prefixes[ZFS_PROP_USERQUOTA];
4506 			const char *gq_prefix =
4507 			    zfs_userquota_prop_prefixes[ZFS_PROP_GROUPQUOTA];
4508 			const char *uiq_prefix =
4509 			    zfs_userquota_prop_prefixes[ZFS_PROP_USEROBJQUOTA];
4510 			const char *giq_prefix =
4511 			    zfs_userquota_prop_prefixes[ZFS_PROP_GROUPOBJQUOTA];
4512 			const char *pq_prefix =
4513 			    zfs_userquota_prop_prefixes[ZFS_PROP_PROJECTQUOTA];
4514 			const char *piq_prefix = zfs_userquota_prop_prefixes[\
4515 			    ZFS_PROP_PROJECTOBJQUOTA];
4516 
4517 			if (strncmp(propname, uq_prefix,
4518 			    strlen(uq_prefix)) == 0) {
4519 				perm = ZFS_DELEG_PERM_USERQUOTA;
4520 			} else if (strncmp(propname, uiq_prefix,
4521 			    strlen(uiq_prefix)) == 0) {
4522 				perm = ZFS_DELEG_PERM_USEROBJQUOTA;
4523 			} else if (strncmp(propname, gq_prefix,
4524 			    strlen(gq_prefix)) == 0) {
4525 				perm = ZFS_DELEG_PERM_GROUPQUOTA;
4526 			} else if (strncmp(propname, giq_prefix,
4527 			    strlen(giq_prefix)) == 0) {
4528 				perm = ZFS_DELEG_PERM_GROUPOBJQUOTA;
4529 			} else if (strncmp(propname, pq_prefix,
4530 			    strlen(pq_prefix)) == 0) {
4531 				perm = ZFS_DELEG_PERM_PROJECTQUOTA;
4532 			} else if (strncmp(propname, piq_prefix,
4533 			    strlen(piq_prefix)) == 0) {
4534 				perm = ZFS_DELEG_PERM_PROJECTOBJQUOTA;
4535 			} else {
4536 				/* {USER|GROUP|PROJECT}USED are read-only */
4537 				return (SET_ERROR(EINVAL));
4538 			}
4539 
4540 			if ((err = zfs_secpolicy_write_perms(dsname, perm, cr)))
4541 				return (err);
4542 			return (0);
4543 		}
4544 
4545 		return (SET_ERROR(EINVAL));
4546 	}
4547 
4548 	if (issnap)
4549 		return (SET_ERROR(EINVAL));
4550 
4551 	if (nvpair_type(pair) == DATA_TYPE_NVLIST) {
4552 		/*
4553 		 * dsl_prop_get_all_impl() returns properties in this
4554 		 * format.
4555 		 */
4556 		nvlist_t *attrs;
4557 		VERIFY(nvpair_value_nvlist(pair, &attrs) == 0);
4558 		VERIFY(nvlist_lookup_nvpair(attrs, ZPROP_VALUE,
4559 		    &pair) == 0);
4560 	}
4561 
4562 	/*
4563 	 * Check that this value is valid for this pool version
4564 	 */
4565 	switch (prop) {
4566 	case ZFS_PROP_COMPRESSION:
4567 		/*
4568 		 * If the user specified gzip compression, make sure
4569 		 * the SPA supports it. We ignore any errors here since
4570 		 * we'll catch them later.
4571 		 */
4572 		if (nvpair_value_uint64(pair, &intval) == 0) {
4573 			compval = ZIO_COMPRESS_ALGO(intval);
4574 			if (compval >= ZIO_COMPRESS_GZIP_1 &&
4575 			    compval <= ZIO_COMPRESS_GZIP_9 &&
4576 			    zfs_earlier_version(dsname,
4577 			    SPA_VERSION_GZIP_COMPRESSION)) {
4578 				return (SET_ERROR(ENOTSUP));
4579 			}
4580 
4581 			if (compval == ZIO_COMPRESS_ZLE &&
4582 			    zfs_earlier_version(dsname,
4583 			    SPA_VERSION_ZLE_COMPRESSION))
4584 				return (SET_ERROR(ENOTSUP));
4585 
4586 			if (compval == ZIO_COMPRESS_LZ4) {
4587 				spa_t *spa;
4588 
4589 				if ((err = spa_open(dsname, &spa, FTAG)) != 0)
4590 					return (err);
4591 
4592 				if (!spa_feature_is_enabled(spa,
4593 				    SPA_FEATURE_LZ4_COMPRESS)) {
4594 					spa_close(spa, FTAG);
4595 					return (SET_ERROR(ENOTSUP));
4596 				}
4597 				spa_close(spa, FTAG);
4598 			}
4599 
4600 			if (compval == ZIO_COMPRESS_ZSTD) {
4601 				spa_t *spa;
4602 
4603 				if ((err = spa_open(dsname, &spa, FTAG)) != 0)
4604 					return (err);
4605 
4606 				if (!spa_feature_is_enabled(spa,
4607 				    SPA_FEATURE_ZSTD_COMPRESS)) {
4608 					spa_close(spa, FTAG);
4609 					return (SET_ERROR(ENOTSUP));
4610 				}
4611 				spa_close(spa, FTAG);
4612 			}
4613 		}
4614 		break;
4615 
4616 	case ZFS_PROP_COPIES:
4617 		if (zfs_earlier_version(dsname, SPA_VERSION_DITTO_BLOCKS))
4618 			return (SET_ERROR(ENOTSUP));
4619 		break;
4620 
4621 	case ZFS_PROP_VOLBLOCKSIZE:
4622 	case ZFS_PROP_RECORDSIZE:
4623 		/* Record sizes above 128k need the feature to be enabled */
4624 		if (nvpair_value_uint64(pair, &intval) == 0 &&
4625 		    intval > SPA_OLD_MAXBLOCKSIZE) {
4626 			spa_t *spa;
4627 
4628 			/*
4629 			 * We don't allow setting the property above 1MB,
4630 			 * unless the tunable has been changed.
4631 			 */
4632 			if (intval > zfs_max_recordsize ||
4633 			    intval > SPA_MAXBLOCKSIZE)
4634 				return (SET_ERROR(ERANGE));
4635 
4636 			if ((err = spa_open(dsname, &spa, FTAG)) != 0)
4637 				return (err);
4638 
4639 			if (!spa_feature_is_enabled(spa,
4640 			    SPA_FEATURE_LARGE_BLOCKS)) {
4641 				spa_close(spa, FTAG);
4642 				return (SET_ERROR(ENOTSUP));
4643 			}
4644 			spa_close(spa, FTAG);
4645 		}
4646 		break;
4647 
4648 	case ZFS_PROP_DNODESIZE:
4649 		/* Dnode sizes above 512 need the feature to be enabled */
4650 		if (nvpair_value_uint64(pair, &intval) == 0 &&
4651 		    intval != ZFS_DNSIZE_LEGACY) {
4652 			spa_t *spa;
4653 
4654 			if ((err = spa_open(dsname, &spa, FTAG)) != 0)
4655 				return (err);
4656 
4657 			if (!spa_feature_is_enabled(spa,
4658 			    SPA_FEATURE_LARGE_DNODE)) {
4659 				spa_close(spa, FTAG);
4660 				return (SET_ERROR(ENOTSUP));
4661 			}
4662 			spa_close(spa, FTAG);
4663 		}
4664 		break;
4665 
4666 	case ZFS_PROP_SPECIAL_SMALL_BLOCKS:
4667 		/*
4668 		 * This property could require the allocation classes
4669 		 * feature to be active for setting, however we allow
4670 		 * it so that tests of settable properties succeed.
4671 		 * The CLI will issue a warning in this case.
4672 		 */
4673 		break;
4674 
4675 	case ZFS_PROP_SHARESMB:
4676 		if (zpl_earlier_version(dsname, ZPL_VERSION_FUID))
4677 			return (SET_ERROR(ENOTSUP));
4678 		break;
4679 
4680 	case ZFS_PROP_ACLINHERIT:
4681 		if (nvpair_type(pair) == DATA_TYPE_UINT64 &&
4682 		    nvpair_value_uint64(pair, &intval) == 0) {
4683 			if (intval == ZFS_ACL_PASSTHROUGH_X &&
4684 			    zfs_earlier_version(dsname,
4685 			    SPA_VERSION_PASSTHROUGH_X))
4686 				return (SET_ERROR(ENOTSUP));
4687 		}
4688 		break;
4689 	case ZFS_PROP_CHECKSUM:
4690 	case ZFS_PROP_DEDUP:
4691 	{
4692 		spa_feature_t feature;
4693 		spa_t *spa;
4694 		int err;
4695 
4696 		/* dedup feature version checks */
4697 		if (prop == ZFS_PROP_DEDUP &&
4698 		    zfs_earlier_version(dsname, SPA_VERSION_DEDUP))
4699 			return (SET_ERROR(ENOTSUP));
4700 
4701 		if (nvpair_type(pair) == DATA_TYPE_UINT64 &&
4702 		    nvpair_value_uint64(pair, &intval) == 0) {
4703 			/* check prop value is enabled in features */
4704 			feature = zio_checksum_to_feature(
4705 			    intval & ZIO_CHECKSUM_MASK);
4706 			if (feature == SPA_FEATURE_NONE)
4707 				break;
4708 
4709 			if ((err = spa_open(dsname, &spa, FTAG)) != 0)
4710 				return (err);
4711 
4712 			if (!spa_feature_is_enabled(spa, feature)) {
4713 				spa_close(spa, FTAG);
4714 				return (SET_ERROR(ENOTSUP));
4715 			}
4716 			spa_close(spa, FTAG);
4717 		}
4718 		break;
4719 	}
4720 
4721 	default:
4722 		break;
4723 	}
4724 
4725 	return (zfs_secpolicy_setprop(dsname, prop, pair, CRED()));
4726 }
4727 
4728 /*
4729  * Removes properties from the given props list that fail permission checks
4730  * needed to clear them and to restore them in case of a receive error. For each
4731  * property, make sure we have both set and inherit permissions.
4732  *
4733  * Returns the first error encountered if any permission checks fail. If the
4734  * caller provides a non-NULL errlist, it also gives the complete list of names
4735  * of all the properties that failed a permission check along with the
4736  * corresponding error numbers. The caller is responsible for freeing the
4737  * returned errlist.
4738  *
4739  * If every property checks out successfully, zero is returned and the list
4740  * pointed at by errlist is NULL.
4741  */
4742 static int
4743 zfs_check_clearable(const char *dataset, nvlist_t *props, nvlist_t **errlist)
4744 {
4745 	zfs_cmd_t *zc;
4746 	nvpair_t *pair, *next_pair;
4747 	nvlist_t *errors;
4748 	int err, rv = 0;
4749 
4750 	if (props == NULL)
4751 		return (0);
4752 
4753 	VERIFY(nvlist_alloc(&errors, NV_UNIQUE_NAME, KM_SLEEP) == 0);
4754 
4755 	zc = kmem_alloc(sizeof (zfs_cmd_t), KM_SLEEP);
4756 	(void) strlcpy(zc->zc_name, dataset, sizeof (zc->zc_name));
4757 	pair = nvlist_next_nvpair(props, NULL);
4758 	while (pair != NULL) {
4759 		next_pair = nvlist_next_nvpair(props, pair);
4760 
4761 		(void) strlcpy(zc->zc_value, nvpair_name(pair),
4762 		    sizeof (zc->zc_value));
4763 		if ((err = zfs_check_settable(dataset, pair, CRED())) != 0 ||
4764 		    (err = zfs_secpolicy_inherit_prop(zc, NULL, CRED())) != 0) {
4765 			VERIFY(nvlist_remove_nvpair(props, pair) == 0);
4766 			VERIFY(nvlist_add_int32(errors,
4767 			    zc->zc_value, err) == 0);
4768 		}
4769 		pair = next_pair;
4770 	}
4771 	kmem_free(zc, sizeof (zfs_cmd_t));
4772 
4773 	if ((pair = nvlist_next_nvpair(errors, NULL)) == NULL) {
4774 		nvlist_free(errors);
4775 		errors = NULL;
4776 	} else {
4777 		VERIFY(nvpair_value_int32(pair, &rv) == 0);
4778 	}
4779 
4780 	if (errlist == NULL)
4781 		nvlist_free(errors);
4782 	else
4783 		*errlist = errors;
4784 
4785 	return (rv);
4786 }
4787 
4788 static boolean_t
4789 propval_equals(nvpair_t *p1, nvpair_t *p2)
4790 {
4791 	if (nvpair_type(p1) == DATA_TYPE_NVLIST) {
4792 		/* dsl_prop_get_all_impl() format */
4793 		nvlist_t *attrs;
4794 		VERIFY(nvpair_value_nvlist(p1, &attrs) == 0);
4795 		VERIFY(nvlist_lookup_nvpair(attrs, ZPROP_VALUE,
4796 		    &p1) == 0);
4797 	}
4798 
4799 	if (nvpair_type(p2) == DATA_TYPE_NVLIST) {
4800 		nvlist_t *attrs;
4801 		VERIFY(nvpair_value_nvlist(p2, &attrs) == 0);
4802 		VERIFY(nvlist_lookup_nvpair(attrs, ZPROP_VALUE,
4803 		    &p2) == 0);
4804 	}
4805 
4806 	if (nvpair_type(p1) != nvpair_type(p2))
4807 		return (B_FALSE);
4808 
4809 	if (nvpair_type(p1) == DATA_TYPE_STRING) {
4810 		char *valstr1, *valstr2;
4811 
4812 		VERIFY(nvpair_value_string(p1, (char **)&valstr1) == 0);
4813 		VERIFY(nvpair_value_string(p2, (char **)&valstr2) == 0);
4814 		return (strcmp(valstr1, valstr2) == 0);
4815 	} else {
4816 		uint64_t intval1, intval2;
4817 
4818 		VERIFY(nvpair_value_uint64(p1, &intval1) == 0);
4819 		VERIFY(nvpair_value_uint64(p2, &intval2) == 0);
4820 		return (intval1 == intval2);
4821 	}
4822 }
4823 
4824 /*
4825  * Remove properties from props if they are not going to change (as determined
4826  * by comparison with origprops). Remove them from origprops as well, since we
4827  * do not need to clear or restore properties that won't change.
4828  */
4829 static void
4830 props_reduce(nvlist_t *props, nvlist_t *origprops)
4831 {
4832 	nvpair_t *pair, *next_pair;
4833 
4834 	if (origprops == NULL)
4835 		return; /* all props need to be received */
4836 
4837 	pair = nvlist_next_nvpair(props, NULL);
4838 	while (pair != NULL) {
4839 		const char *propname = nvpair_name(pair);
4840 		nvpair_t *match;
4841 
4842 		next_pair = nvlist_next_nvpair(props, pair);
4843 
4844 		if ((nvlist_lookup_nvpair(origprops, propname,
4845 		    &match) != 0) || !propval_equals(pair, match))
4846 			goto next; /* need to set received value */
4847 
4848 		/* don't clear the existing received value */
4849 		(void) nvlist_remove_nvpair(origprops, match);
4850 		/* don't bother receiving the property */
4851 		(void) nvlist_remove_nvpair(props, pair);
4852 next:
4853 		pair = next_pair;
4854 	}
4855 }
4856 
4857 /*
4858  * Extract properties that cannot be set PRIOR to the receipt of a dataset.
4859  * For example, refquota cannot be set until after the receipt of a dataset,
4860  * because in replication streams, an older/earlier snapshot may exceed the
4861  * refquota.  We want to receive the older/earlier snapshot, but setting
4862  * refquota pre-receipt will set the dsl's ACTUAL quota, which will prevent
4863  * the older/earlier snapshot from being received (with EDQUOT).
4864  *
4865  * The ZFS test "zfs_receive_011_pos" demonstrates such a scenario.
4866  *
4867  * libzfs will need to be judicious handling errors encountered by props
4868  * extracted by this function.
4869  */
4870 static nvlist_t *
4871 extract_delay_props(nvlist_t *props)
4872 {
4873 	nvlist_t *delayprops;
4874 	nvpair_t *nvp, *tmp;
4875 	static const zfs_prop_t delayable[] = {
4876 		ZFS_PROP_REFQUOTA,
4877 		ZFS_PROP_KEYLOCATION,
4878 		/*
4879 		 * Setting ZFS_PROP_SHARESMB requires the objset type to be
4880 		 * known, which is not possible prior to receipt of raw sends.
4881 		 */
4882 		ZFS_PROP_SHARESMB,
4883 		0
4884 	};
4885 	int i;
4886 
4887 	VERIFY(nvlist_alloc(&delayprops, NV_UNIQUE_NAME, KM_SLEEP) == 0);
4888 
4889 	for (nvp = nvlist_next_nvpair(props, NULL); nvp != NULL;
4890 	    nvp = nvlist_next_nvpair(props, nvp)) {
4891 		/*
4892 		 * strcmp() is safe because zfs_prop_to_name() always returns
4893 		 * a bounded string.
4894 		 */
4895 		for (i = 0; delayable[i] != 0; i++) {
4896 			if (strcmp(zfs_prop_to_name(delayable[i]),
4897 			    nvpair_name(nvp)) == 0) {
4898 				break;
4899 			}
4900 		}
4901 		if (delayable[i] != 0) {
4902 			tmp = nvlist_prev_nvpair(props, nvp);
4903 			VERIFY(nvlist_add_nvpair(delayprops, nvp) == 0);
4904 			VERIFY(nvlist_remove_nvpair(props, nvp) == 0);
4905 			nvp = tmp;
4906 		}
4907 	}
4908 
4909 	if (nvlist_empty(delayprops)) {
4910 		nvlist_free(delayprops);
4911 		delayprops = NULL;
4912 	}
4913 	return (delayprops);
4914 }
4915 
4916 static void
4917 zfs_allow_log_destroy(void *arg)
4918 {
4919 	char *poolname = arg;
4920 
4921 	if (poolname != NULL)
4922 		kmem_strfree(poolname);
4923 }
4924 
4925 #ifdef	ZFS_DEBUG
4926 static boolean_t zfs_ioc_recv_inject_err;
4927 #endif
4928 
4929 /*
4930  * nvlist 'errors' is always allocated. It will contain descriptions of
4931  * encountered errors, if any. It's the callers responsibility to free.
4932  */
4933 static int
4934 zfs_ioc_recv_impl(char *tofs, char *tosnap, char *origin, nvlist_t *recvprops,
4935     nvlist_t *localprops, nvlist_t *hidden_args, boolean_t force,
4936     boolean_t heal, boolean_t resumable, int input_fd,
4937     dmu_replay_record_t *begin_record, uint64_t *read_bytes,
4938     uint64_t *errflags, nvlist_t **errors)
4939 {
4940 	dmu_recv_cookie_t drc;
4941 	int error = 0;
4942 	int props_error = 0;
4943 	offset_t off, noff;
4944 	nvlist_t *local_delayprops = NULL;
4945 	nvlist_t *recv_delayprops = NULL;
4946 	nvlist_t *inherited_delayprops = NULL;
4947 	nvlist_t *origprops = NULL; /* existing properties */
4948 	nvlist_t *origrecvd = NULL; /* existing received properties */
4949 	boolean_t first_recvd_props = B_FALSE;
4950 	boolean_t tofs_was_redacted;
4951 	zfs_file_t *input_fp;
4952 
4953 	*read_bytes = 0;
4954 	*errflags = 0;
4955 	*errors = fnvlist_alloc();
4956 	off = 0;
4957 
4958 	if ((input_fp = zfs_file_get(input_fd)) == NULL)
4959 		return (SET_ERROR(EBADF));
4960 
4961 	noff = off = zfs_file_off(input_fp);
4962 	error = dmu_recv_begin(tofs, tosnap, begin_record, force, heal,
4963 	    resumable, localprops, hidden_args, origin, &drc, input_fp,
4964 	    &off);
4965 	if (error != 0)
4966 		goto out;
4967 	tofs_was_redacted = dsl_get_redacted(drc.drc_ds);
4968 
4969 	/*
4970 	 * Set properties before we receive the stream so that they are applied
4971 	 * to the new data. Note that we must call dmu_recv_stream() if
4972 	 * dmu_recv_begin() succeeds.
4973 	 */
4974 	if (recvprops != NULL && !drc.drc_newfs) {
4975 		if (spa_version(dsl_dataset_get_spa(drc.drc_ds)) >=
4976 		    SPA_VERSION_RECVD_PROPS &&
4977 		    !dsl_prop_get_hasrecvd(tofs))
4978 			first_recvd_props = B_TRUE;
4979 
4980 		/*
4981 		 * If new received properties are supplied, they are to
4982 		 * completely replace the existing received properties,
4983 		 * so stash away the existing ones.
4984 		 */
4985 		if (dsl_prop_get_received(tofs, &origrecvd) == 0) {
4986 			nvlist_t *errlist = NULL;
4987 			/*
4988 			 * Don't bother writing a property if its value won't
4989 			 * change (and avoid the unnecessary security checks).
4990 			 *
4991 			 * The first receive after SPA_VERSION_RECVD_PROPS is a
4992 			 * special case where we blow away all local properties
4993 			 * regardless.
4994 			 */
4995 			if (!first_recvd_props)
4996 				props_reduce(recvprops, origrecvd);
4997 			if (zfs_check_clearable(tofs, origrecvd, &errlist) != 0)
4998 				(void) nvlist_merge(*errors, errlist, 0);
4999 			nvlist_free(errlist);
5000 
5001 			if (clear_received_props(tofs, origrecvd,
5002 			    first_recvd_props ? NULL : recvprops) != 0)
5003 				*errflags |= ZPROP_ERR_NOCLEAR;
5004 		} else {
5005 			*errflags |= ZPROP_ERR_NOCLEAR;
5006 		}
5007 	}
5008 
5009 	/*
5010 	 * Stash away existing properties so we can restore them on error unless
5011 	 * we're doing the first receive after SPA_VERSION_RECVD_PROPS, in which
5012 	 * case "origrecvd" will take care of that.
5013 	 */
5014 	if (localprops != NULL && !drc.drc_newfs && !first_recvd_props) {
5015 		objset_t *os;
5016 		if (dmu_objset_hold(tofs, FTAG, &os) == 0) {
5017 			if (dsl_prop_get_all(os, &origprops) != 0) {
5018 				*errflags |= ZPROP_ERR_NOCLEAR;
5019 			}
5020 			dmu_objset_rele(os, FTAG);
5021 		} else {
5022 			*errflags |= ZPROP_ERR_NOCLEAR;
5023 		}
5024 	}
5025 
5026 	if (recvprops != NULL) {
5027 		props_error = dsl_prop_set_hasrecvd(tofs);
5028 
5029 		if (props_error == 0) {
5030 			recv_delayprops = extract_delay_props(recvprops);
5031 			(void) zfs_set_prop_nvlist(tofs, ZPROP_SRC_RECEIVED,
5032 			    recvprops, *errors);
5033 		}
5034 	}
5035 
5036 	if (localprops != NULL) {
5037 		nvlist_t *oprops = fnvlist_alloc();
5038 		nvlist_t *xprops = fnvlist_alloc();
5039 		nvpair_t *nvp = NULL;
5040 
5041 		while ((nvp = nvlist_next_nvpair(localprops, nvp)) != NULL) {
5042 			if (nvpair_type(nvp) == DATA_TYPE_BOOLEAN) {
5043 				/* -x property */
5044 				const char *name = nvpair_name(nvp);
5045 				zfs_prop_t prop = zfs_name_to_prop(name);
5046 				if (prop != ZPROP_USERPROP) {
5047 					if (!zfs_prop_inheritable(prop))
5048 						continue;
5049 				} else if (!zfs_prop_user(name))
5050 					continue;
5051 				fnvlist_add_boolean(xprops, name);
5052 			} else {
5053 				/* -o property=value */
5054 				fnvlist_add_nvpair(oprops, nvp);
5055 			}
5056 		}
5057 
5058 		local_delayprops = extract_delay_props(oprops);
5059 		(void) zfs_set_prop_nvlist(tofs, ZPROP_SRC_LOCAL,
5060 		    oprops, *errors);
5061 		inherited_delayprops = extract_delay_props(xprops);
5062 		(void) zfs_set_prop_nvlist(tofs, ZPROP_SRC_INHERITED,
5063 		    xprops, *errors);
5064 
5065 		nvlist_free(oprops);
5066 		nvlist_free(xprops);
5067 	}
5068 
5069 	error = dmu_recv_stream(&drc, &off);
5070 
5071 	if (error == 0) {
5072 		zfsvfs_t *zfsvfs = NULL;
5073 		zvol_state_handle_t *zv = NULL;
5074 
5075 		if (getzfsvfs(tofs, &zfsvfs) == 0) {
5076 			/* online recv */
5077 			dsl_dataset_t *ds;
5078 			int end_err;
5079 			boolean_t stream_is_redacted = DMU_GET_FEATUREFLAGS(
5080 			    begin_record->drr_u.drr_begin.
5081 			    drr_versioninfo) & DMU_BACKUP_FEATURE_REDACTED;
5082 
5083 			ds = dmu_objset_ds(zfsvfs->z_os);
5084 			error = zfs_suspend_fs(zfsvfs);
5085 			/*
5086 			 * If the suspend fails, then the recv_end will
5087 			 * likely also fail, and clean up after itself.
5088 			 */
5089 			end_err = dmu_recv_end(&drc, zfsvfs);
5090 			/*
5091 			 * If the dataset was not redacted, but we received a
5092 			 * redacted stream onto it, we need to unmount the
5093 			 * dataset.  Otherwise, resume the filesystem.
5094 			 */
5095 			if (error == 0 && !drc.drc_newfs &&
5096 			    stream_is_redacted && !tofs_was_redacted) {
5097 				error = zfs_end_fs(zfsvfs, ds);
5098 			} else if (error == 0) {
5099 				error = zfs_resume_fs(zfsvfs, ds);
5100 			}
5101 			error = error ? error : end_err;
5102 			zfs_vfs_rele(zfsvfs);
5103 		} else if ((zv = zvol_suspend(tofs)) != NULL) {
5104 			error = dmu_recv_end(&drc, zvol_tag(zv));
5105 			zvol_resume(zv);
5106 		} else {
5107 			error = dmu_recv_end(&drc, NULL);
5108 		}
5109 
5110 		/* Set delayed properties now, after we're done receiving. */
5111 		if (recv_delayprops != NULL && error == 0) {
5112 			(void) zfs_set_prop_nvlist(tofs, ZPROP_SRC_RECEIVED,
5113 			    recv_delayprops, *errors);
5114 		}
5115 		if (local_delayprops != NULL && error == 0) {
5116 			(void) zfs_set_prop_nvlist(tofs, ZPROP_SRC_LOCAL,
5117 			    local_delayprops, *errors);
5118 		}
5119 		if (inherited_delayprops != NULL && error == 0) {
5120 			(void) zfs_set_prop_nvlist(tofs, ZPROP_SRC_INHERITED,
5121 			    inherited_delayprops, *errors);
5122 		}
5123 	}
5124 
5125 	/*
5126 	 * Merge delayed props back in with initial props, in case
5127 	 * we're DEBUG and zfs_ioc_recv_inject_err is set (which means
5128 	 * we have to make sure clear_received_props() includes
5129 	 * the delayed properties).
5130 	 *
5131 	 * Since zfs_ioc_recv_inject_err is only in DEBUG kernels,
5132 	 * using ASSERT() will be just like a VERIFY.
5133 	 */
5134 	if (recv_delayprops != NULL) {
5135 		ASSERT(nvlist_merge(recvprops, recv_delayprops, 0) == 0);
5136 		nvlist_free(recv_delayprops);
5137 	}
5138 	if (local_delayprops != NULL) {
5139 		ASSERT(nvlist_merge(localprops, local_delayprops, 0) == 0);
5140 		nvlist_free(local_delayprops);
5141 	}
5142 	if (inherited_delayprops != NULL) {
5143 		ASSERT(nvlist_merge(localprops, inherited_delayprops, 0) == 0);
5144 		nvlist_free(inherited_delayprops);
5145 	}
5146 	*read_bytes = off - noff;
5147 
5148 #ifdef	ZFS_DEBUG
5149 	if (zfs_ioc_recv_inject_err) {
5150 		zfs_ioc_recv_inject_err = B_FALSE;
5151 		error = 1;
5152 	}
5153 #endif
5154 
5155 	/*
5156 	 * On error, restore the original props.
5157 	 */
5158 	if (error != 0 && recvprops != NULL && !drc.drc_newfs) {
5159 		if (clear_received_props(tofs, recvprops, NULL) != 0) {
5160 			/*
5161 			 * We failed to clear the received properties.
5162 			 * Since we may have left a $recvd value on the
5163 			 * system, we can't clear the $hasrecvd flag.
5164 			 */
5165 			*errflags |= ZPROP_ERR_NORESTORE;
5166 		} else if (first_recvd_props) {
5167 			dsl_prop_unset_hasrecvd(tofs);
5168 		}
5169 
5170 		if (origrecvd == NULL && !drc.drc_newfs) {
5171 			/* We failed to stash the original properties. */
5172 			*errflags |= ZPROP_ERR_NORESTORE;
5173 		}
5174 
5175 		/*
5176 		 * dsl_props_set() will not convert RECEIVED to LOCAL on or
5177 		 * after SPA_VERSION_RECVD_PROPS, so we need to specify LOCAL
5178 		 * explicitly if we're restoring local properties cleared in the
5179 		 * first new-style receive.
5180 		 */
5181 		if (origrecvd != NULL &&
5182 		    zfs_set_prop_nvlist(tofs, (first_recvd_props ?
5183 		    ZPROP_SRC_LOCAL : ZPROP_SRC_RECEIVED),
5184 		    origrecvd, NULL) != 0) {
5185 			/*
5186 			 * We stashed the original properties but failed to
5187 			 * restore them.
5188 			 */
5189 			*errflags |= ZPROP_ERR_NORESTORE;
5190 		}
5191 	}
5192 	if (error != 0 && localprops != NULL && !drc.drc_newfs &&
5193 	    !first_recvd_props) {
5194 		nvlist_t *setprops;
5195 		nvlist_t *inheritprops;
5196 		nvpair_t *nvp;
5197 
5198 		if (origprops == NULL) {
5199 			/* We failed to stash the original properties. */
5200 			*errflags |= ZPROP_ERR_NORESTORE;
5201 			goto out;
5202 		}
5203 
5204 		/* Restore original props */
5205 		setprops = fnvlist_alloc();
5206 		inheritprops = fnvlist_alloc();
5207 		nvp = NULL;
5208 		while ((nvp = nvlist_next_nvpair(localprops, nvp)) != NULL) {
5209 			const char *name = nvpair_name(nvp);
5210 			const char *source;
5211 			nvlist_t *attrs;
5212 
5213 			if (!nvlist_exists(origprops, name)) {
5214 				/*
5215 				 * Property was not present or was explicitly
5216 				 * inherited before the receive, restore this.
5217 				 */
5218 				fnvlist_add_boolean(inheritprops, name);
5219 				continue;
5220 			}
5221 			attrs = fnvlist_lookup_nvlist(origprops, name);
5222 			source = fnvlist_lookup_string(attrs, ZPROP_SOURCE);
5223 
5224 			/* Skip received properties */
5225 			if (strcmp(source, ZPROP_SOURCE_VAL_RECVD) == 0)
5226 				continue;
5227 
5228 			if (strcmp(source, tofs) == 0) {
5229 				/* Property was locally set */
5230 				fnvlist_add_nvlist(setprops, name, attrs);
5231 			} else {
5232 				/* Property was implicitly inherited */
5233 				fnvlist_add_boolean(inheritprops, name);
5234 			}
5235 		}
5236 
5237 		if (zfs_set_prop_nvlist(tofs, ZPROP_SRC_LOCAL, setprops,
5238 		    NULL) != 0)
5239 			*errflags |= ZPROP_ERR_NORESTORE;
5240 		if (zfs_set_prop_nvlist(tofs, ZPROP_SRC_INHERITED, inheritprops,
5241 		    NULL) != 0)
5242 			*errflags |= ZPROP_ERR_NORESTORE;
5243 
5244 		nvlist_free(setprops);
5245 		nvlist_free(inheritprops);
5246 	}
5247 out:
5248 	zfs_file_put(input_fp);
5249 	nvlist_free(origrecvd);
5250 	nvlist_free(origprops);
5251 
5252 	if (error == 0)
5253 		error = props_error;
5254 
5255 	return (error);
5256 }
5257 
5258 /*
5259  * inputs:
5260  * zc_name		name of containing filesystem (unused)
5261  * zc_nvlist_src{_size}	nvlist of properties to apply
5262  * zc_nvlist_conf{_size}	nvlist of properties to exclude
5263  *			(DATA_TYPE_BOOLEAN) and override (everything else)
5264  * zc_value		name of snapshot to create
5265  * zc_string		name of clone origin (if DRR_FLAG_CLONE)
5266  * zc_cookie		file descriptor to recv from
5267  * zc_begin_record	the BEGIN record of the stream (not byteswapped)
5268  * zc_guid		force flag
5269  *
5270  * outputs:
5271  * zc_cookie		number of bytes read
5272  * zc_obj		zprop_errflags_t
5273  * zc_nvlist_dst{_size} error for each unapplied received property
5274  */
5275 static int
5276 zfs_ioc_recv(zfs_cmd_t *zc)
5277 {
5278 	dmu_replay_record_t begin_record;
5279 	nvlist_t *errors = NULL;
5280 	nvlist_t *recvdprops = NULL;
5281 	nvlist_t *localprops = NULL;
5282 	char *origin = NULL;
5283 	char *tosnap;
5284 	char tofs[ZFS_MAX_DATASET_NAME_LEN];
5285 	int error = 0;
5286 
5287 	if (dataset_namecheck(zc->zc_value, NULL, NULL) != 0 ||
5288 	    strchr(zc->zc_value, '@') == NULL ||
5289 	    strchr(zc->zc_value, '%'))
5290 		return (SET_ERROR(EINVAL));
5291 
5292 	(void) strlcpy(tofs, zc->zc_value, sizeof (tofs));
5293 	tosnap = strchr(tofs, '@');
5294 	*tosnap++ = '\0';
5295 
5296 	if (zc->zc_nvlist_src != 0 &&
5297 	    (error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
5298 	    zc->zc_iflags, &recvdprops)) != 0)
5299 		return (error);
5300 
5301 	if (zc->zc_nvlist_conf != 0 &&
5302 	    (error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size,
5303 	    zc->zc_iflags, &localprops)) != 0)
5304 		return (error);
5305 
5306 	if (zc->zc_string[0])
5307 		origin = zc->zc_string;
5308 
5309 	begin_record.drr_type = DRR_BEGIN;
5310 	begin_record.drr_payloadlen = 0;
5311 	begin_record.drr_u.drr_begin = zc->zc_begin_record;
5312 
5313 	error = zfs_ioc_recv_impl(tofs, tosnap, origin, recvdprops, localprops,
5314 	    NULL, zc->zc_guid, B_FALSE, B_FALSE, zc->zc_cookie, &begin_record,
5315 	    &zc->zc_cookie, &zc->zc_obj, &errors);
5316 	nvlist_free(recvdprops);
5317 	nvlist_free(localprops);
5318 
5319 	/*
5320 	 * Now that all props, initial and delayed, are set, report the prop
5321 	 * errors to the caller.
5322 	 */
5323 	if (zc->zc_nvlist_dst_size != 0 && errors != NULL &&
5324 	    (nvlist_smush(errors, zc->zc_nvlist_dst_size) != 0 ||
5325 	    put_nvlist(zc, errors) != 0)) {
5326 		/*
5327 		 * Caller made zc->zc_nvlist_dst less than the minimum expected
5328 		 * size or supplied an invalid address.
5329 		 */
5330 		error = SET_ERROR(EINVAL);
5331 	}
5332 
5333 	nvlist_free(errors);
5334 
5335 	return (error);
5336 }
5337 
5338 /*
5339  * innvl: {
5340  *     "snapname" -> full name of the snapshot to create
5341  *     (optional) "props" -> received properties to set (nvlist)
5342  *     (optional) "localprops" -> override and exclude properties (nvlist)
5343  *     (optional) "origin" -> name of clone origin (DRR_FLAG_CLONE)
5344  *     "begin_record" -> non-byteswapped dmu_replay_record_t
5345  *     "input_fd" -> file descriptor to read stream from (int32)
5346  *     (optional) "force" -> force flag (value ignored)
5347  *     (optional) "heal" -> use send stream to heal data corruption
5348  *     (optional) "resumable" -> resumable flag (value ignored)
5349  *     (optional) "cleanup_fd" -> unused
5350  *     (optional) "action_handle" -> unused
5351  *     (optional) "hidden_args" -> { "wkeydata" -> value }
5352  * }
5353  *
5354  * outnvl: {
5355  *     "read_bytes" -> number of bytes read
5356  *     "error_flags" -> zprop_errflags_t
5357  *     "errors" -> error for each unapplied received property (nvlist)
5358  * }
5359  */
5360 static const zfs_ioc_key_t zfs_keys_recv_new[] = {
5361 	{"snapname",		DATA_TYPE_STRING,	0},
5362 	{"props",		DATA_TYPE_NVLIST,	ZK_OPTIONAL},
5363 	{"localprops",		DATA_TYPE_NVLIST,	ZK_OPTIONAL},
5364 	{"origin",		DATA_TYPE_STRING,	ZK_OPTIONAL},
5365 	{"begin_record",	DATA_TYPE_BYTE_ARRAY,	0},
5366 	{"input_fd",		DATA_TYPE_INT32,	0},
5367 	{"force",		DATA_TYPE_BOOLEAN,	ZK_OPTIONAL},
5368 	{"heal",		DATA_TYPE_BOOLEAN,	ZK_OPTIONAL},
5369 	{"resumable",		DATA_TYPE_BOOLEAN,	ZK_OPTIONAL},
5370 	{"cleanup_fd",		DATA_TYPE_INT32,	ZK_OPTIONAL},
5371 	{"action_handle",	DATA_TYPE_UINT64,	ZK_OPTIONAL},
5372 	{"hidden_args",		DATA_TYPE_NVLIST,	ZK_OPTIONAL},
5373 };
5374 
5375 static int
5376 zfs_ioc_recv_new(const char *fsname, nvlist_t *innvl, nvlist_t *outnvl)
5377 {
5378 	dmu_replay_record_t *begin_record;
5379 	uint_t begin_record_size;
5380 	nvlist_t *errors = NULL;
5381 	nvlist_t *recvprops = NULL;
5382 	nvlist_t *localprops = NULL;
5383 	nvlist_t *hidden_args = NULL;
5384 	char *snapname;
5385 	char *origin = NULL;
5386 	char *tosnap;
5387 	char tofs[ZFS_MAX_DATASET_NAME_LEN];
5388 	boolean_t force;
5389 	boolean_t heal;
5390 	boolean_t resumable;
5391 	uint64_t read_bytes = 0;
5392 	uint64_t errflags = 0;
5393 	int input_fd = -1;
5394 	int error;
5395 
5396 	snapname = fnvlist_lookup_string(innvl, "snapname");
5397 
5398 	if (dataset_namecheck(snapname, NULL, NULL) != 0 ||
5399 	    strchr(snapname, '@') == NULL ||
5400 	    strchr(snapname, '%'))
5401 		return (SET_ERROR(EINVAL));
5402 
5403 	(void) strlcpy(tofs, snapname, sizeof (tofs));
5404 	tosnap = strchr(tofs, '@');
5405 	*tosnap++ = '\0';
5406 
5407 	error = nvlist_lookup_string(innvl, "origin", &origin);
5408 	if (error && error != ENOENT)
5409 		return (error);
5410 
5411 	error = nvlist_lookup_byte_array(innvl, "begin_record",
5412 	    (uchar_t **)&begin_record, &begin_record_size);
5413 	if (error != 0 || begin_record_size != sizeof (*begin_record))
5414 		return (SET_ERROR(EINVAL));
5415 
5416 	input_fd = fnvlist_lookup_int32(innvl, "input_fd");
5417 
5418 	force = nvlist_exists(innvl, "force");
5419 	heal = nvlist_exists(innvl, "heal");
5420 	resumable = nvlist_exists(innvl, "resumable");
5421 
5422 	/* we still use "props" here for backwards compatibility */
5423 	error = nvlist_lookup_nvlist(innvl, "props", &recvprops);
5424 	if (error && error != ENOENT)
5425 		return (error);
5426 
5427 	error = nvlist_lookup_nvlist(innvl, "localprops", &localprops);
5428 	if (error && error != ENOENT)
5429 		return (error);
5430 
5431 	error = nvlist_lookup_nvlist(innvl, ZPOOL_HIDDEN_ARGS, &hidden_args);
5432 	if (error && error != ENOENT)
5433 		return (error);
5434 
5435 	error = zfs_ioc_recv_impl(tofs, tosnap, origin, recvprops, localprops,
5436 	    hidden_args, force, heal, resumable, input_fd, begin_record,
5437 	    &read_bytes, &errflags, &errors);
5438 
5439 	fnvlist_add_uint64(outnvl, "read_bytes", read_bytes);
5440 	fnvlist_add_uint64(outnvl, "error_flags", errflags);
5441 	fnvlist_add_nvlist(outnvl, "errors", errors);
5442 
5443 	nvlist_free(errors);
5444 	nvlist_free(recvprops);
5445 	nvlist_free(localprops);
5446 
5447 	return (error);
5448 }
5449 
5450 typedef struct dump_bytes_io {
5451 	zfs_file_t	*dbi_fp;
5452 	caddr_t		dbi_buf;
5453 	int		dbi_len;
5454 	int		dbi_err;
5455 } dump_bytes_io_t;
5456 
5457 static void
5458 dump_bytes_cb(void *arg)
5459 {
5460 	dump_bytes_io_t *dbi = (dump_bytes_io_t *)arg;
5461 	zfs_file_t *fp;
5462 	caddr_t buf;
5463 
5464 	fp = dbi->dbi_fp;
5465 	buf = dbi->dbi_buf;
5466 
5467 	dbi->dbi_err = zfs_file_write(fp, buf, dbi->dbi_len, NULL);
5468 }
5469 
5470 static int
5471 dump_bytes(objset_t *os, void *buf, int len, void *arg)
5472 {
5473 	dump_bytes_io_t dbi;
5474 
5475 	dbi.dbi_fp = arg;
5476 	dbi.dbi_buf = buf;
5477 	dbi.dbi_len = len;
5478 
5479 #if defined(HAVE_LARGE_STACKS)
5480 	dump_bytes_cb(&dbi);
5481 #else
5482 	/*
5483 	 * The vn_rdwr() call is performed in a taskq to ensure that there is
5484 	 * always enough stack space to write safely to the target filesystem.
5485 	 * The ZIO_TYPE_FREE threads are used because there can be a lot of
5486 	 * them and they are used in vdev_file.c for a similar purpose.
5487 	 */
5488 	spa_taskq_dispatch_sync(dmu_objset_spa(os), ZIO_TYPE_FREE,
5489 	    ZIO_TASKQ_ISSUE, dump_bytes_cb, &dbi, TQ_SLEEP);
5490 #endif /* HAVE_LARGE_STACKS */
5491 
5492 	return (dbi.dbi_err);
5493 }
5494 
5495 /*
5496  * inputs:
5497  * zc_name	name of snapshot to send
5498  * zc_cookie	file descriptor to send stream to
5499  * zc_obj	fromorigin flag (mutually exclusive with zc_fromobj)
5500  * zc_sendobj	objsetid of snapshot to send
5501  * zc_fromobj	objsetid of incremental fromsnap (may be zero)
5502  * zc_guid	if set, estimate size of stream only.  zc_cookie is ignored.
5503  *		output size in zc_objset_type.
5504  * zc_flags	lzc_send_flags
5505  *
5506  * outputs:
5507  * zc_objset_type	estimated size, if zc_guid is set
5508  *
5509  * NOTE: This is no longer the preferred interface, any new functionality
5510  *	  should be added to zfs_ioc_send_new() instead.
5511  */
5512 static int
5513 zfs_ioc_send(zfs_cmd_t *zc)
5514 {
5515 	int error;
5516 	offset_t off;
5517 	boolean_t estimate = (zc->zc_guid != 0);
5518 	boolean_t embedok = (zc->zc_flags & 0x1);
5519 	boolean_t large_block_ok = (zc->zc_flags & 0x2);
5520 	boolean_t compressok = (zc->zc_flags & 0x4);
5521 	boolean_t rawok = (zc->zc_flags & 0x8);
5522 	boolean_t savedok = (zc->zc_flags & 0x10);
5523 
5524 	if (zc->zc_obj != 0) {
5525 		dsl_pool_t *dp;
5526 		dsl_dataset_t *tosnap;
5527 
5528 		error = dsl_pool_hold(zc->zc_name, FTAG, &dp);
5529 		if (error != 0)
5530 			return (error);
5531 
5532 		error = dsl_dataset_hold_obj(dp, zc->zc_sendobj, FTAG, &tosnap);
5533 		if (error != 0) {
5534 			dsl_pool_rele(dp, FTAG);
5535 			return (error);
5536 		}
5537 
5538 		if (dsl_dir_is_clone(tosnap->ds_dir))
5539 			zc->zc_fromobj =
5540 			    dsl_dir_phys(tosnap->ds_dir)->dd_origin_obj;
5541 		dsl_dataset_rele(tosnap, FTAG);
5542 		dsl_pool_rele(dp, FTAG);
5543 	}
5544 
5545 	if (estimate) {
5546 		dsl_pool_t *dp;
5547 		dsl_dataset_t *tosnap;
5548 		dsl_dataset_t *fromsnap = NULL;
5549 
5550 		error = dsl_pool_hold(zc->zc_name, FTAG, &dp);
5551 		if (error != 0)
5552 			return (error);
5553 
5554 		error = dsl_dataset_hold_obj(dp, zc->zc_sendobj,
5555 		    FTAG, &tosnap);
5556 		if (error != 0) {
5557 			dsl_pool_rele(dp, FTAG);
5558 			return (error);
5559 		}
5560 
5561 		if (zc->zc_fromobj != 0) {
5562 			error = dsl_dataset_hold_obj(dp, zc->zc_fromobj,
5563 			    FTAG, &fromsnap);
5564 			if (error != 0) {
5565 				dsl_dataset_rele(tosnap, FTAG);
5566 				dsl_pool_rele(dp, FTAG);
5567 				return (error);
5568 			}
5569 		}
5570 
5571 		error = dmu_send_estimate_fast(tosnap, fromsnap, NULL,
5572 		    compressok || rawok, savedok, &zc->zc_objset_type);
5573 
5574 		if (fromsnap != NULL)
5575 			dsl_dataset_rele(fromsnap, FTAG);
5576 		dsl_dataset_rele(tosnap, FTAG);
5577 		dsl_pool_rele(dp, FTAG);
5578 	} else {
5579 		zfs_file_t *fp;
5580 		dmu_send_outparams_t out = {0};
5581 
5582 		if ((fp = zfs_file_get(zc->zc_cookie)) == NULL)
5583 			return (SET_ERROR(EBADF));
5584 
5585 		off = zfs_file_off(fp);
5586 		out.dso_outfunc = dump_bytes;
5587 		out.dso_arg = fp;
5588 		out.dso_dryrun = B_FALSE;
5589 		error = dmu_send_obj(zc->zc_name, zc->zc_sendobj,
5590 		    zc->zc_fromobj, embedok, large_block_ok, compressok,
5591 		    rawok, savedok, zc->zc_cookie, &off, &out);
5592 
5593 		zfs_file_put(fp);
5594 	}
5595 	return (error);
5596 }
5597 
5598 /*
5599  * inputs:
5600  * zc_name		name of snapshot on which to report progress
5601  * zc_cookie		file descriptor of send stream
5602  *
5603  * outputs:
5604  * zc_cookie		number of bytes written in send stream thus far
5605  * zc_objset_type	logical size of data traversed by send thus far
5606  */
5607 static int
5608 zfs_ioc_send_progress(zfs_cmd_t *zc)
5609 {
5610 	dsl_pool_t *dp;
5611 	dsl_dataset_t *ds;
5612 	dmu_sendstatus_t *dsp = NULL;
5613 	int error;
5614 
5615 	error = dsl_pool_hold(zc->zc_name, FTAG, &dp);
5616 	if (error != 0)
5617 		return (error);
5618 
5619 	error = dsl_dataset_hold(dp, zc->zc_name, FTAG, &ds);
5620 	if (error != 0) {
5621 		dsl_pool_rele(dp, FTAG);
5622 		return (error);
5623 	}
5624 
5625 	mutex_enter(&ds->ds_sendstream_lock);
5626 
5627 	/*
5628 	 * Iterate over all the send streams currently active on this dataset.
5629 	 * If there's one which matches the specified file descriptor _and_ the
5630 	 * stream was started by the current process, return the progress of
5631 	 * that stream.
5632 	 */
5633 
5634 	for (dsp = list_head(&ds->ds_sendstreams); dsp != NULL;
5635 	    dsp = list_next(&ds->ds_sendstreams, dsp)) {
5636 		if (dsp->dss_outfd == zc->zc_cookie &&
5637 		    zfs_proc_is_caller(dsp->dss_proc))
5638 			break;
5639 	}
5640 
5641 	if (dsp != NULL) {
5642 		zc->zc_cookie = atomic_cas_64((volatile uint64_t *)dsp->dss_off,
5643 		    0, 0);
5644 		/* This is the closest thing we have to atomic_read_64. */
5645 		zc->zc_objset_type = atomic_cas_64(&dsp->dss_blocks, 0, 0);
5646 	} else {
5647 		error = SET_ERROR(ENOENT);
5648 	}
5649 
5650 	mutex_exit(&ds->ds_sendstream_lock);
5651 	dsl_dataset_rele(ds, FTAG);
5652 	dsl_pool_rele(dp, FTAG);
5653 	return (error);
5654 }
5655 
5656 static int
5657 zfs_ioc_inject_fault(zfs_cmd_t *zc)
5658 {
5659 	int id, error;
5660 
5661 	error = zio_inject_fault(zc->zc_name, (int)zc->zc_guid, &id,
5662 	    &zc->zc_inject_record);
5663 
5664 	if (error == 0)
5665 		zc->zc_guid = (uint64_t)id;
5666 
5667 	return (error);
5668 }
5669 
5670 static int
5671 zfs_ioc_clear_fault(zfs_cmd_t *zc)
5672 {
5673 	return (zio_clear_fault((int)zc->zc_guid));
5674 }
5675 
5676 static int
5677 zfs_ioc_inject_list_next(zfs_cmd_t *zc)
5678 {
5679 	int id = (int)zc->zc_guid;
5680 	int error;
5681 
5682 	error = zio_inject_list_next(&id, zc->zc_name, sizeof (zc->zc_name),
5683 	    &zc->zc_inject_record);
5684 
5685 	zc->zc_guid = id;
5686 
5687 	return (error);
5688 }
5689 
5690 static int
5691 zfs_ioc_error_log(zfs_cmd_t *zc)
5692 {
5693 	spa_t *spa;
5694 	int error;
5695 	uint64_t count = zc->zc_nvlist_dst_size;
5696 
5697 	if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
5698 		return (error);
5699 
5700 	error = spa_get_errlog(spa, (void *)(uintptr_t)zc->zc_nvlist_dst,
5701 	    &count);
5702 	if (error == 0)
5703 		zc->zc_nvlist_dst_size = count;
5704 	else
5705 		zc->zc_nvlist_dst_size = spa_get_errlog_size(spa);
5706 
5707 	spa_close(spa, FTAG);
5708 
5709 	return (error);
5710 }
5711 
5712 static int
5713 zfs_ioc_clear(zfs_cmd_t *zc)
5714 {
5715 	spa_t *spa;
5716 	vdev_t *vd;
5717 	int error;
5718 
5719 	/*
5720 	 * On zpool clear we also fix up missing slogs
5721 	 */
5722 	mutex_enter(&spa_namespace_lock);
5723 	spa = spa_lookup(zc->zc_name);
5724 	if (spa == NULL) {
5725 		mutex_exit(&spa_namespace_lock);
5726 		return (SET_ERROR(EIO));
5727 	}
5728 	if (spa_get_log_state(spa) == SPA_LOG_MISSING) {
5729 		/* we need to let spa_open/spa_load clear the chains */
5730 		spa_set_log_state(spa, SPA_LOG_CLEAR);
5731 	}
5732 	spa->spa_last_open_failed = 0;
5733 	mutex_exit(&spa_namespace_lock);
5734 
5735 	if (zc->zc_cookie & ZPOOL_NO_REWIND) {
5736 		error = spa_open(zc->zc_name, &spa, FTAG);
5737 	} else {
5738 		nvlist_t *policy;
5739 		nvlist_t *config = NULL;
5740 
5741 		if (zc->zc_nvlist_src == 0)
5742 			return (SET_ERROR(EINVAL));
5743 
5744 		if ((error = get_nvlist(zc->zc_nvlist_src,
5745 		    zc->zc_nvlist_src_size, zc->zc_iflags, &policy)) == 0) {
5746 			error = spa_open_rewind(zc->zc_name, &spa, FTAG,
5747 			    policy, &config);
5748 			if (config != NULL) {
5749 				int err;
5750 
5751 				if ((err = put_nvlist(zc, config)) != 0)
5752 					error = err;
5753 				nvlist_free(config);
5754 			}
5755 			nvlist_free(policy);
5756 		}
5757 	}
5758 
5759 	if (error != 0)
5760 		return (error);
5761 
5762 	/*
5763 	 * If multihost is enabled, resuming I/O is unsafe as another
5764 	 * host may have imported the pool.
5765 	 */
5766 	if (spa_multihost(spa) && spa_suspended(spa))
5767 		return (SET_ERROR(EINVAL));
5768 
5769 	spa_vdev_state_enter(spa, SCL_NONE);
5770 
5771 	if (zc->zc_guid == 0) {
5772 		vd = NULL;
5773 	} else {
5774 		vd = spa_lookup_by_guid(spa, zc->zc_guid, B_TRUE);
5775 		if (vd == NULL) {
5776 			error = SET_ERROR(ENODEV);
5777 			(void) spa_vdev_state_exit(spa, NULL, error);
5778 			spa_close(spa, FTAG);
5779 			return (error);
5780 		}
5781 	}
5782 
5783 	vdev_clear(spa, vd);
5784 
5785 	(void) spa_vdev_state_exit(spa, spa_suspended(spa) ?
5786 	    NULL : spa->spa_root_vdev, 0);
5787 
5788 	/*
5789 	 * Resume any suspended I/Os.
5790 	 */
5791 	if (zio_resume(spa) != 0)
5792 		error = SET_ERROR(EIO);
5793 
5794 	spa_close(spa, FTAG);
5795 
5796 	return (error);
5797 }
5798 
5799 /*
5800  * Reopen all the vdevs associated with the pool.
5801  *
5802  * innvl: {
5803  *  "scrub_restart" -> when true and scrub is running, allow to restart
5804  *              scrub as the side effect of the reopen (boolean).
5805  * }
5806  *
5807  * outnvl is unused
5808  */
5809 static const zfs_ioc_key_t zfs_keys_pool_reopen[] = {
5810 	{"scrub_restart",	DATA_TYPE_BOOLEAN_VALUE,	ZK_OPTIONAL},
5811 };
5812 
5813 static int
5814 zfs_ioc_pool_reopen(const char *pool, nvlist_t *innvl, nvlist_t *outnvl)
5815 {
5816 	(void) outnvl;
5817 	spa_t *spa;
5818 	int error;
5819 	boolean_t rc, scrub_restart = B_TRUE;
5820 
5821 	if (innvl) {
5822 		error = nvlist_lookup_boolean_value(innvl,
5823 		    "scrub_restart", &rc);
5824 		if (error == 0)
5825 			scrub_restart = rc;
5826 	}
5827 
5828 	error = spa_open(pool, &spa, FTAG);
5829 	if (error != 0)
5830 		return (error);
5831 
5832 	spa_vdev_state_enter(spa, SCL_NONE);
5833 
5834 	/*
5835 	 * If the scrub_restart flag is B_FALSE and a scrub is already
5836 	 * in progress then set spa_scrub_reopen flag to B_TRUE so that
5837 	 * we don't restart the scrub as a side effect of the reopen.
5838 	 * Otherwise, let vdev_open() decided if a resilver is required.
5839 	 */
5840 
5841 	spa->spa_scrub_reopen = (!scrub_restart &&
5842 	    dsl_scan_scrubbing(spa->spa_dsl_pool));
5843 	vdev_reopen(spa->spa_root_vdev);
5844 	spa->spa_scrub_reopen = B_FALSE;
5845 
5846 	(void) spa_vdev_state_exit(spa, NULL, 0);
5847 	spa_close(spa, FTAG);
5848 	return (0);
5849 }
5850 
5851 /*
5852  * inputs:
5853  * zc_name	name of filesystem
5854  *
5855  * outputs:
5856  * zc_string	name of conflicting snapshot, if there is one
5857  */
5858 static int
5859 zfs_ioc_promote(zfs_cmd_t *zc)
5860 {
5861 	dsl_pool_t *dp;
5862 	dsl_dataset_t *ds, *ods;
5863 	char origin[ZFS_MAX_DATASET_NAME_LEN];
5864 	char *cp;
5865 	int error;
5866 
5867 	zc->zc_name[sizeof (zc->zc_name) - 1] = '\0';
5868 	if (dataset_namecheck(zc->zc_name, NULL, NULL) != 0 ||
5869 	    strchr(zc->zc_name, '%'))
5870 		return (SET_ERROR(EINVAL));
5871 
5872 	error = dsl_pool_hold(zc->zc_name, FTAG, &dp);
5873 	if (error != 0)
5874 		return (error);
5875 
5876 	error = dsl_dataset_hold(dp, zc->zc_name, FTAG, &ds);
5877 	if (error != 0) {
5878 		dsl_pool_rele(dp, FTAG);
5879 		return (error);
5880 	}
5881 
5882 	if (!dsl_dir_is_clone(ds->ds_dir)) {
5883 		dsl_dataset_rele(ds, FTAG);
5884 		dsl_pool_rele(dp, FTAG);
5885 		return (SET_ERROR(EINVAL));
5886 	}
5887 
5888 	error = dsl_dataset_hold_obj(dp,
5889 	    dsl_dir_phys(ds->ds_dir)->dd_origin_obj, FTAG, &ods);
5890 	if (error != 0) {
5891 		dsl_dataset_rele(ds, FTAG);
5892 		dsl_pool_rele(dp, FTAG);
5893 		return (error);
5894 	}
5895 
5896 	dsl_dataset_name(ods, origin);
5897 	dsl_dataset_rele(ods, FTAG);
5898 	dsl_dataset_rele(ds, FTAG);
5899 	dsl_pool_rele(dp, FTAG);
5900 
5901 	/*
5902 	 * We don't need to unmount *all* the origin fs's snapshots, but
5903 	 * it's easier.
5904 	 */
5905 	cp = strchr(origin, '@');
5906 	if (cp)
5907 		*cp = '\0';
5908 	(void) dmu_objset_find(origin,
5909 	    zfs_unmount_snap_cb, NULL, DS_FIND_SNAPSHOTS);
5910 	return (dsl_dataset_promote(zc->zc_name, zc->zc_string));
5911 }
5912 
5913 /*
5914  * Retrieve a single {user|group|project}{used|quota}@... property.
5915  *
5916  * inputs:
5917  * zc_name	name of filesystem
5918  * zc_objset_type zfs_userquota_prop_t
5919  * zc_value	domain name (eg. "S-1-234-567-89")
5920  * zc_guid	RID/UID/GID
5921  *
5922  * outputs:
5923  * zc_cookie	property value
5924  */
5925 static int
5926 zfs_ioc_userspace_one(zfs_cmd_t *zc)
5927 {
5928 	zfsvfs_t *zfsvfs;
5929 	int error;
5930 
5931 	if (zc->zc_objset_type >= ZFS_NUM_USERQUOTA_PROPS)
5932 		return (SET_ERROR(EINVAL));
5933 
5934 	error = zfsvfs_hold(zc->zc_name, FTAG, &zfsvfs, B_FALSE);
5935 	if (error != 0)
5936 		return (error);
5937 
5938 	error = zfs_userspace_one(zfsvfs,
5939 	    zc->zc_objset_type, zc->zc_value, zc->zc_guid, &zc->zc_cookie);
5940 	zfsvfs_rele(zfsvfs, FTAG);
5941 
5942 	return (error);
5943 }
5944 
5945 /*
5946  * inputs:
5947  * zc_name		name of filesystem
5948  * zc_cookie		zap cursor
5949  * zc_objset_type	zfs_userquota_prop_t
5950  * zc_nvlist_dst[_size] buffer to fill (not really an nvlist)
5951  *
5952  * outputs:
5953  * zc_nvlist_dst[_size]	data buffer (array of zfs_useracct_t)
5954  * zc_cookie	zap cursor
5955  */
5956 static int
5957 zfs_ioc_userspace_many(zfs_cmd_t *zc)
5958 {
5959 	zfsvfs_t *zfsvfs;
5960 	int bufsize = zc->zc_nvlist_dst_size;
5961 
5962 	if (bufsize <= 0)
5963 		return (SET_ERROR(ENOMEM));
5964 
5965 	int error = zfsvfs_hold(zc->zc_name, FTAG, &zfsvfs, B_FALSE);
5966 	if (error != 0)
5967 		return (error);
5968 
5969 	void *buf = vmem_alloc(bufsize, KM_SLEEP);
5970 
5971 	error = zfs_userspace_many(zfsvfs, zc->zc_objset_type, &zc->zc_cookie,
5972 	    buf, &zc->zc_nvlist_dst_size);
5973 
5974 	if (error == 0) {
5975 		error = xcopyout(buf,
5976 		    (void *)(uintptr_t)zc->zc_nvlist_dst,
5977 		    zc->zc_nvlist_dst_size);
5978 	}
5979 	vmem_free(buf, bufsize);
5980 	zfsvfs_rele(zfsvfs, FTAG);
5981 
5982 	return (error);
5983 }
5984 
5985 /*
5986  * inputs:
5987  * zc_name		name of filesystem
5988  *
5989  * outputs:
5990  * none
5991  */
5992 static int
5993 zfs_ioc_userspace_upgrade(zfs_cmd_t *zc)
5994 {
5995 	int error = 0;
5996 	zfsvfs_t *zfsvfs;
5997 
5998 	if (getzfsvfs(zc->zc_name, &zfsvfs) == 0) {
5999 		if (!dmu_objset_userused_enabled(zfsvfs->z_os)) {
6000 			/*
6001 			 * If userused is not enabled, it may be because the
6002 			 * objset needs to be closed & reopened (to grow the
6003 			 * objset_phys_t).  Suspend/resume the fs will do that.
6004 			 */
6005 			dsl_dataset_t *ds, *newds;
6006 
6007 			ds = dmu_objset_ds(zfsvfs->z_os);
6008 			error = zfs_suspend_fs(zfsvfs);
6009 			if (error == 0) {
6010 				dmu_objset_refresh_ownership(ds, &newds,
6011 				    B_TRUE, zfsvfs);
6012 				error = zfs_resume_fs(zfsvfs, newds);
6013 			}
6014 		}
6015 		if (error == 0) {
6016 			mutex_enter(&zfsvfs->z_os->os_upgrade_lock);
6017 			if (zfsvfs->z_os->os_upgrade_id == 0) {
6018 				/* clear potential error code and retry */
6019 				zfsvfs->z_os->os_upgrade_status = 0;
6020 				mutex_exit(&zfsvfs->z_os->os_upgrade_lock);
6021 
6022 				dsl_pool_config_enter(
6023 				    dmu_objset_pool(zfsvfs->z_os), FTAG);
6024 				dmu_objset_userspace_upgrade(zfsvfs->z_os);
6025 				dsl_pool_config_exit(
6026 				    dmu_objset_pool(zfsvfs->z_os), FTAG);
6027 			} else {
6028 				mutex_exit(&zfsvfs->z_os->os_upgrade_lock);
6029 			}
6030 
6031 			taskq_wait_id(zfsvfs->z_os->os_spa->spa_upgrade_taskq,
6032 			    zfsvfs->z_os->os_upgrade_id);
6033 			error = zfsvfs->z_os->os_upgrade_status;
6034 		}
6035 		zfs_vfs_rele(zfsvfs);
6036 	} else {
6037 		objset_t *os;
6038 
6039 		/* XXX kind of reading contents without owning */
6040 		error = dmu_objset_hold_flags(zc->zc_name, B_TRUE, FTAG, &os);
6041 		if (error != 0)
6042 			return (error);
6043 
6044 		mutex_enter(&os->os_upgrade_lock);
6045 		if (os->os_upgrade_id == 0) {
6046 			/* clear potential error code and retry */
6047 			os->os_upgrade_status = 0;
6048 			mutex_exit(&os->os_upgrade_lock);
6049 
6050 			dmu_objset_userspace_upgrade(os);
6051 		} else {
6052 			mutex_exit(&os->os_upgrade_lock);
6053 		}
6054 
6055 		dsl_pool_rele(dmu_objset_pool(os), FTAG);
6056 
6057 		taskq_wait_id(os->os_spa->spa_upgrade_taskq, os->os_upgrade_id);
6058 		error = os->os_upgrade_status;
6059 
6060 		dsl_dataset_rele_flags(dmu_objset_ds(os), DS_HOLD_FLAG_DECRYPT,
6061 		    FTAG);
6062 	}
6063 	return (error);
6064 }
6065 
6066 /*
6067  * inputs:
6068  * zc_name		name of filesystem
6069  *
6070  * outputs:
6071  * none
6072  */
6073 static int
6074 zfs_ioc_id_quota_upgrade(zfs_cmd_t *zc)
6075 {
6076 	objset_t *os;
6077 	int error;
6078 
6079 	error = dmu_objset_hold_flags(zc->zc_name, B_TRUE, FTAG, &os);
6080 	if (error != 0)
6081 		return (error);
6082 
6083 	if (dmu_objset_userobjspace_upgradable(os) ||
6084 	    dmu_objset_projectquota_upgradable(os)) {
6085 		mutex_enter(&os->os_upgrade_lock);
6086 		if (os->os_upgrade_id == 0) {
6087 			/* clear potential error code and retry */
6088 			os->os_upgrade_status = 0;
6089 			mutex_exit(&os->os_upgrade_lock);
6090 
6091 			dmu_objset_id_quota_upgrade(os);
6092 		} else {
6093 			mutex_exit(&os->os_upgrade_lock);
6094 		}
6095 
6096 		dsl_pool_rele(dmu_objset_pool(os), FTAG);
6097 
6098 		taskq_wait_id(os->os_spa->spa_upgrade_taskq, os->os_upgrade_id);
6099 		error = os->os_upgrade_status;
6100 	} else {
6101 		dsl_pool_rele(dmu_objset_pool(os), FTAG);
6102 	}
6103 
6104 	dsl_dataset_rele_flags(dmu_objset_ds(os), DS_HOLD_FLAG_DECRYPT, FTAG);
6105 
6106 	return (error);
6107 }
6108 
6109 static int
6110 zfs_ioc_share(zfs_cmd_t *zc)
6111 {
6112 	return (SET_ERROR(ENOSYS));
6113 }
6114 
6115 /*
6116  * inputs:
6117  * zc_name		name of containing filesystem
6118  * zc_obj		object # beyond which we want next in-use object #
6119  *
6120  * outputs:
6121  * zc_obj		next in-use object #
6122  */
6123 static int
6124 zfs_ioc_next_obj(zfs_cmd_t *zc)
6125 {
6126 	objset_t *os = NULL;
6127 	int error;
6128 
6129 	error = dmu_objset_hold(zc->zc_name, FTAG, &os);
6130 	if (error != 0)
6131 		return (error);
6132 
6133 	error = dmu_object_next(os, &zc->zc_obj, B_FALSE, 0);
6134 
6135 	dmu_objset_rele(os, FTAG);
6136 	return (error);
6137 }
6138 
6139 /*
6140  * inputs:
6141  * zc_name		name of filesystem
6142  * zc_value		prefix name for snapshot
6143  * zc_cleanup_fd	cleanup-on-exit file descriptor for calling process
6144  *
6145  * outputs:
6146  * zc_value		short name of new snapshot
6147  */
6148 static int
6149 zfs_ioc_tmp_snapshot(zfs_cmd_t *zc)
6150 {
6151 	char *snap_name;
6152 	char *hold_name;
6153 	minor_t minor;
6154 
6155 	zfs_file_t *fp = zfs_onexit_fd_hold(zc->zc_cleanup_fd, &minor);
6156 	if (fp == NULL)
6157 		return (SET_ERROR(EBADF));
6158 
6159 	snap_name = kmem_asprintf("%s-%016llx", zc->zc_value,
6160 	    (u_longlong_t)ddi_get_lbolt64());
6161 	hold_name = kmem_asprintf("%%%s", zc->zc_value);
6162 
6163 	int error = dsl_dataset_snapshot_tmp(zc->zc_name, snap_name, minor,
6164 	    hold_name);
6165 	if (error == 0)
6166 		(void) strlcpy(zc->zc_value, snap_name,
6167 		    sizeof (zc->zc_value));
6168 	kmem_strfree(snap_name);
6169 	kmem_strfree(hold_name);
6170 	zfs_onexit_fd_rele(fp);
6171 	return (error);
6172 }
6173 
6174 /*
6175  * inputs:
6176  * zc_name		name of "to" snapshot
6177  * zc_value		name of "from" snapshot
6178  * zc_cookie		file descriptor to write diff data on
6179  *
6180  * outputs:
6181  * dmu_diff_record_t's to the file descriptor
6182  */
6183 static int
6184 zfs_ioc_diff(zfs_cmd_t *zc)
6185 {
6186 	zfs_file_t *fp;
6187 	offset_t off;
6188 	int error;
6189 
6190 	if ((fp = zfs_file_get(zc->zc_cookie)) == NULL)
6191 		return (SET_ERROR(EBADF));
6192 
6193 	off = zfs_file_off(fp);
6194 	error = dmu_diff(zc->zc_name, zc->zc_value, fp, &off);
6195 
6196 	zfs_file_put(fp);
6197 
6198 	return (error);
6199 }
6200 
6201 static int
6202 zfs_ioc_smb_acl(zfs_cmd_t *zc)
6203 {
6204 	return (SET_ERROR(ENOTSUP));
6205 }
6206 
6207 /*
6208  * innvl: {
6209  *     "holds" -> { snapname -> holdname (string), ... }
6210  *     (optional) "cleanup_fd" -> fd (int32)
6211  * }
6212  *
6213  * outnvl: {
6214  *     snapname -> error value (int32)
6215  *     ...
6216  * }
6217  */
6218 static const zfs_ioc_key_t zfs_keys_hold[] = {
6219 	{"holds",		DATA_TYPE_NVLIST,	0},
6220 	{"cleanup_fd",		DATA_TYPE_INT32,	ZK_OPTIONAL},
6221 };
6222 
6223 static int
6224 zfs_ioc_hold(const char *pool, nvlist_t *args, nvlist_t *errlist)
6225 {
6226 	(void) pool;
6227 	nvpair_t *pair;
6228 	nvlist_t *holds;
6229 	int cleanup_fd = -1;
6230 	int error;
6231 	minor_t minor = 0;
6232 	zfs_file_t *fp = NULL;
6233 
6234 	holds = fnvlist_lookup_nvlist(args, "holds");
6235 
6236 	/* make sure the user didn't pass us any invalid (empty) tags */
6237 	for (pair = nvlist_next_nvpair(holds, NULL); pair != NULL;
6238 	    pair = nvlist_next_nvpair(holds, pair)) {
6239 		char *htag;
6240 
6241 		error = nvpair_value_string(pair, &htag);
6242 		if (error != 0)
6243 			return (SET_ERROR(error));
6244 
6245 		if (strlen(htag) == 0)
6246 			return (SET_ERROR(EINVAL));
6247 	}
6248 
6249 	if (nvlist_lookup_int32(args, "cleanup_fd", &cleanup_fd) == 0) {
6250 		fp = zfs_onexit_fd_hold(cleanup_fd, &minor);
6251 		if (fp == NULL)
6252 			return (SET_ERROR(EBADF));
6253 	}
6254 
6255 	error = dsl_dataset_user_hold(holds, minor, errlist);
6256 	if (fp != NULL) {
6257 		ASSERT3U(minor, !=, 0);
6258 		zfs_onexit_fd_rele(fp);
6259 	}
6260 	return (SET_ERROR(error));
6261 }
6262 
6263 /*
6264  * innvl is not used.
6265  *
6266  * outnvl: {
6267  *    holdname -> time added (uint64 seconds since epoch)
6268  *    ...
6269  * }
6270  */
6271 static const zfs_ioc_key_t zfs_keys_get_holds[] = {
6272 	/* no nvl keys */
6273 };
6274 
6275 static int
6276 zfs_ioc_get_holds(const char *snapname, nvlist_t *args, nvlist_t *outnvl)
6277 {
6278 	(void) args;
6279 	return (dsl_dataset_get_holds(snapname, outnvl));
6280 }
6281 
6282 /*
6283  * innvl: {
6284  *     snapname -> { holdname, ... }
6285  *     ...
6286  * }
6287  *
6288  * outnvl: {
6289  *     snapname -> error value (int32)
6290  *     ...
6291  * }
6292  */
6293 static const zfs_ioc_key_t zfs_keys_release[] = {
6294 	{"<snapname>...",	DATA_TYPE_NVLIST,	ZK_WILDCARDLIST},
6295 };
6296 
6297 static int
6298 zfs_ioc_release(const char *pool, nvlist_t *holds, nvlist_t *errlist)
6299 {
6300 	(void) pool;
6301 	return (dsl_dataset_user_release(holds, errlist));
6302 }
6303 
6304 /*
6305  * inputs:
6306  * zc_guid		flags (ZEVENT_NONBLOCK)
6307  * zc_cleanup_fd	zevent file descriptor
6308  *
6309  * outputs:
6310  * zc_nvlist_dst	next nvlist event
6311  * zc_cookie		dropped events since last get
6312  */
6313 static int
6314 zfs_ioc_events_next(zfs_cmd_t *zc)
6315 {
6316 	zfs_zevent_t *ze;
6317 	nvlist_t *event = NULL;
6318 	minor_t minor;
6319 	uint64_t dropped = 0;
6320 	int error;
6321 
6322 	zfs_file_t *fp = zfs_zevent_fd_hold(zc->zc_cleanup_fd, &minor, &ze);
6323 	if (fp == NULL)
6324 		return (SET_ERROR(EBADF));
6325 
6326 	do {
6327 		error = zfs_zevent_next(ze, &event,
6328 		    &zc->zc_nvlist_dst_size, &dropped);
6329 		if (event != NULL) {
6330 			zc->zc_cookie = dropped;
6331 			error = put_nvlist(zc, event);
6332 			nvlist_free(event);
6333 		}
6334 
6335 		if (zc->zc_guid & ZEVENT_NONBLOCK)
6336 			break;
6337 
6338 		if ((error == 0) || (error != ENOENT))
6339 			break;
6340 
6341 		error = zfs_zevent_wait(ze);
6342 		if (error != 0)
6343 			break;
6344 	} while (1);
6345 
6346 	zfs_zevent_fd_rele(fp);
6347 
6348 	return (error);
6349 }
6350 
6351 /*
6352  * outputs:
6353  * zc_cookie		cleared events count
6354  */
6355 static int
6356 zfs_ioc_events_clear(zfs_cmd_t *zc)
6357 {
6358 	int count;
6359 
6360 	zfs_zevent_drain_all(&count);
6361 	zc->zc_cookie = count;
6362 
6363 	return (0);
6364 }
6365 
6366 /*
6367  * inputs:
6368  * zc_guid		eid | ZEVENT_SEEK_START | ZEVENT_SEEK_END
6369  * zc_cleanup		zevent file descriptor
6370  */
6371 static int
6372 zfs_ioc_events_seek(zfs_cmd_t *zc)
6373 {
6374 	zfs_zevent_t *ze;
6375 	minor_t minor;
6376 	int error;
6377 
6378 	zfs_file_t *fp = zfs_zevent_fd_hold(zc->zc_cleanup_fd, &minor, &ze);
6379 	if (fp == NULL)
6380 		return (SET_ERROR(EBADF));
6381 
6382 	error = zfs_zevent_seek(ze, zc->zc_guid);
6383 	zfs_zevent_fd_rele(fp);
6384 
6385 	return (error);
6386 }
6387 
6388 /*
6389  * inputs:
6390  * zc_name		name of later filesystem or snapshot
6391  * zc_value		full name of old snapshot or bookmark
6392  *
6393  * outputs:
6394  * zc_cookie		space in bytes
6395  * zc_objset_type	compressed space in bytes
6396  * zc_perm_action	uncompressed space in bytes
6397  */
6398 static int
6399 zfs_ioc_space_written(zfs_cmd_t *zc)
6400 {
6401 	int error;
6402 	dsl_pool_t *dp;
6403 	dsl_dataset_t *new;
6404 
6405 	error = dsl_pool_hold(zc->zc_name, FTAG, &dp);
6406 	if (error != 0)
6407 		return (error);
6408 	error = dsl_dataset_hold(dp, zc->zc_name, FTAG, &new);
6409 	if (error != 0) {
6410 		dsl_pool_rele(dp, FTAG);
6411 		return (error);
6412 	}
6413 	if (strchr(zc->zc_value, '#') != NULL) {
6414 		zfs_bookmark_phys_t bmp;
6415 		error = dsl_bookmark_lookup(dp, zc->zc_value,
6416 		    new, &bmp);
6417 		if (error == 0) {
6418 			error = dsl_dataset_space_written_bookmark(&bmp, new,
6419 			    &zc->zc_cookie,
6420 			    &zc->zc_objset_type, &zc->zc_perm_action);
6421 		}
6422 	} else {
6423 		dsl_dataset_t *old;
6424 		error = dsl_dataset_hold(dp, zc->zc_value, FTAG, &old);
6425 
6426 		if (error == 0) {
6427 			error = dsl_dataset_space_written(old, new,
6428 			    &zc->zc_cookie,
6429 			    &zc->zc_objset_type, &zc->zc_perm_action);
6430 			dsl_dataset_rele(old, FTAG);
6431 		}
6432 	}
6433 	dsl_dataset_rele(new, FTAG);
6434 	dsl_pool_rele(dp, FTAG);
6435 	return (error);
6436 }
6437 
6438 /*
6439  * innvl: {
6440  *     "firstsnap" -> snapshot name
6441  * }
6442  *
6443  * outnvl: {
6444  *     "used" -> space in bytes
6445  *     "compressed" -> compressed space in bytes
6446  *     "uncompressed" -> uncompressed space in bytes
6447  * }
6448  */
6449 static const zfs_ioc_key_t zfs_keys_space_snaps[] = {
6450 	{"firstsnap",	DATA_TYPE_STRING,	0},
6451 };
6452 
6453 static int
6454 zfs_ioc_space_snaps(const char *lastsnap, nvlist_t *innvl, nvlist_t *outnvl)
6455 {
6456 	int error;
6457 	dsl_pool_t *dp;
6458 	dsl_dataset_t *new, *old;
6459 	char *firstsnap;
6460 	uint64_t used, comp, uncomp;
6461 
6462 	firstsnap = fnvlist_lookup_string(innvl, "firstsnap");
6463 
6464 	error = dsl_pool_hold(lastsnap, FTAG, &dp);
6465 	if (error != 0)
6466 		return (error);
6467 
6468 	error = dsl_dataset_hold(dp, lastsnap, FTAG, &new);
6469 	if (error == 0 && !new->ds_is_snapshot) {
6470 		dsl_dataset_rele(new, FTAG);
6471 		error = SET_ERROR(EINVAL);
6472 	}
6473 	if (error != 0) {
6474 		dsl_pool_rele(dp, FTAG);
6475 		return (error);
6476 	}
6477 	error = dsl_dataset_hold(dp, firstsnap, FTAG, &old);
6478 	if (error == 0 && !old->ds_is_snapshot) {
6479 		dsl_dataset_rele(old, FTAG);
6480 		error = SET_ERROR(EINVAL);
6481 	}
6482 	if (error != 0) {
6483 		dsl_dataset_rele(new, FTAG);
6484 		dsl_pool_rele(dp, FTAG);
6485 		return (error);
6486 	}
6487 
6488 	error = dsl_dataset_space_wouldfree(old, new, &used, &comp, &uncomp);
6489 	dsl_dataset_rele(old, FTAG);
6490 	dsl_dataset_rele(new, FTAG);
6491 	dsl_pool_rele(dp, FTAG);
6492 	fnvlist_add_uint64(outnvl, "used", used);
6493 	fnvlist_add_uint64(outnvl, "compressed", comp);
6494 	fnvlist_add_uint64(outnvl, "uncompressed", uncomp);
6495 	return (error);
6496 }
6497 
6498 /*
6499  * innvl: {
6500  *     "fd" -> file descriptor to write stream to (int32)
6501  *     (optional) "fromsnap" -> full snap name to send an incremental from
6502  *     (optional) "largeblockok" -> (value ignored)
6503  *         indicates that blocks > 128KB are permitted
6504  *     (optional) "embedok" -> (value ignored)
6505  *         presence indicates DRR_WRITE_EMBEDDED records are permitted
6506  *     (optional) "compressok" -> (value ignored)
6507  *         presence indicates compressed DRR_WRITE records are permitted
6508  *     (optional) "rawok" -> (value ignored)
6509  *         presence indicates raw encrypted records should be used.
6510  *     (optional) "savedok" -> (value ignored)
6511  *         presence indicates we should send a partially received snapshot
6512  *     (optional) "resume_object" and "resume_offset" -> (uint64)
6513  *         if present, resume send stream from specified object and offset.
6514  *     (optional) "redactbook" -> (string)
6515  *         if present, use this bookmark's redaction list to generate a redacted
6516  *         send stream
6517  * }
6518  *
6519  * outnvl is unused
6520  */
6521 static const zfs_ioc_key_t zfs_keys_send_new[] = {
6522 	{"fd",			DATA_TYPE_INT32,	0},
6523 	{"fromsnap",		DATA_TYPE_STRING,	ZK_OPTIONAL},
6524 	{"largeblockok",	DATA_TYPE_BOOLEAN,	ZK_OPTIONAL},
6525 	{"embedok",		DATA_TYPE_BOOLEAN,	ZK_OPTIONAL},
6526 	{"compressok",		DATA_TYPE_BOOLEAN,	ZK_OPTIONAL},
6527 	{"rawok",		DATA_TYPE_BOOLEAN,	ZK_OPTIONAL},
6528 	{"savedok",		DATA_TYPE_BOOLEAN,	ZK_OPTIONAL},
6529 	{"resume_object",	DATA_TYPE_UINT64,	ZK_OPTIONAL},
6530 	{"resume_offset",	DATA_TYPE_UINT64,	ZK_OPTIONAL},
6531 	{"redactbook",		DATA_TYPE_STRING,	ZK_OPTIONAL},
6532 };
6533 
6534 static int
6535 zfs_ioc_send_new(const char *snapname, nvlist_t *innvl, nvlist_t *outnvl)
6536 {
6537 	(void) outnvl;
6538 	int error;
6539 	offset_t off;
6540 	char *fromname = NULL;
6541 	int fd;
6542 	zfs_file_t *fp;
6543 	boolean_t largeblockok;
6544 	boolean_t embedok;
6545 	boolean_t compressok;
6546 	boolean_t rawok;
6547 	boolean_t savedok;
6548 	uint64_t resumeobj = 0;
6549 	uint64_t resumeoff = 0;
6550 	char *redactbook = NULL;
6551 
6552 	fd = fnvlist_lookup_int32(innvl, "fd");
6553 
6554 	(void) nvlist_lookup_string(innvl, "fromsnap", &fromname);
6555 
6556 	largeblockok = nvlist_exists(innvl, "largeblockok");
6557 	embedok = nvlist_exists(innvl, "embedok");
6558 	compressok = nvlist_exists(innvl, "compressok");
6559 	rawok = nvlist_exists(innvl, "rawok");
6560 	savedok = nvlist_exists(innvl, "savedok");
6561 
6562 	(void) nvlist_lookup_uint64(innvl, "resume_object", &resumeobj);
6563 	(void) nvlist_lookup_uint64(innvl, "resume_offset", &resumeoff);
6564 
6565 	(void) nvlist_lookup_string(innvl, "redactbook", &redactbook);
6566 
6567 	if ((fp = zfs_file_get(fd)) == NULL)
6568 		return (SET_ERROR(EBADF));
6569 
6570 	off = zfs_file_off(fp);
6571 
6572 	dmu_send_outparams_t out = {0};
6573 	out.dso_outfunc = dump_bytes;
6574 	out.dso_arg = fp;
6575 	out.dso_dryrun = B_FALSE;
6576 	error = dmu_send(snapname, fromname, embedok, largeblockok,
6577 	    compressok, rawok, savedok, resumeobj, resumeoff,
6578 	    redactbook, fd, &off, &out);
6579 
6580 	zfs_file_put(fp);
6581 	return (error);
6582 }
6583 
6584 static int
6585 send_space_sum(objset_t *os, void *buf, int len, void *arg)
6586 {
6587 	(void) os, (void) buf;
6588 	uint64_t *size = arg;
6589 
6590 	*size += len;
6591 	return (0);
6592 }
6593 
6594 /*
6595  * Determine approximately how large a zfs send stream will be -- the number
6596  * of bytes that will be written to the fd supplied to zfs_ioc_send_new().
6597  *
6598  * innvl: {
6599  *     (optional) "from" -> full snap or bookmark name to send an incremental
6600  *                          from
6601  *     (optional) "largeblockok" -> (value ignored)
6602  *         indicates that blocks > 128KB are permitted
6603  *     (optional) "embedok" -> (value ignored)
6604  *         presence indicates DRR_WRITE_EMBEDDED records are permitted
6605  *     (optional) "compressok" -> (value ignored)
6606  *         presence indicates compressed DRR_WRITE records are permitted
6607  *     (optional) "rawok" -> (value ignored)
6608  *         presence indicates raw encrypted records should be used.
6609  *     (optional) "resume_object" and "resume_offset" -> (uint64)
6610  *         if present, resume send stream from specified object and offset.
6611  *     (optional) "fd" -> file descriptor to use as a cookie for progress
6612  *         tracking (int32)
6613  * }
6614  *
6615  * outnvl: {
6616  *     "space" -> bytes of space (uint64)
6617  * }
6618  */
6619 static const zfs_ioc_key_t zfs_keys_send_space[] = {
6620 	{"from",		DATA_TYPE_STRING,	ZK_OPTIONAL},
6621 	{"fromsnap",		DATA_TYPE_STRING,	ZK_OPTIONAL},
6622 	{"largeblockok",	DATA_TYPE_BOOLEAN,	ZK_OPTIONAL},
6623 	{"embedok",		DATA_TYPE_BOOLEAN,	ZK_OPTIONAL},
6624 	{"compressok",		DATA_TYPE_BOOLEAN,	ZK_OPTIONAL},
6625 	{"rawok",		DATA_TYPE_BOOLEAN,	ZK_OPTIONAL},
6626 	{"fd",			DATA_TYPE_INT32,	ZK_OPTIONAL},
6627 	{"redactbook",		DATA_TYPE_STRING,	ZK_OPTIONAL},
6628 	{"resume_object",	DATA_TYPE_UINT64,	ZK_OPTIONAL},
6629 	{"resume_offset",	DATA_TYPE_UINT64,	ZK_OPTIONAL},
6630 	{"bytes",		DATA_TYPE_UINT64,	ZK_OPTIONAL},
6631 };
6632 
6633 static int
6634 zfs_ioc_send_space(const char *snapname, nvlist_t *innvl, nvlist_t *outnvl)
6635 {
6636 	dsl_pool_t *dp;
6637 	dsl_dataset_t *tosnap;
6638 	dsl_dataset_t *fromsnap = NULL;
6639 	int error;
6640 	char *fromname = NULL;
6641 	char *redactlist_book = NULL;
6642 	boolean_t largeblockok;
6643 	boolean_t embedok;
6644 	boolean_t compressok;
6645 	boolean_t rawok;
6646 	boolean_t savedok;
6647 	uint64_t space = 0;
6648 	boolean_t full_estimate = B_FALSE;
6649 	uint64_t resumeobj = 0;
6650 	uint64_t resumeoff = 0;
6651 	uint64_t resume_bytes = 0;
6652 	int32_t fd = -1;
6653 	zfs_bookmark_phys_t zbm = {0};
6654 
6655 	error = dsl_pool_hold(snapname, FTAG, &dp);
6656 	if (error != 0)
6657 		return (error);
6658 
6659 	error = dsl_dataset_hold(dp, snapname, FTAG, &tosnap);
6660 	if (error != 0) {
6661 		dsl_pool_rele(dp, FTAG);
6662 		return (error);
6663 	}
6664 	(void) nvlist_lookup_int32(innvl, "fd", &fd);
6665 
6666 	largeblockok = nvlist_exists(innvl, "largeblockok");
6667 	embedok = nvlist_exists(innvl, "embedok");
6668 	compressok = nvlist_exists(innvl, "compressok");
6669 	rawok = nvlist_exists(innvl, "rawok");
6670 	savedok = nvlist_exists(innvl, "savedok");
6671 	boolean_t from = (nvlist_lookup_string(innvl, "from", &fromname) == 0);
6672 	boolean_t altbook = (nvlist_lookup_string(innvl, "redactbook",
6673 	    &redactlist_book) == 0);
6674 
6675 	(void) nvlist_lookup_uint64(innvl, "resume_object", &resumeobj);
6676 	(void) nvlist_lookup_uint64(innvl, "resume_offset", &resumeoff);
6677 	(void) nvlist_lookup_uint64(innvl, "bytes", &resume_bytes);
6678 
6679 	if (altbook) {
6680 		full_estimate = B_TRUE;
6681 	} else if (from) {
6682 		if (strchr(fromname, '#')) {
6683 			error = dsl_bookmark_lookup(dp, fromname, tosnap, &zbm);
6684 
6685 			/*
6686 			 * dsl_bookmark_lookup() will fail with EXDEV if
6687 			 * the from-bookmark and tosnap are at the same txg.
6688 			 * However, it's valid to do a send (and therefore,
6689 			 * a send estimate) from and to the same time point,
6690 			 * if the bookmark is redacted (the incremental send
6691 			 * can change what's redacted on the target).  In
6692 			 * this case, dsl_bookmark_lookup() fills in zbm
6693 			 * but returns EXDEV.  Ignore this error.
6694 			 */
6695 			if (error == EXDEV && zbm.zbm_redaction_obj != 0 &&
6696 			    zbm.zbm_guid ==
6697 			    dsl_dataset_phys(tosnap)->ds_guid)
6698 				error = 0;
6699 
6700 			if (error != 0) {
6701 				dsl_dataset_rele(tosnap, FTAG);
6702 				dsl_pool_rele(dp, FTAG);
6703 				return (error);
6704 			}
6705 			if (zbm.zbm_redaction_obj != 0 || !(zbm.zbm_flags &
6706 			    ZBM_FLAG_HAS_FBN)) {
6707 				full_estimate = B_TRUE;
6708 			}
6709 		} else if (strchr(fromname, '@')) {
6710 			error = dsl_dataset_hold(dp, fromname, FTAG, &fromsnap);
6711 			if (error != 0) {
6712 				dsl_dataset_rele(tosnap, FTAG);
6713 				dsl_pool_rele(dp, FTAG);
6714 				return (error);
6715 			}
6716 
6717 			if (!dsl_dataset_is_before(tosnap, fromsnap, 0)) {
6718 				full_estimate = B_TRUE;
6719 				dsl_dataset_rele(fromsnap, FTAG);
6720 			}
6721 		} else {
6722 			/*
6723 			 * from is not properly formatted as a snapshot or
6724 			 * bookmark
6725 			 */
6726 			dsl_dataset_rele(tosnap, FTAG);
6727 			dsl_pool_rele(dp, FTAG);
6728 			return (SET_ERROR(EINVAL));
6729 		}
6730 	}
6731 
6732 	if (full_estimate) {
6733 		dmu_send_outparams_t out = {0};
6734 		offset_t off = 0;
6735 		out.dso_outfunc = send_space_sum;
6736 		out.dso_arg = &space;
6737 		out.dso_dryrun = B_TRUE;
6738 		/*
6739 		 * We have to release these holds so dmu_send can take them.  It
6740 		 * will do all the error checking we need.
6741 		 */
6742 		dsl_dataset_rele(tosnap, FTAG);
6743 		dsl_pool_rele(dp, FTAG);
6744 		error = dmu_send(snapname, fromname, embedok, largeblockok,
6745 		    compressok, rawok, savedok, resumeobj, resumeoff,
6746 		    redactlist_book, fd, &off, &out);
6747 	} else {
6748 		error = dmu_send_estimate_fast(tosnap, fromsnap,
6749 		    (from && strchr(fromname, '#') != NULL ? &zbm : NULL),
6750 		    compressok || rawok, savedok, &space);
6751 		space -= resume_bytes;
6752 		if (fromsnap != NULL)
6753 			dsl_dataset_rele(fromsnap, FTAG);
6754 		dsl_dataset_rele(tosnap, FTAG);
6755 		dsl_pool_rele(dp, FTAG);
6756 	}
6757 
6758 	fnvlist_add_uint64(outnvl, "space", space);
6759 
6760 	return (error);
6761 }
6762 
6763 /*
6764  * Sync the currently open TXG to disk for the specified pool.
6765  * This is somewhat similar to 'zfs_sync()'.
6766  * For cases that do not result in error this ioctl will wait for
6767  * the currently open TXG to commit before returning back to the caller.
6768  *
6769  * innvl: {
6770  *  "force" -> when true, force uberblock update even if there is no dirty data.
6771  *             In addition this will cause the vdev configuration to be written
6772  *             out including updating the zpool cache file. (boolean_t)
6773  * }
6774  *
6775  * onvl is unused
6776  */
6777 static const zfs_ioc_key_t zfs_keys_pool_sync[] = {
6778 	{"force",	DATA_TYPE_BOOLEAN_VALUE,	0},
6779 };
6780 
6781 static int
6782 zfs_ioc_pool_sync(const char *pool, nvlist_t *innvl, nvlist_t *onvl)
6783 {
6784 	(void) onvl;
6785 	int err;
6786 	boolean_t rc, force = B_FALSE;
6787 	spa_t *spa;
6788 
6789 	if ((err = spa_open(pool, &spa, FTAG)) != 0)
6790 		return (err);
6791 
6792 	if (innvl) {
6793 		err = nvlist_lookup_boolean_value(innvl, "force", &rc);
6794 		if (err == 0)
6795 			force = rc;
6796 	}
6797 
6798 	if (force) {
6799 		spa_config_enter(spa, SCL_CONFIG, FTAG, RW_WRITER);
6800 		vdev_config_dirty(spa->spa_root_vdev);
6801 		spa_config_exit(spa, SCL_CONFIG, FTAG);
6802 	}
6803 	txg_wait_synced(spa_get_dsl(spa), 0);
6804 
6805 	spa_close(spa, FTAG);
6806 
6807 	return (0);
6808 }
6809 
6810 /*
6811  * Load a user's wrapping key into the kernel.
6812  * innvl: {
6813  *     "hidden_args" -> { "wkeydata" -> value }
6814  *         raw uint8_t array of encryption wrapping key data (32 bytes)
6815  *     (optional) "noop" -> (value ignored)
6816  *         presence indicated key should only be verified, not loaded
6817  * }
6818  */
6819 static const zfs_ioc_key_t zfs_keys_load_key[] = {
6820 	{"hidden_args",	DATA_TYPE_NVLIST,	0},
6821 	{"noop",	DATA_TYPE_BOOLEAN,	ZK_OPTIONAL},
6822 };
6823 
6824 static int
6825 zfs_ioc_load_key(const char *dsname, nvlist_t *innvl, nvlist_t *outnvl)
6826 {
6827 	(void) outnvl;
6828 	int ret;
6829 	dsl_crypto_params_t *dcp = NULL;
6830 	nvlist_t *hidden_args;
6831 	boolean_t noop = nvlist_exists(innvl, "noop");
6832 
6833 	if (strchr(dsname, '@') != NULL || strchr(dsname, '%') != NULL) {
6834 		ret = SET_ERROR(EINVAL);
6835 		goto error;
6836 	}
6837 
6838 	hidden_args = fnvlist_lookup_nvlist(innvl, ZPOOL_HIDDEN_ARGS);
6839 
6840 	ret = dsl_crypto_params_create_nvlist(DCP_CMD_NONE, NULL,
6841 	    hidden_args, &dcp);
6842 	if (ret != 0)
6843 		goto error;
6844 
6845 	ret = spa_keystore_load_wkey(dsname, dcp, noop);
6846 	if (ret != 0)
6847 		goto error;
6848 
6849 	dsl_crypto_params_free(dcp, noop);
6850 
6851 	return (0);
6852 
6853 error:
6854 	dsl_crypto_params_free(dcp, B_TRUE);
6855 	return (ret);
6856 }
6857 
6858 /*
6859  * Unload a user's wrapping key from the kernel.
6860  * Both innvl and outnvl are unused.
6861  */
6862 static const zfs_ioc_key_t zfs_keys_unload_key[] = {
6863 	/* no nvl keys */
6864 };
6865 
6866 static int
6867 zfs_ioc_unload_key(const char *dsname, nvlist_t *innvl, nvlist_t *outnvl)
6868 {
6869 	(void) innvl, (void) outnvl;
6870 	int ret = 0;
6871 
6872 	if (strchr(dsname, '@') != NULL || strchr(dsname, '%') != NULL) {
6873 		ret = (SET_ERROR(EINVAL));
6874 		goto out;
6875 	}
6876 
6877 	ret = spa_keystore_unload_wkey(dsname);
6878 	if (ret != 0)
6879 		goto out;
6880 
6881 out:
6882 	return (ret);
6883 }
6884 
6885 /*
6886  * Changes a user's wrapping key used to decrypt a dataset. The keyformat,
6887  * keylocation, pbkdf2salt, and pbkdf2iters properties can also be specified
6888  * here to change how the key is derived in userspace.
6889  *
6890  * innvl: {
6891  *    "hidden_args" (optional) -> { "wkeydata" -> value }
6892  *         raw uint8_t array of new encryption wrapping key data (32 bytes)
6893  *    "props" (optional) -> { prop -> value }
6894  * }
6895  *
6896  * outnvl is unused
6897  */
6898 static const zfs_ioc_key_t zfs_keys_change_key[] = {
6899 	{"crypt_cmd",	DATA_TYPE_UINT64,	ZK_OPTIONAL},
6900 	{"hidden_args",	DATA_TYPE_NVLIST,	ZK_OPTIONAL},
6901 	{"props",	DATA_TYPE_NVLIST,	ZK_OPTIONAL},
6902 };
6903 
6904 static int
6905 zfs_ioc_change_key(const char *dsname, nvlist_t *innvl, nvlist_t *outnvl)
6906 {
6907 	(void) outnvl;
6908 	int ret;
6909 	uint64_t cmd = DCP_CMD_NONE;
6910 	dsl_crypto_params_t *dcp = NULL;
6911 	nvlist_t *args = NULL, *hidden_args = NULL;
6912 
6913 	if (strchr(dsname, '@') != NULL || strchr(dsname, '%') != NULL) {
6914 		ret = (SET_ERROR(EINVAL));
6915 		goto error;
6916 	}
6917 
6918 	(void) nvlist_lookup_uint64(innvl, "crypt_cmd", &cmd);
6919 	(void) nvlist_lookup_nvlist(innvl, "props", &args);
6920 	(void) nvlist_lookup_nvlist(innvl, ZPOOL_HIDDEN_ARGS, &hidden_args);
6921 
6922 	ret = dsl_crypto_params_create_nvlist(cmd, args, hidden_args, &dcp);
6923 	if (ret != 0)
6924 		goto error;
6925 
6926 	ret = spa_keystore_change_key(dsname, dcp);
6927 	if (ret != 0)
6928 		goto error;
6929 
6930 	dsl_crypto_params_free(dcp, B_FALSE);
6931 
6932 	return (0);
6933 
6934 error:
6935 	dsl_crypto_params_free(dcp, B_TRUE);
6936 	return (ret);
6937 }
6938 
6939 static zfs_ioc_vec_t zfs_ioc_vec[ZFS_IOC_LAST - ZFS_IOC_FIRST];
6940 
6941 static void
6942 zfs_ioctl_register_legacy(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func,
6943     zfs_secpolicy_func_t *secpolicy, zfs_ioc_namecheck_t namecheck,
6944     boolean_t log_history, zfs_ioc_poolcheck_t pool_check)
6945 {
6946 	zfs_ioc_vec_t *vec = &zfs_ioc_vec[ioc - ZFS_IOC_FIRST];
6947 
6948 	ASSERT3U(ioc, >=, ZFS_IOC_FIRST);
6949 	ASSERT3U(ioc, <, ZFS_IOC_LAST);
6950 	ASSERT3P(vec->zvec_legacy_func, ==, NULL);
6951 	ASSERT3P(vec->zvec_func, ==, NULL);
6952 
6953 	vec->zvec_legacy_func = func;
6954 	vec->zvec_secpolicy = secpolicy;
6955 	vec->zvec_namecheck = namecheck;
6956 	vec->zvec_allow_log = log_history;
6957 	vec->zvec_pool_check = pool_check;
6958 }
6959 
6960 /*
6961  * See the block comment at the beginning of this file for details on
6962  * each argument to this function.
6963  */
6964 void
6965 zfs_ioctl_register(const char *name, zfs_ioc_t ioc, zfs_ioc_func_t *func,
6966     zfs_secpolicy_func_t *secpolicy, zfs_ioc_namecheck_t namecheck,
6967     zfs_ioc_poolcheck_t pool_check, boolean_t smush_outnvlist,
6968     boolean_t allow_log, const zfs_ioc_key_t *nvl_keys, size_t num_keys)
6969 {
6970 	zfs_ioc_vec_t *vec = &zfs_ioc_vec[ioc - ZFS_IOC_FIRST];
6971 
6972 	ASSERT3U(ioc, >=, ZFS_IOC_FIRST);
6973 	ASSERT3U(ioc, <, ZFS_IOC_LAST);
6974 	ASSERT3P(vec->zvec_legacy_func, ==, NULL);
6975 	ASSERT3P(vec->zvec_func, ==, NULL);
6976 
6977 	/* if we are logging, the name must be valid */
6978 	ASSERT(!allow_log || namecheck != NO_NAME);
6979 
6980 	vec->zvec_name = name;
6981 	vec->zvec_func = func;
6982 	vec->zvec_secpolicy = secpolicy;
6983 	vec->zvec_namecheck = namecheck;
6984 	vec->zvec_pool_check = pool_check;
6985 	vec->zvec_smush_outnvlist = smush_outnvlist;
6986 	vec->zvec_allow_log = allow_log;
6987 	vec->zvec_nvl_keys = nvl_keys;
6988 	vec->zvec_nvl_key_count = num_keys;
6989 }
6990 
6991 static void
6992 zfs_ioctl_register_pool(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func,
6993     zfs_secpolicy_func_t *secpolicy, boolean_t log_history,
6994     zfs_ioc_poolcheck_t pool_check)
6995 {
6996 	zfs_ioctl_register_legacy(ioc, func, secpolicy,
6997 	    POOL_NAME, log_history, pool_check);
6998 }
6999 
7000 void
7001 zfs_ioctl_register_dataset_nolog(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func,
7002     zfs_secpolicy_func_t *secpolicy, zfs_ioc_poolcheck_t pool_check)
7003 {
7004 	zfs_ioctl_register_legacy(ioc, func, secpolicy,
7005 	    DATASET_NAME, B_FALSE, pool_check);
7006 }
7007 
7008 static void
7009 zfs_ioctl_register_pool_modify(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func)
7010 {
7011 	zfs_ioctl_register_legacy(ioc, func, zfs_secpolicy_config,
7012 	    POOL_NAME, B_TRUE, POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY);
7013 }
7014 
7015 static void
7016 zfs_ioctl_register_pool_meta(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func,
7017     zfs_secpolicy_func_t *secpolicy)
7018 {
7019 	zfs_ioctl_register_legacy(ioc, func, secpolicy,
7020 	    NO_NAME, B_FALSE, POOL_CHECK_NONE);
7021 }
7022 
7023 static void
7024 zfs_ioctl_register_dataset_read_secpolicy(zfs_ioc_t ioc,
7025     zfs_ioc_legacy_func_t *func, zfs_secpolicy_func_t *secpolicy)
7026 {
7027 	zfs_ioctl_register_legacy(ioc, func, secpolicy,
7028 	    DATASET_NAME, B_FALSE, POOL_CHECK_SUSPENDED);
7029 }
7030 
7031 static void
7032 zfs_ioctl_register_dataset_read(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func)
7033 {
7034 	zfs_ioctl_register_dataset_read_secpolicy(ioc, func,
7035 	    zfs_secpolicy_read);
7036 }
7037 
7038 static void
7039 zfs_ioctl_register_dataset_modify(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func,
7040     zfs_secpolicy_func_t *secpolicy)
7041 {
7042 	zfs_ioctl_register_legacy(ioc, func, secpolicy,
7043 	    DATASET_NAME, B_TRUE, POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY);
7044 }
7045 
7046 static void
7047 zfs_ioctl_init(void)
7048 {
7049 	zfs_ioctl_register("snapshot", ZFS_IOC_SNAPSHOT,
7050 	    zfs_ioc_snapshot, zfs_secpolicy_snapshot, POOL_NAME,
7051 	    POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE,
7052 	    zfs_keys_snapshot, ARRAY_SIZE(zfs_keys_snapshot));
7053 
7054 	zfs_ioctl_register("log_history", ZFS_IOC_LOG_HISTORY,
7055 	    zfs_ioc_log_history, zfs_secpolicy_log_history, NO_NAME,
7056 	    POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_FALSE, B_FALSE,
7057 	    zfs_keys_log_history, ARRAY_SIZE(zfs_keys_log_history));
7058 
7059 	zfs_ioctl_register("space_snaps", ZFS_IOC_SPACE_SNAPS,
7060 	    zfs_ioc_space_snaps, zfs_secpolicy_read, DATASET_NAME,
7061 	    POOL_CHECK_SUSPENDED, B_FALSE, B_FALSE,
7062 	    zfs_keys_space_snaps, ARRAY_SIZE(zfs_keys_space_snaps));
7063 
7064 	zfs_ioctl_register("send", ZFS_IOC_SEND_NEW,
7065 	    zfs_ioc_send_new, zfs_secpolicy_send_new, DATASET_NAME,
7066 	    POOL_CHECK_SUSPENDED, B_FALSE, B_FALSE,
7067 	    zfs_keys_send_new, ARRAY_SIZE(zfs_keys_send_new));
7068 
7069 	zfs_ioctl_register("send_space", ZFS_IOC_SEND_SPACE,
7070 	    zfs_ioc_send_space, zfs_secpolicy_read, DATASET_NAME,
7071 	    POOL_CHECK_SUSPENDED, B_FALSE, B_FALSE,
7072 	    zfs_keys_send_space, ARRAY_SIZE(zfs_keys_send_space));
7073 
7074 	zfs_ioctl_register("create", ZFS_IOC_CREATE,
7075 	    zfs_ioc_create, zfs_secpolicy_create_clone, DATASET_NAME,
7076 	    POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE,
7077 	    zfs_keys_create, ARRAY_SIZE(zfs_keys_create));
7078 
7079 	zfs_ioctl_register("clone", ZFS_IOC_CLONE,
7080 	    zfs_ioc_clone, zfs_secpolicy_create_clone, DATASET_NAME,
7081 	    POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE,
7082 	    zfs_keys_clone, ARRAY_SIZE(zfs_keys_clone));
7083 
7084 	zfs_ioctl_register("remap", ZFS_IOC_REMAP,
7085 	    zfs_ioc_remap, zfs_secpolicy_none, DATASET_NAME,
7086 	    POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_FALSE, B_TRUE,
7087 	    zfs_keys_remap, ARRAY_SIZE(zfs_keys_remap));
7088 
7089 	zfs_ioctl_register("destroy_snaps", ZFS_IOC_DESTROY_SNAPS,
7090 	    zfs_ioc_destroy_snaps, zfs_secpolicy_destroy_snaps, POOL_NAME,
7091 	    POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE,
7092 	    zfs_keys_destroy_snaps, ARRAY_SIZE(zfs_keys_destroy_snaps));
7093 
7094 	zfs_ioctl_register("hold", ZFS_IOC_HOLD,
7095 	    zfs_ioc_hold, zfs_secpolicy_hold, POOL_NAME,
7096 	    POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE,
7097 	    zfs_keys_hold, ARRAY_SIZE(zfs_keys_hold));
7098 	zfs_ioctl_register("release", ZFS_IOC_RELEASE,
7099 	    zfs_ioc_release, zfs_secpolicy_release, POOL_NAME,
7100 	    POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE,
7101 	    zfs_keys_release, ARRAY_SIZE(zfs_keys_release));
7102 
7103 	zfs_ioctl_register("get_holds", ZFS_IOC_GET_HOLDS,
7104 	    zfs_ioc_get_holds, zfs_secpolicy_read, DATASET_NAME,
7105 	    POOL_CHECK_SUSPENDED, B_FALSE, B_FALSE,
7106 	    zfs_keys_get_holds, ARRAY_SIZE(zfs_keys_get_holds));
7107 
7108 	zfs_ioctl_register("rollback", ZFS_IOC_ROLLBACK,
7109 	    zfs_ioc_rollback, zfs_secpolicy_rollback, DATASET_NAME,
7110 	    POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_FALSE, B_TRUE,
7111 	    zfs_keys_rollback, ARRAY_SIZE(zfs_keys_rollback));
7112 
7113 	zfs_ioctl_register("bookmark", ZFS_IOC_BOOKMARK,
7114 	    zfs_ioc_bookmark, zfs_secpolicy_bookmark, POOL_NAME,
7115 	    POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE,
7116 	    zfs_keys_bookmark, ARRAY_SIZE(zfs_keys_bookmark));
7117 
7118 	zfs_ioctl_register("get_bookmarks", ZFS_IOC_GET_BOOKMARKS,
7119 	    zfs_ioc_get_bookmarks, zfs_secpolicy_read, DATASET_NAME,
7120 	    POOL_CHECK_SUSPENDED, B_FALSE, B_FALSE,
7121 	    zfs_keys_get_bookmarks, ARRAY_SIZE(zfs_keys_get_bookmarks));
7122 
7123 	zfs_ioctl_register("get_bookmark_props", ZFS_IOC_GET_BOOKMARK_PROPS,
7124 	    zfs_ioc_get_bookmark_props, zfs_secpolicy_read, ENTITY_NAME,
7125 	    POOL_CHECK_SUSPENDED, B_FALSE, B_FALSE, zfs_keys_get_bookmark_props,
7126 	    ARRAY_SIZE(zfs_keys_get_bookmark_props));
7127 
7128 	zfs_ioctl_register("destroy_bookmarks", ZFS_IOC_DESTROY_BOOKMARKS,
7129 	    zfs_ioc_destroy_bookmarks, zfs_secpolicy_destroy_bookmarks,
7130 	    POOL_NAME,
7131 	    POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE,
7132 	    zfs_keys_destroy_bookmarks,
7133 	    ARRAY_SIZE(zfs_keys_destroy_bookmarks));
7134 
7135 	zfs_ioctl_register("receive", ZFS_IOC_RECV_NEW,
7136 	    zfs_ioc_recv_new, zfs_secpolicy_recv, DATASET_NAME,
7137 	    POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE,
7138 	    zfs_keys_recv_new, ARRAY_SIZE(zfs_keys_recv_new));
7139 	zfs_ioctl_register("load-key", ZFS_IOC_LOAD_KEY,
7140 	    zfs_ioc_load_key, zfs_secpolicy_load_key,
7141 	    DATASET_NAME, POOL_CHECK_SUSPENDED, B_TRUE, B_TRUE,
7142 	    zfs_keys_load_key, ARRAY_SIZE(zfs_keys_load_key));
7143 	zfs_ioctl_register("unload-key", ZFS_IOC_UNLOAD_KEY,
7144 	    zfs_ioc_unload_key, zfs_secpolicy_load_key,
7145 	    DATASET_NAME, POOL_CHECK_SUSPENDED, B_TRUE, B_TRUE,
7146 	    zfs_keys_unload_key, ARRAY_SIZE(zfs_keys_unload_key));
7147 	zfs_ioctl_register("change-key", ZFS_IOC_CHANGE_KEY,
7148 	    zfs_ioc_change_key, zfs_secpolicy_change_key,
7149 	    DATASET_NAME, POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY,
7150 	    B_TRUE, B_TRUE, zfs_keys_change_key,
7151 	    ARRAY_SIZE(zfs_keys_change_key));
7152 
7153 	zfs_ioctl_register("sync", ZFS_IOC_POOL_SYNC,
7154 	    zfs_ioc_pool_sync, zfs_secpolicy_none, POOL_NAME,
7155 	    POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_FALSE, B_FALSE,
7156 	    zfs_keys_pool_sync, ARRAY_SIZE(zfs_keys_pool_sync));
7157 	zfs_ioctl_register("reopen", ZFS_IOC_POOL_REOPEN, zfs_ioc_pool_reopen,
7158 	    zfs_secpolicy_config, POOL_NAME, POOL_CHECK_SUSPENDED, B_TRUE,
7159 	    B_TRUE, zfs_keys_pool_reopen, ARRAY_SIZE(zfs_keys_pool_reopen));
7160 
7161 	zfs_ioctl_register("channel_program", ZFS_IOC_CHANNEL_PROGRAM,
7162 	    zfs_ioc_channel_program, zfs_secpolicy_config,
7163 	    POOL_NAME, POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE,
7164 	    B_TRUE, zfs_keys_channel_program,
7165 	    ARRAY_SIZE(zfs_keys_channel_program));
7166 
7167 	zfs_ioctl_register("redact", ZFS_IOC_REDACT,
7168 	    zfs_ioc_redact, zfs_secpolicy_config, DATASET_NAME,
7169 	    POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE,
7170 	    zfs_keys_redact, ARRAY_SIZE(zfs_keys_redact));
7171 
7172 	zfs_ioctl_register("zpool_checkpoint", ZFS_IOC_POOL_CHECKPOINT,
7173 	    zfs_ioc_pool_checkpoint, zfs_secpolicy_config, POOL_NAME,
7174 	    POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE,
7175 	    zfs_keys_pool_checkpoint, ARRAY_SIZE(zfs_keys_pool_checkpoint));
7176 
7177 	zfs_ioctl_register("zpool_discard_checkpoint",
7178 	    ZFS_IOC_POOL_DISCARD_CHECKPOINT, zfs_ioc_pool_discard_checkpoint,
7179 	    zfs_secpolicy_config, POOL_NAME,
7180 	    POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE,
7181 	    zfs_keys_pool_discard_checkpoint,
7182 	    ARRAY_SIZE(zfs_keys_pool_discard_checkpoint));
7183 
7184 	zfs_ioctl_register("initialize", ZFS_IOC_POOL_INITIALIZE,
7185 	    zfs_ioc_pool_initialize, zfs_secpolicy_config, POOL_NAME,
7186 	    POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE,
7187 	    zfs_keys_pool_initialize, ARRAY_SIZE(zfs_keys_pool_initialize));
7188 
7189 	zfs_ioctl_register("trim", ZFS_IOC_POOL_TRIM,
7190 	    zfs_ioc_pool_trim, zfs_secpolicy_config, POOL_NAME,
7191 	    POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE,
7192 	    zfs_keys_pool_trim, ARRAY_SIZE(zfs_keys_pool_trim));
7193 
7194 	zfs_ioctl_register("wait", ZFS_IOC_WAIT,
7195 	    zfs_ioc_wait, zfs_secpolicy_none, POOL_NAME,
7196 	    POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_FALSE, B_FALSE,
7197 	    zfs_keys_pool_wait, ARRAY_SIZE(zfs_keys_pool_wait));
7198 
7199 	zfs_ioctl_register("wait_fs", ZFS_IOC_WAIT_FS,
7200 	    zfs_ioc_wait_fs, zfs_secpolicy_none, DATASET_NAME,
7201 	    POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_FALSE, B_FALSE,
7202 	    zfs_keys_fs_wait, ARRAY_SIZE(zfs_keys_fs_wait));
7203 
7204 	zfs_ioctl_register("set_bootenv", ZFS_IOC_SET_BOOTENV,
7205 	    zfs_ioc_set_bootenv, zfs_secpolicy_config, POOL_NAME,
7206 	    POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_FALSE, B_TRUE,
7207 	    zfs_keys_set_bootenv, ARRAY_SIZE(zfs_keys_set_bootenv));
7208 
7209 	zfs_ioctl_register("get_bootenv", ZFS_IOC_GET_BOOTENV,
7210 	    zfs_ioc_get_bootenv, zfs_secpolicy_none, POOL_NAME,
7211 	    POOL_CHECK_SUSPENDED, B_FALSE, B_TRUE,
7212 	    zfs_keys_get_bootenv, ARRAY_SIZE(zfs_keys_get_bootenv));
7213 
7214 	zfs_ioctl_register("zpool_vdev_get_props", ZFS_IOC_VDEV_GET_PROPS,
7215 	    zfs_ioc_vdev_get_props, zfs_secpolicy_read, POOL_NAME,
7216 	    POOL_CHECK_NONE, B_FALSE, B_FALSE, zfs_keys_vdev_get_props,
7217 	    ARRAY_SIZE(zfs_keys_vdev_get_props));
7218 
7219 	zfs_ioctl_register("zpool_vdev_set_props", ZFS_IOC_VDEV_SET_PROPS,
7220 	    zfs_ioc_vdev_set_props, zfs_secpolicy_config, POOL_NAME,
7221 	    POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_FALSE, B_FALSE,
7222 	    zfs_keys_vdev_set_props, ARRAY_SIZE(zfs_keys_vdev_set_props));
7223 
7224 	/* IOCTLS that use the legacy function signature */
7225 
7226 	zfs_ioctl_register_legacy(ZFS_IOC_POOL_FREEZE, zfs_ioc_pool_freeze,
7227 	    zfs_secpolicy_config, NO_NAME, B_FALSE, POOL_CHECK_READONLY);
7228 
7229 	zfs_ioctl_register_pool(ZFS_IOC_POOL_CREATE, zfs_ioc_pool_create,
7230 	    zfs_secpolicy_config, B_TRUE, POOL_CHECK_NONE);
7231 	zfs_ioctl_register_pool_modify(ZFS_IOC_POOL_SCAN,
7232 	    zfs_ioc_pool_scan);
7233 	zfs_ioctl_register_pool_modify(ZFS_IOC_POOL_UPGRADE,
7234 	    zfs_ioc_pool_upgrade);
7235 	zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_ADD,
7236 	    zfs_ioc_vdev_add);
7237 	zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_REMOVE,
7238 	    zfs_ioc_vdev_remove);
7239 	zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_SET_STATE,
7240 	    zfs_ioc_vdev_set_state);
7241 	zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_ATTACH,
7242 	    zfs_ioc_vdev_attach);
7243 	zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_DETACH,
7244 	    zfs_ioc_vdev_detach);
7245 	zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_SETPATH,
7246 	    zfs_ioc_vdev_setpath);
7247 	zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_SETFRU,
7248 	    zfs_ioc_vdev_setfru);
7249 	zfs_ioctl_register_pool_modify(ZFS_IOC_POOL_SET_PROPS,
7250 	    zfs_ioc_pool_set_props);
7251 	zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_SPLIT,
7252 	    zfs_ioc_vdev_split);
7253 	zfs_ioctl_register_pool_modify(ZFS_IOC_POOL_REGUID,
7254 	    zfs_ioc_pool_reguid);
7255 
7256 	zfs_ioctl_register_pool_meta(ZFS_IOC_POOL_CONFIGS,
7257 	    zfs_ioc_pool_configs, zfs_secpolicy_none);
7258 	zfs_ioctl_register_pool_meta(ZFS_IOC_POOL_TRYIMPORT,
7259 	    zfs_ioc_pool_tryimport, zfs_secpolicy_config);
7260 	zfs_ioctl_register_pool_meta(ZFS_IOC_INJECT_FAULT,
7261 	    zfs_ioc_inject_fault, zfs_secpolicy_inject);
7262 	zfs_ioctl_register_pool_meta(ZFS_IOC_CLEAR_FAULT,
7263 	    zfs_ioc_clear_fault, zfs_secpolicy_inject);
7264 	zfs_ioctl_register_pool_meta(ZFS_IOC_INJECT_LIST_NEXT,
7265 	    zfs_ioc_inject_list_next, zfs_secpolicy_inject);
7266 
7267 	/*
7268 	 * pool destroy, and export don't log the history as part of
7269 	 * zfsdev_ioctl, but rather zfs_ioc_pool_export
7270 	 * does the logging of those commands.
7271 	 */
7272 	zfs_ioctl_register_pool(ZFS_IOC_POOL_DESTROY, zfs_ioc_pool_destroy,
7273 	    zfs_secpolicy_config, B_FALSE, POOL_CHECK_SUSPENDED);
7274 	zfs_ioctl_register_pool(ZFS_IOC_POOL_EXPORT, zfs_ioc_pool_export,
7275 	    zfs_secpolicy_config, B_FALSE, POOL_CHECK_SUSPENDED);
7276 
7277 	zfs_ioctl_register_pool(ZFS_IOC_POOL_STATS, zfs_ioc_pool_stats,
7278 	    zfs_secpolicy_read, B_FALSE, POOL_CHECK_NONE);
7279 	zfs_ioctl_register_pool(ZFS_IOC_POOL_GET_PROPS, zfs_ioc_pool_get_props,
7280 	    zfs_secpolicy_read, B_FALSE, POOL_CHECK_NONE);
7281 
7282 	zfs_ioctl_register_pool(ZFS_IOC_ERROR_LOG, zfs_ioc_error_log,
7283 	    zfs_secpolicy_inject, B_FALSE, POOL_CHECK_SUSPENDED);
7284 	zfs_ioctl_register_pool(ZFS_IOC_DSOBJ_TO_DSNAME,
7285 	    zfs_ioc_dsobj_to_dsname,
7286 	    zfs_secpolicy_diff, B_FALSE, POOL_CHECK_SUSPENDED);
7287 	zfs_ioctl_register_pool(ZFS_IOC_POOL_GET_HISTORY,
7288 	    zfs_ioc_pool_get_history,
7289 	    zfs_secpolicy_config, B_FALSE, POOL_CHECK_SUSPENDED);
7290 
7291 	zfs_ioctl_register_pool(ZFS_IOC_POOL_IMPORT, zfs_ioc_pool_import,
7292 	    zfs_secpolicy_config, B_TRUE, POOL_CHECK_NONE);
7293 
7294 	zfs_ioctl_register_pool(ZFS_IOC_CLEAR, zfs_ioc_clear,
7295 	    zfs_secpolicy_config, B_TRUE, POOL_CHECK_READONLY);
7296 
7297 	zfs_ioctl_register_dataset_read(ZFS_IOC_SPACE_WRITTEN,
7298 	    zfs_ioc_space_written);
7299 	zfs_ioctl_register_dataset_read(ZFS_IOC_OBJSET_RECVD_PROPS,
7300 	    zfs_ioc_objset_recvd_props);
7301 	zfs_ioctl_register_dataset_read(ZFS_IOC_NEXT_OBJ,
7302 	    zfs_ioc_next_obj);
7303 	zfs_ioctl_register_dataset_read(ZFS_IOC_GET_FSACL,
7304 	    zfs_ioc_get_fsacl);
7305 	zfs_ioctl_register_dataset_read(ZFS_IOC_OBJSET_STATS,
7306 	    zfs_ioc_objset_stats);
7307 	zfs_ioctl_register_dataset_read(ZFS_IOC_OBJSET_ZPLPROPS,
7308 	    zfs_ioc_objset_zplprops);
7309 	zfs_ioctl_register_dataset_read(ZFS_IOC_DATASET_LIST_NEXT,
7310 	    zfs_ioc_dataset_list_next);
7311 	zfs_ioctl_register_dataset_read(ZFS_IOC_SNAPSHOT_LIST_NEXT,
7312 	    zfs_ioc_snapshot_list_next);
7313 	zfs_ioctl_register_dataset_read(ZFS_IOC_SEND_PROGRESS,
7314 	    zfs_ioc_send_progress);
7315 
7316 	zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_DIFF,
7317 	    zfs_ioc_diff, zfs_secpolicy_diff);
7318 	zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_OBJ_TO_STATS,
7319 	    zfs_ioc_obj_to_stats, zfs_secpolicy_diff);
7320 	zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_OBJ_TO_PATH,
7321 	    zfs_ioc_obj_to_path, zfs_secpolicy_diff);
7322 	zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_USERSPACE_ONE,
7323 	    zfs_ioc_userspace_one, zfs_secpolicy_userspace_one);
7324 	zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_USERSPACE_MANY,
7325 	    zfs_ioc_userspace_many, zfs_secpolicy_userspace_many);
7326 	zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_SEND,
7327 	    zfs_ioc_send, zfs_secpolicy_send);
7328 
7329 	zfs_ioctl_register_dataset_modify(ZFS_IOC_SET_PROP, zfs_ioc_set_prop,
7330 	    zfs_secpolicy_none);
7331 	zfs_ioctl_register_dataset_modify(ZFS_IOC_DESTROY, zfs_ioc_destroy,
7332 	    zfs_secpolicy_destroy);
7333 	zfs_ioctl_register_dataset_modify(ZFS_IOC_RENAME, zfs_ioc_rename,
7334 	    zfs_secpolicy_rename);
7335 	zfs_ioctl_register_dataset_modify(ZFS_IOC_RECV, zfs_ioc_recv,
7336 	    zfs_secpolicy_recv);
7337 	zfs_ioctl_register_dataset_modify(ZFS_IOC_PROMOTE, zfs_ioc_promote,
7338 	    zfs_secpolicy_promote);
7339 	zfs_ioctl_register_dataset_modify(ZFS_IOC_INHERIT_PROP,
7340 	    zfs_ioc_inherit_prop, zfs_secpolicy_inherit_prop);
7341 	zfs_ioctl_register_dataset_modify(ZFS_IOC_SET_FSACL, zfs_ioc_set_fsacl,
7342 	    zfs_secpolicy_set_fsacl);
7343 
7344 	zfs_ioctl_register_dataset_nolog(ZFS_IOC_SHARE, zfs_ioc_share,
7345 	    zfs_secpolicy_share, POOL_CHECK_NONE);
7346 	zfs_ioctl_register_dataset_nolog(ZFS_IOC_SMB_ACL, zfs_ioc_smb_acl,
7347 	    zfs_secpolicy_smb_acl, POOL_CHECK_NONE);
7348 	zfs_ioctl_register_dataset_nolog(ZFS_IOC_USERSPACE_UPGRADE,
7349 	    zfs_ioc_userspace_upgrade, zfs_secpolicy_userspace_upgrade,
7350 	    POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY);
7351 	zfs_ioctl_register_dataset_nolog(ZFS_IOC_TMP_SNAPSHOT,
7352 	    zfs_ioc_tmp_snapshot, zfs_secpolicy_tmp_snapshot,
7353 	    POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY);
7354 
7355 	zfs_ioctl_register_legacy(ZFS_IOC_EVENTS_NEXT, zfs_ioc_events_next,
7356 	    zfs_secpolicy_config, NO_NAME, B_FALSE, POOL_CHECK_NONE);
7357 	zfs_ioctl_register_legacy(ZFS_IOC_EVENTS_CLEAR, zfs_ioc_events_clear,
7358 	    zfs_secpolicy_config, NO_NAME, B_FALSE, POOL_CHECK_NONE);
7359 	zfs_ioctl_register_legacy(ZFS_IOC_EVENTS_SEEK, zfs_ioc_events_seek,
7360 	    zfs_secpolicy_config, NO_NAME, B_FALSE, POOL_CHECK_NONE);
7361 
7362 	zfs_ioctl_init_os();
7363 }
7364 
7365 /*
7366  * Verify that for non-legacy ioctls the input nvlist
7367  * pairs match against the expected input.
7368  *
7369  * Possible errors are:
7370  * ZFS_ERR_IOC_ARG_UNAVAIL	An unrecognized nvpair was encountered
7371  * ZFS_ERR_IOC_ARG_REQUIRED	A required nvpair is missing
7372  * ZFS_ERR_IOC_ARG_BADTYPE	Invalid type for nvpair
7373  */
7374 static int
7375 zfs_check_input_nvpairs(nvlist_t *innvl, const zfs_ioc_vec_t *vec)
7376 {
7377 	const zfs_ioc_key_t *nvl_keys = vec->zvec_nvl_keys;
7378 	boolean_t required_keys_found = B_FALSE;
7379 
7380 	/*
7381 	 * examine each input pair
7382 	 */
7383 	for (nvpair_t *pair = nvlist_next_nvpair(innvl, NULL);
7384 	    pair != NULL; pair = nvlist_next_nvpair(innvl, pair)) {
7385 		char *name = nvpair_name(pair);
7386 		data_type_t type = nvpair_type(pair);
7387 		boolean_t identified = B_FALSE;
7388 
7389 		/*
7390 		 * check pair against the documented names and type
7391 		 */
7392 		for (int k = 0; k < vec->zvec_nvl_key_count; k++) {
7393 			/* if not a wild card name, check for an exact match */
7394 			if ((nvl_keys[k].zkey_flags & ZK_WILDCARDLIST) == 0 &&
7395 			    strcmp(nvl_keys[k].zkey_name, name) != 0)
7396 				continue;
7397 
7398 			identified = B_TRUE;
7399 
7400 			if (nvl_keys[k].zkey_type != DATA_TYPE_ANY &&
7401 			    nvl_keys[k].zkey_type != type) {
7402 				return (SET_ERROR(ZFS_ERR_IOC_ARG_BADTYPE));
7403 			}
7404 
7405 			if (nvl_keys[k].zkey_flags & ZK_OPTIONAL)
7406 				continue;
7407 
7408 			required_keys_found = B_TRUE;
7409 			break;
7410 		}
7411 
7412 		/* allow an 'optional' key, everything else is invalid */
7413 		if (!identified &&
7414 		    (strcmp(name, "optional") != 0 ||
7415 		    type != DATA_TYPE_NVLIST)) {
7416 			return (SET_ERROR(ZFS_ERR_IOC_ARG_UNAVAIL));
7417 		}
7418 	}
7419 
7420 	/* verify that all required keys were found */
7421 	for (int k = 0; k < vec->zvec_nvl_key_count; k++) {
7422 		if (nvl_keys[k].zkey_flags & ZK_OPTIONAL)
7423 			continue;
7424 
7425 		if (nvl_keys[k].zkey_flags & ZK_WILDCARDLIST) {
7426 			/* at least one non-optional key is expected here */
7427 			if (!required_keys_found)
7428 				return (SET_ERROR(ZFS_ERR_IOC_ARG_REQUIRED));
7429 			continue;
7430 		}
7431 
7432 		if (!nvlist_exists(innvl, nvl_keys[k].zkey_name))
7433 			return (SET_ERROR(ZFS_ERR_IOC_ARG_REQUIRED));
7434 	}
7435 
7436 	return (0);
7437 }
7438 
7439 static int
7440 pool_status_check(const char *name, zfs_ioc_namecheck_t type,
7441     zfs_ioc_poolcheck_t check)
7442 {
7443 	spa_t *spa;
7444 	int error;
7445 
7446 	ASSERT(type == POOL_NAME || type == DATASET_NAME ||
7447 	    type == ENTITY_NAME);
7448 
7449 	if (check & POOL_CHECK_NONE)
7450 		return (0);
7451 
7452 	error = spa_open(name, &spa, FTAG);
7453 	if (error == 0) {
7454 		if ((check & POOL_CHECK_SUSPENDED) && spa_suspended(spa))
7455 			error = SET_ERROR(EAGAIN);
7456 		else if ((check & POOL_CHECK_READONLY) && !spa_writeable(spa))
7457 			error = SET_ERROR(EROFS);
7458 		spa_close(spa, FTAG);
7459 	}
7460 	return (error);
7461 }
7462 
7463 int
7464 zfsdev_getminor(zfs_file_t *fp, minor_t *minorp)
7465 {
7466 	zfsdev_state_t *zs, *fpd;
7467 
7468 	ASSERT(!MUTEX_HELD(&zfsdev_state_lock));
7469 
7470 	fpd = zfs_file_private(fp);
7471 	if (fpd == NULL)
7472 		return (SET_ERROR(EBADF));
7473 
7474 	mutex_enter(&zfsdev_state_lock);
7475 
7476 	for (zs = zfsdev_state_list; zs != NULL; zs = zs->zs_next) {
7477 
7478 		if (zs->zs_minor == -1)
7479 			continue;
7480 
7481 		if (fpd == zs) {
7482 			*minorp = fpd->zs_minor;
7483 			mutex_exit(&zfsdev_state_lock);
7484 			return (0);
7485 		}
7486 	}
7487 
7488 	mutex_exit(&zfsdev_state_lock);
7489 
7490 	return (SET_ERROR(EBADF));
7491 }
7492 
7493 void *
7494 zfsdev_get_state(minor_t minor, enum zfsdev_state_type which)
7495 {
7496 	zfsdev_state_t *zs;
7497 
7498 	for (zs = zfsdev_state_list; zs != NULL; zs = zs->zs_next) {
7499 		if (zs->zs_minor == minor) {
7500 			membar_consumer();
7501 			switch (which) {
7502 			case ZST_ONEXIT:
7503 				return (zs->zs_onexit);
7504 			case ZST_ZEVENT:
7505 				return (zs->zs_zevent);
7506 			case ZST_ALL:
7507 				return (zs);
7508 			}
7509 		}
7510 	}
7511 
7512 	return (NULL);
7513 }
7514 
7515 /*
7516  * Find a free minor number.  The zfsdev_state_list is expected to
7517  * be short since it is only a list of currently open file handles.
7518  */
7519 static minor_t
7520 zfsdev_minor_alloc(void)
7521 {
7522 	static minor_t last_minor = 0;
7523 	minor_t m;
7524 
7525 	ASSERT(MUTEX_HELD(&zfsdev_state_lock));
7526 
7527 	for (m = last_minor + 1; m != last_minor; m++) {
7528 		if (m > ZFSDEV_MAX_MINOR)
7529 			m = 1;
7530 		if (zfsdev_get_state(m, ZST_ALL) == NULL) {
7531 			last_minor = m;
7532 			return (m);
7533 		}
7534 	}
7535 
7536 	return (0);
7537 }
7538 
7539 int
7540 zfsdev_state_init(void *priv)
7541 {
7542 	zfsdev_state_t *zs, *zsprev = NULL;
7543 	minor_t minor;
7544 	boolean_t newzs = B_FALSE;
7545 
7546 	ASSERT(MUTEX_HELD(&zfsdev_state_lock));
7547 
7548 	minor = zfsdev_minor_alloc();
7549 	if (minor == 0)
7550 		return (SET_ERROR(ENXIO));
7551 
7552 	for (zs = zfsdev_state_list; zs != NULL; zs = zs->zs_next) {
7553 		if (zs->zs_minor == -1)
7554 			break;
7555 		zsprev = zs;
7556 	}
7557 
7558 	if (!zs) {
7559 		zs = kmem_zalloc(sizeof (zfsdev_state_t), KM_SLEEP);
7560 		newzs = B_TRUE;
7561 	}
7562 
7563 	zfsdev_private_set_state(priv, zs);
7564 
7565 	zfs_onexit_init((zfs_onexit_t **)&zs->zs_onexit);
7566 	zfs_zevent_init((zfs_zevent_t **)&zs->zs_zevent);
7567 
7568 	/*
7569 	 * In order to provide for lock-free concurrent read access
7570 	 * to the minor list in zfsdev_get_state(), new entries
7571 	 * must be completely written before linking them into the
7572 	 * list whereas existing entries are already linked; the last
7573 	 * operation must be updating zs_minor (from -1 to the new
7574 	 * value).
7575 	 */
7576 	if (newzs) {
7577 		zs->zs_minor = minor;
7578 		membar_producer();
7579 		zsprev->zs_next = zs;
7580 	} else {
7581 		membar_producer();
7582 		zs->zs_minor = minor;
7583 	}
7584 
7585 	return (0);
7586 }
7587 
7588 void
7589 zfsdev_state_destroy(void *priv)
7590 {
7591 	zfsdev_state_t *zs = zfsdev_private_get_state(priv);
7592 
7593 	ASSERT(zs != NULL);
7594 	ASSERT3S(zs->zs_minor, >, 0);
7595 
7596 	/*
7597 	 * The last reference to this zfsdev file descriptor is being dropped.
7598 	 * We don't have to worry about lookup grabbing this state object, and
7599 	 * zfsdev_state_init() will not try to reuse this object until it is
7600 	 * invalidated by setting zs_minor to -1.  Invalidation must be done
7601 	 * last, with a memory barrier to ensure ordering.  This lets us avoid
7602 	 * taking the global zfsdev state lock around destruction.
7603 	 */
7604 	zfs_onexit_destroy(zs->zs_onexit);
7605 	zfs_zevent_destroy(zs->zs_zevent);
7606 	zs->zs_onexit = NULL;
7607 	zs->zs_zevent = NULL;
7608 	membar_producer();
7609 	zs->zs_minor = -1;
7610 }
7611 
7612 long
7613 zfsdev_ioctl_common(uint_t vecnum, zfs_cmd_t *zc, int flag)
7614 {
7615 	int error, cmd;
7616 	const zfs_ioc_vec_t *vec;
7617 	char *saved_poolname = NULL;
7618 	uint64_t max_nvlist_src_size;
7619 	size_t saved_poolname_len = 0;
7620 	nvlist_t *innvl = NULL;
7621 	fstrans_cookie_t cookie;
7622 	hrtime_t start_time = gethrtime();
7623 
7624 	cmd = vecnum;
7625 	error = 0;
7626 	if (vecnum >= sizeof (zfs_ioc_vec) / sizeof (zfs_ioc_vec[0]))
7627 		return (SET_ERROR(ZFS_ERR_IOC_CMD_UNAVAIL));
7628 
7629 	vec = &zfs_ioc_vec[vecnum];
7630 
7631 	/*
7632 	 * The registered ioctl list may be sparse, verify that either
7633 	 * a normal or legacy handler are registered.
7634 	 */
7635 	if (vec->zvec_func == NULL && vec->zvec_legacy_func == NULL)
7636 		return (SET_ERROR(ZFS_ERR_IOC_CMD_UNAVAIL));
7637 
7638 	zc->zc_iflags = flag & FKIOCTL;
7639 	max_nvlist_src_size = zfs_max_nvlist_src_size_os();
7640 	if (zc->zc_nvlist_src_size > max_nvlist_src_size) {
7641 		/*
7642 		 * Make sure the user doesn't pass in an insane value for
7643 		 * zc_nvlist_src_size.  We have to check, since we will end
7644 		 * up allocating that much memory inside of get_nvlist().  This
7645 		 * prevents a nefarious user from allocating tons of kernel
7646 		 * memory.
7647 		 *
7648 		 * Also, we return EINVAL instead of ENOMEM here.  The reason
7649 		 * being that returning ENOMEM from an ioctl() has a special
7650 		 * connotation; that the user's size value is too small and
7651 		 * needs to be expanded to hold the nvlist.  See
7652 		 * zcmd_expand_dst_nvlist() for details.
7653 		 */
7654 		error = SET_ERROR(EINVAL);	/* User's size too big */
7655 
7656 	} else if (zc->zc_nvlist_src_size != 0) {
7657 		error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
7658 		    zc->zc_iflags, &innvl);
7659 		if (error != 0)
7660 			goto out;
7661 	}
7662 
7663 	/*
7664 	 * Ensure that all pool/dataset names are valid before we pass down to
7665 	 * the lower layers.
7666 	 */
7667 	zc->zc_name[sizeof (zc->zc_name) - 1] = '\0';
7668 	switch (vec->zvec_namecheck) {
7669 	case POOL_NAME:
7670 		if (pool_namecheck(zc->zc_name, NULL, NULL) != 0)
7671 			error = SET_ERROR(EINVAL);
7672 		else
7673 			error = pool_status_check(zc->zc_name,
7674 			    vec->zvec_namecheck, vec->zvec_pool_check);
7675 		break;
7676 
7677 	case DATASET_NAME:
7678 		if (dataset_namecheck(zc->zc_name, NULL, NULL) != 0)
7679 			error = SET_ERROR(EINVAL);
7680 		else
7681 			error = pool_status_check(zc->zc_name,
7682 			    vec->zvec_namecheck, vec->zvec_pool_check);
7683 		break;
7684 
7685 	case ENTITY_NAME:
7686 		if (entity_namecheck(zc->zc_name, NULL, NULL) != 0) {
7687 			error = SET_ERROR(EINVAL);
7688 		} else {
7689 			error = pool_status_check(zc->zc_name,
7690 			    vec->zvec_namecheck, vec->zvec_pool_check);
7691 		}
7692 		break;
7693 
7694 	case NO_NAME:
7695 		break;
7696 	}
7697 	/*
7698 	 * Ensure that all input pairs are valid before we pass them down
7699 	 * to the lower layers.
7700 	 *
7701 	 * The vectored functions can use fnvlist_lookup_{type} for any
7702 	 * required pairs since zfs_check_input_nvpairs() confirmed that
7703 	 * they exist and are of the correct type.
7704 	 */
7705 	if (error == 0 && vec->zvec_func != NULL) {
7706 		error = zfs_check_input_nvpairs(innvl, vec);
7707 		if (error != 0)
7708 			goto out;
7709 	}
7710 
7711 	if (error == 0) {
7712 		cookie = spl_fstrans_mark();
7713 		error = vec->zvec_secpolicy(zc, innvl, CRED());
7714 		spl_fstrans_unmark(cookie);
7715 	}
7716 
7717 	if (error != 0)
7718 		goto out;
7719 
7720 	/* legacy ioctls can modify zc_name */
7721 	/*
7722 	 * Can't use kmem_strdup() as we might truncate the string and
7723 	 * kmem_strfree() would then free with incorrect size.
7724 	 */
7725 	saved_poolname_len = strlen(zc->zc_name) + 1;
7726 	saved_poolname = kmem_alloc(saved_poolname_len, KM_SLEEP);
7727 
7728 	strlcpy(saved_poolname, zc->zc_name, saved_poolname_len);
7729 	saved_poolname[strcspn(saved_poolname, "/@#")] = '\0';
7730 
7731 	if (vec->zvec_func != NULL) {
7732 		nvlist_t *outnvl;
7733 		int puterror = 0;
7734 		spa_t *spa;
7735 		nvlist_t *lognv = NULL;
7736 
7737 		ASSERT(vec->zvec_legacy_func == NULL);
7738 
7739 		/*
7740 		 * Add the innvl to the lognv before calling the func,
7741 		 * in case the func changes the innvl.
7742 		 */
7743 		if (vec->zvec_allow_log) {
7744 			lognv = fnvlist_alloc();
7745 			fnvlist_add_string(lognv, ZPOOL_HIST_IOCTL,
7746 			    vec->zvec_name);
7747 			if (!nvlist_empty(innvl)) {
7748 				fnvlist_add_nvlist(lognv, ZPOOL_HIST_INPUT_NVL,
7749 				    innvl);
7750 			}
7751 		}
7752 
7753 		outnvl = fnvlist_alloc();
7754 		cookie = spl_fstrans_mark();
7755 		error = vec->zvec_func(zc->zc_name, innvl, outnvl);
7756 		spl_fstrans_unmark(cookie);
7757 
7758 		/*
7759 		 * Some commands can partially execute, modify state, and still
7760 		 * return an error.  In these cases, attempt to record what
7761 		 * was modified.
7762 		 */
7763 		if ((error == 0 ||
7764 		    (cmd == ZFS_IOC_CHANNEL_PROGRAM && error != EINVAL)) &&
7765 		    vec->zvec_allow_log &&
7766 		    spa_open(zc->zc_name, &spa, FTAG) == 0) {
7767 			if (!nvlist_empty(outnvl)) {
7768 				size_t out_size = fnvlist_size(outnvl);
7769 				if (out_size > zfs_history_output_max) {
7770 					fnvlist_add_int64(lognv,
7771 					    ZPOOL_HIST_OUTPUT_SIZE, out_size);
7772 				} else {
7773 					fnvlist_add_nvlist(lognv,
7774 					    ZPOOL_HIST_OUTPUT_NVL, outnvl);
7775 				}
7776 			}
7777 			if (error != 0) {
7778 				fnvlist_add_int64(lognv, ZPOOL_HIST_ERRNO,
7779 				    error);
7780 			}
7781 			fnvlist_add_int64(lognv, ZPOOL_HIST_ELAPSED_NS,
7782 			    gethrtime() - start_time);
7783 			(void) spa_history_log_nvl(spa, lognv);
7784 			spa_close(spa, FTAG);
7785 		}
7786 		fnvlist_free(lognv);
7787 
7788 		if (!nvlist_empty(outnvl) || zc->zc_nvlist_dst_size != 0) {
7789 			int smusherror = 0;
7790 			if (vec->zvec_smush_outnvlist) {
7791 				smusherror = nvlist_smush(outnvl,
7792 				    zc->zc_nvlist_dst_size);
7793 			}
7794 			if (smusherror == 0)
7795 				puterror = put_nvlist(zc, outnvl);
7796 		}
7797 
7798 		if (puterror != 0)
7799 			error = puterror;
7800 
7801 		nvlist_free(outnvl);
7802 	} else {
7803 		cookie = spl_fstrans_mark();
7804 		error = vec->zvec_legacy_func(zc);
7805 		spl_fstrans_unmark(cookie);
7806 	}
7807 
7808 out:
7809 	nvlist_free(innvl);
7810 	if (error == 0 && vec->zvec_allow_log) {
7811 		char *s = tsd_get(zfs_allow_log_key);
7812 		if (s != NULL)
7813 			kmem_strfree(s);
7814 		(void) tsd_set(zfs_allow_log_key, kmem_strdup(saved_poolname));
7815 	}
7816 	if (saved_poolname != NULL)
7817 		kmem_free(saved_poolname, saved_poolname_len);
7818 
7819 	return (error);
7820 }
7821 
7822 int
7823 zfs_kmod_init(void)
7824 {
7825 	int error;
7826 
7827 	if ((error = zvol_init()) != 0)
7828 		return (error);
7829 
7830 	spa_init(SPA_MODE_READ | SPA_MODE_WRITE);
7831 	zfs_init();
7832 
7833 	zfs_ioctl_init();
7834 
7835 	mutex_init(&zfsdev_state_lock, NULL, MUTEX_DEFAULT, NULL);
7836 	zfsdev_state_list = kmem_zalloc(sizeof (zfsdev_state_t), KM_SLEEP);
7837 	zfsdev_state_list->zs_minor = -1;
7838 
7839 	if ((error = zfsdev_attach()) != 0)
7840 		goto out;
7841 
7842 	tsd_create(&zfs_fsyncer_key, NULL);
7843 	tsd_create(&rrw_tsd_key, rrw_tsd_destroy);
7844 	tsd_create(&zfs_allow_log_key, zfs_allow_log_destroy);
7845 
7846 	return (0);
7847 out:
7848 	zfs_fini();
7849 	spa_fini();
7850 	zvol_fini();
7851 
7852 	return (error);
7853 }
7854 
7855 void
7856 zfs_kmod_fini(void)
7857 {
7858 	zfsdev_state_t *zs, *zsnext = NULL;
7859 
7860 	zfsdev_detach();
7861 
7862 	mutex_destroy(&zfsdev_state_lock);
7863 
7864 	for (zs = zfsdev_state_list; zs != NULL; zs = zsnext) {
7865 		zsnext = zs->zs_next;
7866 		if (zs->zs_onexit)
7867 			zfs_onexit_destroy(zs->zs_onexit);
7868 		if (zs->zs_zevent)
7869 			zfs_zevent_destroy(zs->zs_zevent);
7870 		kmem_free(zs, sizeof (zfsdev_state_t));
7871 	}
7872 
7873 	zfs_ereport_taskq_fini();	/* run before zfs_fini() on Linux */
7874 	zfs_fini();
7875 	spa_fini();
7876 	zvol_fini();
7877 
7878 	tsd_destroy(&zfs_fsyncer_key);
7879 	tsd_destroy(&rrw_tsd_key);
7880 	tsd_destroy(&zfs_allow_log_key);
7881 }
7882 
7883 ZFS_MODULE_PARAM(zfs, zfs_, max_nvlist_src_size, ULONG, ZMOD_RW,
7884 	"Maximum size in bytes allowed for src nvlist passed with ZFS ioctls");
7885 
7886 ZFS_MODULE_PARAM(zfs, zfs_, history_output_max, ULONG, ZMOD_RW,
7887 	"Maximum size in bytes of ZFS ioctl output that will be logged");
7888