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 http://www.opensolaris.org/os/licensing.
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 2011 Nexenta Systems, Inc. All rights reserved.
26 * Copyright (c) 2012, Joyent, Inc. All rights reserved.
27 * Copyright (c) 2012 by Delphix. All rights reserved.
28 * Copyright (c) 2013 by Saso Kiselkov. All rights reserved.
29 */
30
31 /*
32 * ZFS ioctls.
33 *
34 * This file handles the ioctls to /dev/zfs, used for configuring ZFS storage
35 * pools and filesystems, e.g. with /sbin/zfs and /sbin/zpool.
36 *
37 * There are two ways that we handle ioctls: the legacy way where almost
38 * all of the logic is in the ioctl callback, and the new way where most
39 * of the marshalling is handled in the common entry point, zfsdev_ioctl().
40 *
41 * Non-legacy ioctls should be registered by calling
42 * zfs_ioctl_register() from zfs_ioctl_init(). The ioctl is invoked
43 * from userland by lzc_ioctl().
44 *
45 * The registration arguments are as follows:
46 *
47 * const char *name
48 * The name of the ioctl. This is used for history logging. If the
49 * ioctl returns successfully (the callback returns 0), and allow_log
50 * is true, then a history log entry will be recorded with the input &
51 * output nvlists. The log entry can be printed with "zpool history -i".
52 *
53 * zfs_ioc_t ioc
54 * The ioctl request number, which userland will pass to ioctl(2).
55 * The ioctl numbers can change from release to release, because
56 * the caller (libzfs) must be matched to the kernel.
57 *
58 * zfs_secpolicy_func_t *secpolicy
59 * This function will be called before the zfs_ioc_func_t, to
60 * determine if this operation is permitted. It should return EPERM
61 * on failure, and 0 on success. Checks include determining if the
62 * dataset is visible in this zone, and if the user has either all
63 * zfs privileges in the zone (SYS_MOUNT), or has been granted permission
64 * to do this operation on this dataset with "zfs allow".
65 *
66 * zfs_ioc_namecheck_t namecheck
67 * This specifies what to expect in the zfs_cmd_t:zc_name -- a pool
68 * name, a dataset name, or nothing. If the name is not well-formed,
69 * the ioctl will fail and the callback will not be called.
70 * Therefore, the callback can assume that the name is well-formed
71 * (e.g. is null-terminated, doesn't have more than one '@' character,
72 * doesn't have invalid characters).
73 *
74 * zfs_ioc_poolcheck_t pool_check
75 * This specifies requirements on the pool state. If the pool does
76 * not meet them (is suspended or is readonly), the ioctl will fail
77 * and the callback will not be called. If any checks are specified
78 * (i.e. it is not POOL_CHECK_NONE), namecheck must not be NO_NAME.
79 * Multiple checks can be or-ed together (e.g. POOL_CHECK_SUSPENDED |
80 * POOL_CHECK_READONLY).
81 *
82 * boolean_t smush_outnvlist
83 * If smush_outnvlist is true, then the output is presumed to be a
84 * list of errors, and it will be "smushed" down to fit into the
85 * caller's buffer, by removing some entries and replacing them with a
86 * single "N_MORE_ERRORS" entry indicating how many were removed. See
87 * nvlist_smush() for details. If smush_outnvlist is false, and the
88 * outnvlist does not fit into the userland-provided buffer, then the
89 * ioctl will fail with ENOMEM.
90 *
91 * zfs_ioc_func_t *func
92 * The callback function that will perform the operation.
93 *
94 * The callback should return 0 on success, or an error number on
95 * failure. If the function fails, the userland ioctl will return -1,
96 * and errno will be set to the callback's return value. The callback
97 * will be called with the following arguments:
98 *
99 * const char *name
100 * The name of the pool or dataset to operate on, from
101 * zfs_cmd_t:zc_name. The 'namecheck' argument specifies the
102 * expected type (pool, dataset, or none).
103 *
104 * nvlist_t *innvl
105 * The input nvlist, deserialized from zfs_cmd_t:zc_nvlist_src. Or
106 * NULL if no input nvlist was provided. Changes to this nvlist are
107 * ignored. If the input nvlist could not be deserialized, the
108 * ioctl will fail and the callback will not be called.
109 *
110 * nvlist_t *outnvl
111 * The output nvlist, initially empty. The callback can fill it in,
112 * and it will be returned to userland by serializing it into
113 * zfs_cmd_t:zc_nvlist_dst. If it is non-empty, and serialization
114 * fails (e.g. because the caller didn't supply a large enough
115 * buffer), then the overall ioctl will fail. See the
116 * 'smush_nvlist' argument above for additional behaviors.
117 *
118 * There are two typical uses of the output nvlist:
119 * - To return state, e.g. property values. In this case,
120 * smush_outnvlist should be false. If the buffer was not large
121 * enough, the caller will reallocate a larger buffer and try
122 * the ioctl again.
123 *
124 * - To return multiple errors from an ioctl which makes on-disk
125 * changes. In this case, smush_outnvlist should be true.
126 * Ioctls which make on-disk modifications should generally not
127 * use the outnvl if they succeed, because the caller can not
128 * distinguish between the operation failing, and
129 * deserialization failing.
130 */
131
132 #include <sys/types.h>
133 #include <sys/param.h>
134 #include <sys/errno.h>
135 #include <sys/uio.h>
136 #include <sys/buf.h>
137 #include <sys/modctl.h>
138 #include <sys/open.h>
139 #include <sys/file.h>
140 #include <sys/kmem.h>
141 #include <sys/conf.h>
142 #include <sys/cmn_err.h>
143 #include <sys/stat.h>
144 #include <sys/zfs_ioctl.h>
145 #include <sys/zfs_vfsops.h>
146 #include <sys/zfs_znode.h>
147 #include <sys/zap.h>
148 #include <sys/spa.h>
149 #include <sys/spa_impl.h>
150 #include <sys/vdev.h>
151 #include <sys/priv_impl.h>
152 #include <sys/dmu.h>
153 #include <sys/dsl_dir.h>
154 #include <sys/dsl_dataset.h>
155 #include <sys/dsl_prop.h>
156 #include <sys/dsl_deleg.h>
157 #include <sys/dmu_objset.h>
158 #include <sys/dmu_impl.h>
159 #include <sys/ddi.h>
160 #include <sys/sunddi.h>
161 #include <sys/sunldi.h>
162 #include <sys/policy.h>
163 #include <sys/zone.h>
164 #include <sys/nvpair.h>
165 #include <sys/pathname.h>
166 #include <sys/mount.h>
167 #include <sys/sdt.h>
168 #include <sys/fs/zfs.h>
169 #include <sys/zfs_ctldir.h>
170 #include <sys/zfs_dir.h>
171 #include <sys/zfs_onexit.h>
172 #include <sys/zvol.h>
173 #include <sys/dsl_scan.h>
174 #include <sharefs/share.h>
175 #include <sys/dmu_objset.h>
176 #include <sys/zfeature.h>
177
178 #include "zfs_namecheck.h"
179 #include "zfs_prop.h"
180 #include "zfs_deleg.h"
181 #include "zfs_comutil.h"
182
183 extern struct modlfs zfs_modlfs;
184
185 extern void zfs_init(void);
186 extern void zfs_fini(void);
187
188 ldi_ident_t zfs_li = NULL;
189 dev_info_t *zfs_dip;
190
191 uint_t zfs_fsyncer_key;
192 extern uint_t rrw_tsd_key;
193 static uint_t zfs_allow_log_key;
194
195 typedef int zfs_ioc_legacy_func_t(zfs_cmd_t *);
196 typedef int zfs_ioc_func_t(const char *, nvlist_t *, nvlist_t *);
197 typedef int zfs_secpolicy_func_t(zfs_cmd_t *, nvlist_t *, cred_t *);
198
199 typedef enum {
200 NO_NAME,
201 POOL_NAME,
202 DATASET_NAME
203 } zfs_ioc_namecheck_t;
204
205 typedef enum {
206 POOL_CHECK_NONE = 1 << 0,
207 POOL_CHECK_SUSPENDED = 1 << 1,
208 POOL_CHECK_READONLY = 1 << 2,
209 } zfs_ioc_poolcheck_t;
210
211 typedef struct zfs_ioc_vec {
212 zfs_ioc_legacy_func_t *zvec_legacy_func;
213 zfs_ioc_func_t *zvec_func;
214 zfs_secpolicy_func_t *zvec_secpolicy;
215 zfs_ioc_namecheck_t zvec_namecheck;
216 boolean_t zvec_allow_log;
217 zfs_ioc_poolcheck_t zvec_pool_check;
218 boolean_t zvec_smush_outnvlist;
219 const char *zvec_name;
220 } zfs_ioc_vec_t;
221
222 /* This array is indexed by zfs_userquota_prop_t */
223 static const char *userquota_perms[] = {
224 ZFS_DELEG_PERM_USERUSED,
225 ZFS_DELEG_PERM_USERQUOTA,
226 ZFS_DELEG_PERM_GROUPUSED,
227 ZFS_DELEG_PERM_GROUPQUOTA,
228 };
229
230 static int zfs_ioc_userspace_upgrade(zfs_cmd_t *zc);
231 static int zfs_check_settable(const char *name, nvpair_t *property,
232 cred_t *cr);
233 static int zfs_check_clearable(char *dataset, nvlist_t *props,
234 nvlist_t **errors);
235 static int zfs_fill_zplprops_root(uint64_t, nvlist_t *, nvlist_t *,
236 boolean_t *);
237 int zfs_set_prop_nvlist(const char *, zprop_source_t, nvlist_t *, nvlist_t *);
238 static int get_nvlist(uint64_t nvl, uint64_t size, int iflag, nvlist_t **nvp);
239
240 static int zfs_prop_activate_feature(dsl_pool_t *dp, zfeature_info_t *feature);
241 static int zfs_prop_activate_feature_check(void *arg1, void *arg2,
242 dmu_tx_t *tx);
243 static void zfs_prop_activate_feature_sync(void *arg1, void *arg2,
244 dmu_tx_t *tx);
245
246 /* _NOTE(PRINTFLIKE(4)) - this is printf-like, but lint is too whiney */
247 void
248 __dprintf(const char *file, const char *func, int line, const char *fmt, ...)
249 {
250 const char *newfile;
251 char buf[512];
252 va_list adx;
253
254 /*
255 * Get rid of annoying "../common/" prefix to filename.
256 */
257 newfile = strrchr(file, '/');
258 if (newfile != NULL) {
259 newfile = newfile + 1; /* Get rid of leading / */
260 } else {
261 newfile = file;
262 }
263
264 va_start(adx, fmt);
265 (void) vsnprintf(buf, sizeof (buf), fmt, adx);
266 va_end(adx);
267
268 /*
269 * To get this data, use the zfs-dprintf probe as so:
270 * dtrace -q -n 'zfs-dprintf \
271 * /stringof(arg0) == "dbuf.c"/ \
272 * {printf("%s: %s", stringof(arg1), stringof(arg3))}'
273 * arg0 = file name
274 * arg1 = function name
275 * arg2 = line number
276 * arg3 = message
277 */
278 DTRACE_PROBE4(zfs__dprintf,
279 char *, newfile, char *, func, int, line, char *, buf);
280 }
281
282 static void
283 history_str_free(char *buf)
284 {
285 kmem_free(buf, HIS_MAX_RECORD_LEN);
286 }
287
288 static char *
289 history_str_get(zfs_cmd_t *zc)
290 {
291 char *buf;
292
293 if (zc->zc_history == NULL)
294 return (NULL);
295
296 buf = kmem_alloc(HIS_MAX_RECORD_LEN, KM_SLEEP);
297 if (copyinstr((void *)(uintptr_t)zc->zc_history,
298 buf, HIS_MAX_RECORD_LEN, NULL) != 0) {
299 history_str_free(buf);
300 return (NULL);
301 }
302
303 buf[HIS_MAX_RECORD_LEN -1] = '\0';
304
305 return (buf);
306 }
307
308 /*
309 * Check to see if the named dataset is currently defined as bootable
310 */
311 static boolean_t
312 zfs_is_bootfs(const char *name)
313 {
314 objset_t *os;
315
316 if (dmu_objset_hold(name, FTAG, &os) == 0) {
317 boolean_t ret;
318 ret = (dmu_objset_id(os) == spa_bootfs(dmu_objset_spa(os)));
319 dmu_objset_rele(os, FTAG);
320 return (ret);
321 }
322 return (B_FALSE);
323 }
324
325 /*
326 * zfs_earlier_version
327 *
328 * Return non-zero if the spa version is less than requested version.
329 */
330 static int
331 zfs_earlier_version(const char *name, int version)
332 {
333 spa_t *spa;
334
335 if (spa_open(name, &spa, FTAG) == 0) {
336 if (spa_version(spa) < version) {
337 spa_close(spa, FTAG);
338 return (1);
339 }
340 spa_close(spa, FTAG);
341 }
342 return (0);
343 }
344
345 /*
346 * zpl_earlier_version
347 *
348 * Return TRUE if the ZPL version is less than requested version.
349 */
350 static boolean_t
351 zpl_earlier_version(const char *name, int version)
352 {
353 objset_t *os;
354 boolean_t rc = B_TRUE;
355
356 if (dmu_objset_hold(name, FTAG, &os) == 0) {
357 uint64_t zplversion;
358
359 if (dmu_objset_type(os) != DMU_OST_ZFS) {
360 dmu_objset_rele(os, FTAG);
361 return (B_TRUE);
362 }
363 /* XXX reading from non-owned objset */
364 if (zfs_get_zplprop(os, ZFS_PROP_VERSION, &zplversion) == 0)
365 rc = zplversion < version;
366 dmu_objset_rele(os, FTAG);
367 }
368 return (rc);
369 }
370
371 static void
372 zfs_log_history(zfs_cmd_t *zc)
373 {
374 spa_t *spa;
375 char *buf;
376
377 if ((buf = history_str_get(zc)) == NULL)
378 return;
379
380 if (spa_open(zc->zc_name, &spa, FTAG) == 0) {
381 if (spa_version(spa) >= SPA_VERSION_ZPOOL_HISTORY)
382 (void) spa_history_log(spa, buf);
383 spa_close(spa, FTAG);
384 }
385 history_str_free(buf);
386 }
387
388 /*
389 * Policy for top-level read operations (list pools). Requires no privileges,
390 * and can be used in the local zone, as there is no associated dataset.
391 */
392 /* ARGSUSED */
393 static int
394 zfs_secpolicy_none(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
395 {
396 return (0);
397 }
398
399 /*
400 * Policy for dataset read operations (list children, get statistics). Requires
401 * no privileges, but must be visible in the local zone.
402 */
403 /* ARGSUSED */
404 static int
405 zfs_secpolicy_read(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
406 {
407 if (INGLOBALZONE(curproc) ||
408 zone_dataset_visible(zc->zc_name, NULL))
409 return (0);
410
411 return (ENOENT);
412 }
413
414 static int
415 zfs_dozonecheck_impl(const char *dataset, uint64_t zoned, cred_t *cr)
416 {
417 int writable = 1;
418
419 /*
420 * The dataset must be visible by this zone -- check this first
421 * so they don't see EPERM on something they shouldn't know about.
422 */
423 if (!INGLOBALZONE(curproc) &&
424 !zone_dataset_visible(dataset, &writable))
425 return (ENOENT);
426
427 if (INGLOBALZONE(curproc)) {
428 /*
429 * If the fs is zoned, only root can access it from the
430 * global zone.
431 */
432 if (secpolicy_zfs(cr) && zoned)
433 return (EPERM);
434 } else {
435 /*
436 * If we are in a local zone, the 'zoned' property must be set.
437 */
438 if (!zoned)
439 return (EPERM);
440
441 /* must be writable by this zone */
442 if (!writable)
443 return (EPERM);
444 }
445 return (0);
446 }
447
448 static int
449 zfs_dozonecheck(const char *dataset, cred_t *cr)
450 {
451 uint64_t zoned;
452
453 if (dsl_prop_get_integer(dataset, "zoned", &zoned, NULL))
454 return (ENOENT);
455
456 return (zfs_dozonecheck_impl(dataset, zoned, cr));
457 }
458
459 static int
460 zfs_dozonecheck_ds(const char *dataset, dsl_dataset_t *ds, cred_t *cr)
461 {
462 uint64_t zoned;
463
464 rw_enter(&ds->ds_dir->dd_pool->dp_config_rwlock, RW_READER);
465 if (dsl_prop_get_ds(ds, "zoned", 8, 1, &zoned, NULL)) {
466 rw_exit(&ds->ds_dir->dd_pool->dp_config_rwlock);
467 return (ENOENT);
468 }
469 rw_exit(&ds->ds_dir->dd_pool->dp_config_rwlock);
470
471 return (zfs_dozonecheck_impl(dataset, zoned, cr));
472 }
473
474 static int
475 zfs_secpolicy_write_perms(const char *name, const char *perm, cred_t *cr)
476 {
477 int error;
478 dsl_dataset_t *ds;
479
480 error = dsl_dataset_hold(name, FTAG, &ds);
481 if (error != 0)
482 return (error);
483
484 error = zfs_dozonecheck_ds(name, ds, cr);
485 if (error == 0) {
486 error = secpolicy_zfs(cr);
487 if (error)
488 error = dsl_deleg_access_impl(ds, perm, cr);
489 }
490
491 dsl_dataset_rele(ds, FTAG);
492 return (error);
493 }
494
495 static int
496 zfs_secpolicy_write_perms_ds(const char *name, dsl_dataset_t *ds,
497 const char *perm, cred_t *cr)
498 {
499 int error;
500
501 error = zfs_dozonecheck_ds(name, ds, cr);
502 if (error == 0) {
503 error = secpolicy_zfs(cr);
504 if (error)
505 error = dsl_deleg_access_impl(ds, perm, cr);
506 }
507 return (error);
508 }
509
510 /*
511 * Policy for setting the security label property.
512 *
513 * Returns 0 for success, non-zero for access and other errors.
514 */
515 static int
516 zfs_set_slabel_policy(const char *name, char *strval, cred_t *cr)
517 {
518 char ds_hexsl[MAXNAMELEN];
519 bslabel_t ds_sl, new_sl;
520 boolean_t new_default = FALSE;
521 uint64_t zoned;
522 int needed_priv = -1;
523 int error;
524
525 /* First get the existing dataset label. */
526 error = dsl_prop_get(name, zfs_prop_to_name(ZFS_PROP_MLSLABEL),
527 1, sizeof (ds_hexsl), &ds_hexsl, NULL);
528 if (error)
529 return (EPERM);
530
531 if (strcasecmp(strval, ZFS_MLSLABEL_DEFAULT) == 0)
532 new_default = TRUE;
533
534 /* The label must be translatable */
535 if (!new_default && (hexstr_to_label(strval, &new_sl) != 0))
536 return (EINVAL);
537
538 /*
539 * In a non-global zone, disallow attempts to set a label that
540 * doesn't match that of the zone; otherwise no other checks
541 * are needed.
542 */
543 if (!INGLOBALZONE(curproc)) {
544 if (new_default || !blequal(&new_sl, CR_SL(CRED())))
545 return (EPERM);
546 return (0);
547 }
548
549 /*
550 * For global-zone datasets (i.e., those whose zoned property is
551 * "off", verify that the specified new label is valid for the
552 * global zone.
553 */
554 if (dsl_prop_get_integer(name,
555 zfs_prop_to_name(ZFS_PROP_ZONED), &zoned, NULL))
556 return (EPERM);
557 if (!zoned) {
558 if (zfs_check_global_label(name, strval) != 0)
559 return (EPERM);
560 }
561
562 /*
563 * If the existing dataset label is nondefault, check if the
564 * dataset is mounted (label cannot be changed while mounted).
565 * Get the zfsvfs; if there isn't one, then the dataset isn't
566 * mounted (or isn't a dataset, doesn't exist, ...).
567 */
568 if (strcasecmp(ds_hexsl, ZFS_MLSLABEL_DEFAULT) != 0) {
569 objset_t *os;
570 static char *setsl_tag = "setsl_tag";
571
572 /*
573 * Try to own the dataset; abort if there is any error,
574 * (e.g., already mounted, in use, or other error).
575 */
576 error = dmu_objset_own(name, DMU_OST_ZFS, B_TRUE,
577 setsl_tag, &os);
578 if (error)
579 return (EPERM);
580
581 dmu_objset_disown(os, setsl_tag);
582
583 if (new_default) {
584 needed_priv = PRIV_FILE_DOWNGRADE_SL;
585 goto out_check;
586 }
587
588 if (hexstr_to_label(strval, &new_sl) != 0)
589 return (EPERM);
590
591 if (blstrictdom(&ds_sl, &new_sl))
592 needed_priv = PRIV_FILE_DOWNGRADE_SL;
593 else if (blstrictdom(&new_sl, &ds_sl))
594 needed_priv = PRIV_FILE_UPGRADE_SL;
595 } else {
596 /* dataset currently has a default label */
597 if (!new_default)
598 needed_priv = PRIV_FILE_UPGRADE_SL;
599 }
600
601 out_check:
602 if (needed_priv != -1)
603 return (PRIV_POLICY(cr, needed_priv, B_FALSE, EPERM, NULL));
604 return (0);
605 }
606
607 static int
608 zfs_secpolicy_setprop(const char *dsname, zfs_prop_t prop, nvpair_t *propval,
609 cred_t *cr)
610 {
611 char *strval;
612
613 /*
614 * Check permissions for special properties.
615 */
616 switch (prop) {
617 case ZFS_PROP_ZONED:
618 /*
619 * Disallow setting of 'zoned' from within a local zone.
620 */
621 if (!INGLOBALZONE(curproc))
622 return (EPERM);
623 break;
624
625 case ZFS_PROP_QUOTA:
626 if (!INGLOBALZONE(curproc)) {
627 uint64_t zoned;
628 char setpoint[MAXNAMELEN];
629 /*
630 * Unprivileged users are allowed to modify the
631 * quota on things *under* (ie. contained by)
632 * the thing they own.
633 */
634 if (dsl_prop_get_integer(dsname, "zoned", &zoned,
635 setpoint))
636 return (EPERM);
637 if (!zoned || strlen(dsname) <= strlen(setpoint))
638 return (EPERM);
639 }
640 break;
641
642 case ZFS_PROP_MLSLABEL:
643 if (!is_system_labeled())
644 return (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 /* ARGSUSED */
660 static int
661 zfs_secpolicy_set_fsacl(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
662 {
663 int error;
664
665 error = zfs_dozonecheck(zc->zc_name, cr);
666 if (error)
667 return (error);
668
669 /*
670 * permission to set permissions will be evaluated later in
671 * dsl_deleg_can_allow()
672 */
673 return (0);
674 }
675
676 /* ARGSUSED */
677 static int
678 zfs_secpolicy_rollback(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
679 {
680 return (zfs_secpolicy_write_perms(zc->zc_name,
681 ZFS_DELEG_PERM_ROLLBACK, cr));
682 }
683
684 /* ARGSUSED */
685 static int
686 zfs_secpolicy_send(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
687 {
688 spa_t *spa;
689 dsl_pool_t *dp;
690 dsl_dataset_t *ds;
691 char *cp;
692 int error;
693
694 /*
695 * Generate the current snapshot name from the given objsetid, then
696 * use that name for the secpolicy/zone checks.
697 */
698 cp = strchr(zc->zc_name, '@');
699 if (cp == NULL)
700 return (EINVAL);
701 error = spa_open(zc->zc_name, &spa, FTAG);
702 if (error)
703 return (error);
704
705 dp = spa_get_dsl(spa);
706 rw_enter(&dp->dp_config_rwlock, RW_READER);
707 error = dsl_dataset_hold_obj(dp, zc->zc_sendobj, FTAG, &ds);
708 rw_exit(&dp->dp_config_rwlock);
709 spa_close(spa, FTAG);
710 if (error)
711 return (error);
712
713 dsl_dataset_name(ds, zc->zc_name);
714
715 error = zfs_secpolicy_write_perms_ds(zc->zc_name, ds,
716 ZFS_DELEG_PERM_SEND, cr);
717 dsl_dataset_rele(ds, FTAG);
718
719 return (error);
720 }
721
722 /* ARGSUSED */
723 static int
724 zfs_secpolicy_send_new(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
725 {
726 return (zfs_secpolicy_write_perms(zc->zc_name,
727 ZFS_DELEG_PERM_SEND, cr));
728 }
729
730 /* ARGSUSED */
731 static int
732 zfs_secpolicy_deleg_share(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
733 {
734 vnode_t *vp;
735 int error;
736
737 if ((error = lookupname(zc->zc_value, UIO_SYSSPACE,
738 NO_FOLLOW, NULL, &vp)) != 0)
739 return (error);
740
741 /* Now make sure mntpnt and dataset are ZFS */
742
743 if (vp->v_vfsp->vfs_fstype != zfsfstype ||
744 (strcmp((char *)refstr_value(vp->v_vfsp->vfs_resource),
745 zc->zc_name) != 0)) {
746 VN_RELE(vp);
747 return (EPERM);
748 }
749
750 VN_RELE(vp);
751 return (dsl_deleg_access(zc->zc_name,
752 ZFS_DELEG_PERM_SHARE, cr));
753 }
754
755 int
756 zfs_secpolicy_share(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
757 {
758 if (!INGLOBALZONE(curproc))
759 return (EPERM);
760
761 if (secpolicy_nfs(cr) == 0) {
762 return (0);
763 } else {
764 return (zfs_secpolicy_deleg_share(zc, innvl, cr));
765 }
766 }
767
768 int
769 zfs_secpolicy_smb_acl(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
770 {
771 if (!INGLOBALZONE(curproc))
772 return (EPERM);
773
774 if (secpolicy_smb(cr) == 0) {
775 return (0);
776 } else {
777 return (zfs_secpolicy_deleg_share(zc, innvl, cr));
778 }
779 }
780
781 static int
782 zfs_get_parent(const char *datasetname, char *parent, int parentsize)
783 {
784 char *cp;
785
786 /*
787 * Remove the @bla or /bla from the end of the name to get the parent.
788 */
789 (void) strncpy(parent, datasetname, parentsize);
790 cp = strrchr(parent, '@');
791 if (cp != NULL) {
792 cp[0] = '\0';
793 } else {
794 cp = strrchr(parent, '/');
795 if (cp == NULL)
796 return (ENOENT);
797 cp[0] = '\0';
798 }
799
800 return (0);
801 }
802
803 int
804 zfs_secpolicy_destroy_perms(const char *name, cred_t *cr)
805 {
806 int error;
807
808 if ((error = zfs_secpolicy_write_perms(name,
809 ZFS_DELEG_PERM_MOUNT, cr)) != 0)
810 return (error);
811
812 return (zfs_secpolicy_write_perms(name, ZFS_DELEG_PERM_DESTROY, cr));
813 }
814
815 /* ARGSUSED */
816 static int
817 zfs_secpolicy_destroy(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
818 {
819 return (zfs_secpolicy_destroy_perms(zc->zc_name, cr));
820 }
821
822 /*
823 * Destroying snapshots with delegated permissions requires
824 * descendant mount and destroy permissions.
825 */
826 /* ARGSUSED */
827 static int
828 zfs_secpolicy_destroy_snaps(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
829 {
830 nvlist_t *snaps;
831 nvpair_t *pair, *nextpair;
832 int error = 0;
833
834 if (nvlist_lookup_nvlist(innvl, "snaps", &snaps) != 0)
835 return (EINVAL);
836 for (pair = nvlist_next_nvpair(snaps, NULL); pair != NULL;
837 pair = nextpair) {
838 dsl_dataset_t *ds;
839
840 nextpair = nvlist_next_nvpair(snaps, pair);
841 error = dsl_dataset_hold(nvpair_name(pair), FTAG, &ds);
842 if (error == 0) {
843 dsl_dataset_rele(ds, FTAG);
844 } else if (error == ENOENT) {
845 /*
846 * Ignore any snapshots that don't exist (we consider
847 * them "already destroyed"). Remove the name from the
848 * nvl here in case the snapshot is created between
849 * now and when we try to destroy it (in which case
850 * we don't want to destroy it since we haven't
851 * checked for permission).
852 */
853 fnvlist_remove_nvpair(snaps, pair);
854 error = 0;
855 continue;
856 } else {
857 break;
858 }
859 error = zfs_secpolicy_destroy_perms(nvpair_name(pair), cr);
860 if (error != 0)
861 break;
862 }
863
864 return (error);
865 }
866
867 int
868 zfs_secpolicy_rename_perms(const char *from, const char *to, cred_t *cr)
869 {
870 char parentname[MAXNAMELEN];
871 int error;
872
873 if ((error = zfs_secpolicy_write_perms(from,
874 ZFS_DELEG_PERM_RENAME, cr)) != 0)
875 return (error);
876
877 if ((error = zfs_secpolicy_write_perms(from,
878 ZFS_DELEG_PERM_MOUNT, cr)) != 0)
879 return (error);
880
881 if ((error = zfs_get_parent(to, parentname,
882 sizeof (parentname))) != 0)
883 return (error);
884
885 if ((error = zfs_secpolicy_write_perms(parentname,
886 ZFS_DELEG_PERM_CREATE, cr)) != 0)
887 return (error);
888
889 if ((error = zfs_secpolicy_write_perms(parentname,
890 ZFS_DELEG_PERM_MOUNT, cr)) != 0)
891 return (error);
892
893 return (error);
894 }
895
896 /* ARGSUSED */
897 static int
898 zfs_secpolicy_rename(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
899 {
900 return (zfs_secpolicy_rename_perms(zc->zc_name, zc->zc_value, cr));
901 }
902
903 /* ARGSUSED */
904 static int
905 zfs_secpolicy_promote(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
906 {
907 char parentname[MAXNAMELEN];
908 objset_t *clone;
909 int error;
910
911 error = zfs_secpolicy_write_perms(zc->zc_name,
912 ZFS_DELEG_PERM_PROMOTE, cr);
913 if (error)
914 return (error);
915
916 error = dmu_objset_hold(zc->zc_name, FTAG, &clone);
917
918 if (error == 0) {
919 dsl_dataset_t *pclone = NULL;
920 dsl_dir_t *dd;
921 dd = clone->os_dsl_dataset->ds_dir;
922
923 rw_enter(&dd->dd_pool->dp_config_rwlock, RW_READER);
924 error = dsl_dataset_hold_obj(dd->dd_pool,
925 dd->dd_phys->dd_origin_obj, FTAG, &pclone);
926 rw_exit(&dd->dd_pool->dp_config_rwlock);
927 if (error) {
928 dmu_objset_rele(clone, FTAG);
929 return (error);
930 }
931
932 error = zfs_secpolicy_write_perms(zc->zc_name,
933 ZFS_DELEG_PERM_MOUNT, cr);
934
935 dsl_dataset_name(pclone, parentname);
936 dmu_objset_rele(clone, FTAG);
937 dsl_dataset_rele(pclone, FTAG);
938 if (error == 0)
939 error = zfs_secpolicy_write_perms(parentname,
940 ZFS_DELEG_PERM_PROMOTE, cr);
941 }
942 return (error);
943 }
944
945 /* ARGSUSED */
946 static int
947 zfs_secpolicy_recv(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
948 {
949 int error;
950
951 if ((error = zfs_secpolicy_write_perms(zc->zc_name,
952 ZFS_DELEG_PERM_RECEIVE, cr)) != 0)
953 return (error);
954
955 if ((error = zfs_secpolicy_write_perms(zc->zc_name,
956 ZFS_DELEG_PERM_MOUNT, cr)) != 0)
957 return (error);
958
959 return (zfs_secpolicy_write_perms(zc->zc_name,
960 ZFS_DELEG_PERM_CREATE, cr));
961 }
962
963 int
964 zfs_secpolicy_snapshot_perms(const char *name, cred_t *cr)
965 {
966 return (zfs_secpolicy_write_perms(name,
967 ZFS_DELEG_PERM_SNAPSHOT, cr));
968 }
969
970 /*
971 * Check for permission to create each snapshot in the nvlist.
972 */
973 /* ARGSUSED */
974 static int
975 zfs_secpolicy_snapshot(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
976 {
977 nvlist_t *snaps;
978 int error;
979 nvpair_t *pair;
980
981 if (nvlist_lookup_nvlist(innvl, "snaps", &snaps) != 0)
982 return (EINVAL);
983 for (pair = nvlist_next_nvpair(snaps, NULL); pair != NULL;
984 pair = nvlist_next_nvpair(snaps, pair)) {
985 char *name = nvpair_name(pair);
986 char *atp = strchr(name, '@');
987
988 if (atp == NULL) {
989 error = EINVAL;
990 break;
991 }
992 *atp = '\0';
993 error = zfs_secpolicy_snapshot_perms(name, cr);
994 *atp = '@';
995 if (error != 0)
996 break;
997 }
998 return (error);
999 }
1000
1001 /* ARGSUSED */
1002 static int
1003 zfs_secpolicy_log_history(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
1004 {
1005 /*
1006 * Even root must have a proper TSD so that we know what pool
1007 * to log to.
1008 */
1009 if (tsd_get(zfs_allow_log_key) == NULL)
1010 return (EPERM);
1011 return (0);
1012 }
1013
1014 static int
1015 zfs_secpolicy_create_clone(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
1016 {
1017 char parentname[MAXNAMELEN];
1018 int error;
1019 char *origin;
1020
1021 if ((error = zfs_get_parent(zc->zc_name, parentname,
1022 sizeof (parentname))) != 0)
1023 return (error);
1024
1025 if (nvlist_lookup_string(innvl, "origin", &origin) == 0 &&
1026 (error = zfs_secpolicy_write_perms(origin,
1027 ZFS_DELEG_PERM_CLONE, cr)) != 0)
1028 return (error);
1029
1030 if ((error = zfs_secpolicy_write_perms(parentname,
1031 ZFS_DELEG_PERM_CREATE, cr)) != 0)
1032 return (error);
1033
1034 return (zfs_secpolicy_write_perms(parentname,
1035 ZFS_DELEG_PERM_MOUNT, cr));
1036 }
1037
1038 /*
1039 * Policy for pool operations - create/destroy pools, add vdevs, etc. Requires
1040 * SYS_CONFIG privilege, which is not available in a local zone.
1041 */
1042 /* ARGSUSED */
1043 static int
1044 zfs_secpolicy_config(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
1045 {
1046 if (secpolicy_sys_config(cr, B_FALSE) != 0)
1047 return (EPERM);
1048
1049 return (0);
1050 }
1051
1052 /*
1053 * Policy for object to name lookups.
1054 */
1055 /* ARGSUSED */
1056 static int
1057 zfs_secpolicy_diff(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
1058 {
1059 int error;
1060
1061 if ((error = secpolicy_sys_config(cr, B_FALSE)) == 0)
1062 return (0);
1063
1064 error = zfs_secpolicy_write_perms(zc->zc_name, ZFS_DELEG_PERM_DIFF, cr);
1065 return (error);
1066 }
1067
1068 /*
1069 * Policy for fault injection. Requires all privileges.
1070 */
1071 /* ARGSUSED */
1072 static int
1073 zfs_secpolicy_inject(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
1074 {
1075 return (secpolicy_zinject(cr));
1076 }
1077
1078 /* ARGSUSED */
1079 static int
1080 zfs_secpolicy_inherit_prop(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
1081 {
1082 zfs_prop_t prop = zfs_name_to_prop(zc->zc_value);
1083
1084 if (prop == ZPROP_INVAL) {
1085 if (!zfs_prop_user(zc->zc_value))
1086 return (EINVAL);
1087 return (zfs_secpolicy_write_perms(zc->zc_name,
1088 ZFS_DELEG_PERM_USERPROP, cr));
1089 } else {
1090 return (zfs_secpolicy_setprop(zc->zc_name, prop,
1091 NULL, cr));
1092 }
1093 }
1094
1095 static int
1096 zfs_secpolicy_userspace_one(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
1097 {
1098 int err = zfs_secpolicy_read(zc, innvl, cr);
1099 if (err)
1100 return (err);
1101
1102 if (zc->zc_objset_type >= ZFS_NUM_USERQUOTA_PROPS)
1103 return (EINVAL);
1104
1105 if (zc->zc_value[0] == 0) {
1106 /*
1107 * They are asking about a posix uid/gid. If it's
1108 * themself, allow it.
1109 */
1110 if (zc->zc_objset_type == ZFS_PROP_USERUSED ||
1111 zc->zc_objset_type == ZFS_PROP_USERQUOTA) {
1112 if (zc->zc_guid == crgetuid(cr))
1113 return (0);
1114 } else {
1115 if (groupmember(zc->zc_guid, cr))
1116 return (0);
1117 }
1118 }
1119
1120 return (zfs_secpolicy_write_perms(zc->zc_name,
1121 userquota_perms[zc->zc_objset_type], cr));
1122 }
1123
1124 static int
1125 zfs_secpolicy_userspace_many(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
1126 {
1127 int err = zfs_secpolicy_read(zc, innvl, cr);
1128 if (err)
1129 return (err);
1130
1131 if (zc->zc_objset_type >= ZFS_NUM_USERQUOTA_PROPS)
1132 return (EINVAL);
1133
1134 return (zfs_secpolicy_write_perms(zc->zc_name,
1135 userquota_perms[zc->zc_objset_type], cr));
1136 }
1137
1138 /* ARGSUSED */
1139 static int
1140 zfs_secpolicy_userspace_upgrade(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
1141 {
1142 return (zfs_secpolicy_setprop(zc->zc_name, ZFS_PROP_VERSION,
1143 NULL, cr));
1144 }
1145
1146 /* ARGSUSED */
1147 static int
1148 zfs_secpolicy_hold(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
1149 {
1150 return (zfs_secpolicy_write_perms(zc->zc_name,
1151 ZFS_DELEG_PERM_HOLD, cr));
1152 }
1153
1154 /* ARGSUSED */
1155 static int
1156 zfs_secpolicy_release(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
1157 {
1158 return (zfs_secpolicy_write_perms(zc->zc_name,
1159 ZFS_DELEG_PERM_RELEASE, cr));
1160 }
1161
1162 /*
1163 * Policy for allowing temporary snapshots to be taken or released
1164 */
1165 static int
1166 zfs_secpolicy_tmp_snapshot(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr)
1167 {
1168 /*
1169 * A temporary snapshot is the same as a snapshot,
1170 * hold, destroy and release all rolled into one.
1171 * Delegated diff alone is sufficient that we allow this.
1172 */
1173 int error;
1174
1175 if ((error = zfs_secpolicy_write_perms(zc->zc_name,
1176 ZFS_DELEG_PERM_DIFF, cr)) == 0)
1177 return (0);
1178
1179 error = zfs_secpolicy_snapshot_perms(zc->zc_name, cr);
1180 if (!error)
1181 error = zfs_secpolicy_hold(zc, innvl, cr);
1182 if (!error)
1183 error = zfs_secpolicy_release(zc, innvl, cr);
1184 if (!error)
1185 error = zfs_secpolicy_destroy(zc, innvl, cr);
1186 return (error);
1187 }
1188
1189 /*
1190 * Returns the nvlist as specified by the user in the zfs_cmd_t.
1191 */
1192 static int
1193 get_nvlist(uint64_t nvl, uint64_t size, int iflag, nvlist_t **nvp)
1194 {
1195 char *packed;
1196 int error;
1197 nvlist_t *list = NULL;
1198
1199 /*
1200 * Read in and unpack the user-supplied nvlist.
1201 */
1202 if (size == 0)
1203 return (EINVAL);
1204
1205 packed = kmem_alloc(size, KM_SLEEP);
1206
1207 if ((error = ddi_copyin((void *)(uintptr_t)nvl, packed, size,
1208 iflag)) != 0) {
1209 kmem_free(packed, size);
1210 return (error);
1211 }
1212
1213 if ((error = nvlist_unpack(packed, size, &list, 0)) != 0) {
1214 kmem_free(packed, size);
1215 return (error);
1216 }
1217
1218 kmem_free(packed, size);
1219
1220 *nvp = list;
1221 return (0);
1222 }
1223
1224 /*
1225 * Reduce the size of this nvlist until it can be serialized in 'max' bytes.
1226 * Entries will be removed from the end of the nvlist, and one int32 entry
1227 * named "N_MORE_ERRORS" will be added indicating how many entries were
1228 * removed.
1229 */
1230 static int
1231 nvlist_smush(nvlist_t *errors, size_t max)
1232 {
1233 size_t size;
1234
1235 size = fnvlist_size(errors);
1236
1237 if (size > max) {
1238 nvpair_t *more_errors;
1239 int n = 0;
1240
1241 if (max < 1024)
1242 return (ENOMEM);
1243
1244 fnvlist_add_int32(errors, ZPROP_N_MORE_ERRORS, 0);
1245 more_errors = nvlist_prev_nvpair(errors, NULL);
1246
1247 do {
1248 nvpair_t *pair = nvlist_prev_nvpair(errors,
1249 more_errors);
1250 fnvlist_remove_nvpair(errors, pair);
1251 n++;
1252 size = fnvlist_size(errors);
1253 } while (size > max);
1254
1255 fnvlist_remove_nvpair(errors, more_errors);
1256 fnvlist_add_int32(errors, ZPROP_N_MORE_ERRORS, n);
1257 ASSERT3U(fnvlist_size(errors), <=, max);
1258 }
1259
1260 return (0);
1261 }
1262
1263 static int
1264 put_nvlist(zfs_cmd_t *zc, nvlist_t *nvl)
1265 {
1266 char *packed = NULL;
1267 int error = 0;
1268 size_t size;
1269
1270 size = fnvlist_size(nvl);
1271
1272 if (size > zc->zc_nvlist_dst_size) {
1273 error = ENOMEM;
1274 } else {
1275 packed = fnvlist_pack(nvl, &size);
1276 if (ddi_copyout(packed, (void *)(uintptr_t)zc->zc_nvlist_dst,
1277 size, zc->zc_iflags) != 0)
1278 error = EFAULT;
1279 fnvlist_pack_free(packed, size);
1280 }
1281
1282 zc->zc_nvlist_dst_size = size;
1283 zc->zc_nvlist_dst_filled = B_TRUE;
1284 return (error);
1285 }
1286
1287 static int
1288 getzfsvfs(const char *dsname, zfsvfs_t **zfvp)
1289 {
1290 objset_t *os;
1291 int error;
1292
1293 error = dmu_objset_hold(dsname, FTAG, &os);
1294 if (error)
1295 return (error);
1296 if (dmu_objset_type(os) != DMU_OST_ZFS) {
1297 dmu_objset_rele(os, FTAG);
1298 return (EINVAL);
1299 }
1300
1301 mutex_enter(&os->os_user_ptr_lock);
1302 *zfvp = dmu_objset_get_user(os);
1303 if (*zfvp) {
1304 VFS_HOLD((*zfvp)->z_vfs);
1305 } else {
1306 error = ESRCH;
1307 }
1308 mutex_exit(&os->os_user_ptr_lock);
1309 dmu_objset_rele(os, FTAG);
1310 return (error);
1311 }
1312
1313 /*
1314 * Find a zfsvfs_t for a mounted filesystem, or create our own, in which
1315 * case its z_vfs will be NULL, and it will be opened as the owner.
1316 * If 'writer' is set, the z_teardown_lock will be held for RW_WRITER,
1317 * which prevents all vnode ops from running.
1318 */
1319 static int
1320 zfsvfs_hold(const char *name, void *tag, zfsvfs_t **zfvp, boolean_t writer)
1321 {
1322 int error = 0;
1323
1324 if (getzfsvfs(name, zfvp) != 0)
1325 error = zfsvfs_create(name, zfvp);
1326 if (error == 0) {
1327 rrw_enter(&(*zfvp)->z_teardown_lock, (writer) ? RW_WRITER :
1328 RW_READER, tag);
1329 if ((*zfvp)->z_unmounted) {
1330 /*
1331 * XXX we could probably try again, since the unmounting
1332 * thread should be just about to disassociate the
1333 * objset from the zfsvfs.
1334 */
1335 rrw_exit(&(*zfvp)->z_teardown_lock, tag);
1336 return (EBUSY);
1337 }
1338 }
1339 return (error);
1340 }
1341
1342 static void
1343 zfsvfs_rele(zfsvfs_t *zfsvfs, void *tag)
1344 {
1345 rrw_exit(&zfsvfs->z_teardown_lock, tag);
1346
1347 if (zfsvfs->z_vfs) {
1348 VFS_RELE(zfsvfs->z_vfs);
1349 } else {
1350 dmu_objset_disown(zfsvfs->z_os, zfsvfs);
1351 zfsvfs_free(zfsvfs);
1352 }
1353 }
1354
1355 static int
1356 zfs_ioc_pool_create(zfs_cmd_t *zc)
1357 {
1358 int error;
1359 nvlist_t *config, *props = NULL;
1360 nvlist_t *rootprops = NULL;
1361 nvlist_t *zplprops = NULL;
1362
1363 if (error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size,
1364 zc->zc_iflags, &config))
1365 return (error);
1366
1367 if (zc->zc_nvlist_src_size != 0 && (error =
1368 get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
1369 zc->zc_iflags, &props))) {
1370 nvlist_free(config);
1371 return (error);
1372 }
1373
1374 if (props) {
1375 nvlist_t *nvl = NULL;
1376 uint64_t version = SPA_VERSION;
1377
1378 (void) nvlist_lookup_uint64(props,
1379 zpool_prop_to_name(ZPOOL_PROP_VERSION), &version);
1380 if (!SPA_VERSION_IS_SUPPORTED(version)) {
1381 error = EINVAL;
1382 goto pool_props_bad;
1383 }
1384 (void) nvlist_lookup_nvlist(props, ZPOOL_ROOTFS_PROPS, &nvl);
1385 if (nvl) {
1386 error = nvlist_dup(nvl, &rootprops, KM_SLEEP);
1387 if (error != 0) {
1388 nvlist_free(config);
1389 nvlist_free(props);
1390 return (error);
1391 }
1392 (void) nvlist_remove_all(props, ZPOOL_ROOTFS_PROPS);
1393 }
1394 VERIFY(nvlist_alloc(&zplprops, NV_UNIQUE_NAME, KM_SLEEP) == 0);
1395 error = zfs_fill_zplprops_root(version, rootprops,
1396 zplprops, NULL);
1397 if (error)
1398 goto pool_props_bad;
1399 }
1400
1401 error = spa_create(zc->zc_name, config, props, zplprops);
1402
1403 /*
1404 * Set the remaining root properties
1405 */
1406 if (!error && (error = zfs_set_prop_nvlist(zc->zc_name,
1407 ZPROP_SRC_LOCAL, rootprops, NULL)) != 0)
1408 (void) spa_destroy(zc->zc_name);
1409
1410 pool_props_bad:
1411 nvlist_free(rootprops);
1412 nvlist_free(zplprops);
1413 nvlist_free(config);
1414 nvlist_free(props);
1415
1416 return (error);
1417 }
1418
1419 static int
1420 zfs_ioc_pool_destroy(zfs_cmd_t *zc)
1421 {
1422 int error;
1423 zfs_log_history(zc);
1424 error = spa_destroy(zc->zc_name);
1425 if (error == 0)
1426 zvol_remove_minors(zc->zc_name);
1427 return (error);
1428 }
1429
1430 static int
1431 zfs_ioc_pool_import(zfs_cmd_t *zc)
1432 {
1433 nvlist_t *config, *props = NULL;
1434 uint64_t guid;
1435 int error;
1436
1437 if ((error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size,
1438 zc->zc_iflags, &config)) != 0)
1439 return (error);
1440
1441 if (zc->zc_nvlist_src_size != 0 && (error =
1442 get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
1443 zc->zc_iflags, &props))) {
1444 nvlist_free(config);
1445 return (error);
1446 }
1447
1448 if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, &guid) != 0 ||
1449 guid != zc->zc_guid)
1450 error = EINVAL;
1451 else
1452 error = spa_import(zc->zc_name, config, props, zc->zc_cookie);
1453
1454 if (zc->zc_nvlist_dst != 0) {
1455 int err;
1456
1457 if ((err = put_nvlist(zc, config)) != 0)
1458 error = err;
1459 }
1460
1461 nvlist_free(config);
1462
1463 if (props)
1464 nvlist_free(props);
1465
1466 return (error);
1467 }
1468
1469 static int
1470 zfs_ioc_pool_export(zfs_cmd_t *zc)
1471 {
1472 int error;
1473 boolean_t force = (boolean_t)zc->zc_cookie;
1474 boolean_t hardforce = (boolean_t)zc->zc_guid;
1475
1476 zfs_log_history(zc);
1477 error = spa_export(zc->zc_name, NULL, force, hardforce);
1478 if (error == 0)
1479 zvol_remove_minors(zc->zc_name);
1480 return (error);
1481 }
1482
1483 static int
1484 zfs_ioc_pool_configs(zfs_cmd_t *zc)
1485 {
1486 nvlist_t *configs;
1487 int error;
1488
1489 if ((configs = spa_all_configs(&zc->zc_cookie)) == NULL)
1490 return (EEXIST);
1491
1492 error = put_nvlist(zc, configs);
1493
1494 nvlist_free(configs);
1495
1496 return (error);
1497 }
1498
1499 /*
1500 * inputs:
1501 * zc_name name of the pool
1502 *
1503 * outputs:
1504 * zc_cookie real errno
1505 * zc_nvlist_dst config nvlist
1506 * zc_nvlist_dst_size size of config nvlist
1507 */
1508 static int
1509 zfs_ioc_pool_stats(zfs_cmd_t *zc)
1510 {
1511 nvlist_t *config;
1512 int error;
1513 int ret = 0;
1514
1515 error = spa_get_stats(zc->zc_name, &config, zc->zc_value,
1516 sizeof (zc->zc_value));
1517
1518 if (config != NULL) {
1519 ret = put_nvlist(zc, config);
1520 nvlist_free(config);
1521
1522 /*
1523 * The config may be present even if 'error' is non-zero.
1524 * In this case we return success, and preserve the real errno
1525 * in 'zc_cookie'.
1526 */
1527 zc->zc_cookie = error;
1528 } else {
1529 ret = error;
1530 }
1531
1532 return (ret);
1533 }
1534
1535 /*
1536 * Try to import the given pool, returning pool stats as appropriate so that
1537 * user land knows which devices are available and overall pool health.
1538 */
1539 static int
1540 zfs_ioc_pool_tryimport(zfs_cmd_t *zc)
1541 {
1542 nvlist_t *tryconfig, *config;
1543 int error;
1544
1545 if ((error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size,
1546 zc->zc_iflags, &tryconfig)) != 0)
1547 return (error);
1548
1549 config = spa_tryimport(tryconfig);
1550
1551 nvlist_free(tryconfig);
1552
1553 if (config == NULL)
1554 return (EINVAL);
1555
1556 error = put_nvlist(zc, config);
1557 nvlist_free(config);
1558
1559 return (error);
1560 }
1561
1562 /*
1563 * inputs:
1564 * zc_name name of the pool
1565 * zc_cookie scan func (pool_scan_func_t)
1566 */
1567 static int
1568 zfs_ioc_pool_scan(zfs_cmd_t *zc)
1569 {
1570 spa_t *spa;
1571 int error;
1572
1573 if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
1574 return (error);
1575
1576 if (zc->zc_cookie == POOL_SCAN_NONE)
1577 error = spa_scan_stop(spa);
1578 else
1579 error = spa_scan(spa, zc->zc_cookie);
1580
1581 spa_close(spa, FTAG);
1582
1583 return (error);
1584 }
1585
1586 static int
1587 zfs_ioc_pool_freeze(zfs_cmd_t *zc)
1588 {
1589 spa_t *spa;
1590 int error;
1591
1592 error = spa_open(zc->zc_name, &spa, FTAG);
1593 if (error == 0) {
1594 spa_freeze(spa);
1595 spa_close(spa, FTAG);
1596 }
1597 return (error);
1598 }
1599
1600 static int
1601 zfs_ioc_pool_upgrade(zfs_cmd_t *zc)
1602 {
1603 spa_t *spa;
1604 int error;
1605
1606 if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
1607 return (error);
1608
1609 if (zc->zc_cookie < spa_version(spa) ||
1610 !SPA_VERSION_IS_SUPPORTED(zc->zc_cookie)) {
1611 spa_close(spa, FTAG);
1612 return (EINVAL);
1613 }
1614
1615 spa_upgrade(spa, zc->zc_cookie);
1616 spa_close(spa, FTAG);
1617
1618 return (error);
1619 }
1620
1621 static int
1622 zfs_ioc_pool_get_history(zfs_cmd_t *zc)
1623 {
1624 spa_t *spa;
1625 char *hist_buf;
1626 uint64_t size;
1627 int error;
1628
1629 if ((size = zc->zc_history_len) == 0)
1630 return (EINVAL);
1631
1632 if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
1633 return (error);
1634
1635 if (spa_version(spa) < SPA_VERSION_ZPOOL_HISTORY) {
1636 spa_close(spa, FTAG);
1637 return (ENOTSUP);
1638 }
1639
1640 hist_buf = kmem_alloc(size, KM_SLEEP);
1641 if ((error = spa_history_get(spa, &zc->zc_history_offset,
1642 &zc->zc_history_len, hist_buf)) == 0) {
1643 error = ddi_copyout(hist_buf,
1644 (void *)(uintptr_t)zc->zc_history,
1645 zc->zc_history_len, zc->zc_iflags);
1646 }
1647
1648 spa_close(spa, FTAG);
1649 kmem_free(hist_buf, size);
1650 return (error);
1651 }
1652
1653 static int
1654 zfs_ioc_pool_reguid(zfs_cmd_t *zc)
1655 {
1656 spa_t *spa;
1657 int error;
1658
1659 error = spa_open(zc->zc_name, &spa, FTAG);
1660 if (error == 0) {
1661 error = spa_change_guid(spa);
1662 spa_close(spa, FTAG);
1663 }
1664 return (error);
1665 }
1666
1667 static int
1668 zfs_ioc_dsobj_to_dsname(zfs_cmd_t *zc)
1669 {
1670 int error;
1671
1672 if (error = dsl_dsobj_to_dsname(zc->zc_name, zc->zc_obj, zc->zc_value))
1673 return (error);
1674
1675 return (0);
1676 }
1677
1678 /*
1679 * inputs:
1680 * zc_name name of filesystem
1681 * zc_obj object to find
1682 *
1683 * outputs:
1684 * zc_value name of object
1685 */
1686 static int
1687 zfs_ioc_obj_to_path(zfs_cmd_t *zc)
1688 {
1689 objset_t *os;
1690 int error;
1691
1692 /* XXX reading from objset not owned */
1693 if ((error = dmu_objset_hold(zc->zc_name, FTAG, &os)) != 0)
1694 return (error);
1695 if (dmu_objset_type(os) != DMU_OST_ZFS) {
1696 dmu_objset_rele(os, FTAG);
1697 return (EINVAL);
1698 }
1699 error = zfs_obj_to_path(os, zc->zc_obj, zc->zc_value,
1700 sizeof (zc->zc_value));
1701 dmu_objset_rele(os, FTAG);
1702
1703 return (error);
1704 }
1705
1706 /*
1707 * inputs:
1708 * zc_name name of filesystem
1709 * zc_obj object to find
1710 *
1711 * outputs:
1712 * zc_stat stats on object
1713 * zc_value path to object
1714 */
1715 static int
1716 zfs_ioc_obj_to_stats(zfs_cmd_t *zc)
1717 {
1718 objset_t *os;
1719 int error;
1720
1721 /* XXX reading from objset not owned */
1722 if ((error = dmu_objset_hold(zc->zc_name, FTAG, &os)) != 0)
1723 return (error);
1724 if (dmu_objset_type(os) != DMU_OST_ZFS) {
1725 dmu_objset_rele(os, FTAG);
1726 return (EINVAL);
1727 }
1728 error = zfs_obj_to_stats(os, zc->zc_obj, &zc->zc_stat, zc->zc_value,
1729 sizeof (zc->zc_value));
1730 dmu_objset_rele(os, FTAG);
1731
1732 return (error);
1733 }
1734
1735 static int
1736 zfs_ioc_vdev_add(zfs_cmd_t *zc)
1737 {
1738 spa_t *spa;
1739 int error;
1740 nvlist_t *config, **l2cache, **spares;
1741 uint_t nl2cache = 0, nspares = 0;
1742
1743 error = spa_open(zc->zc_name, &spa, FTAG);
1744 if (error != 0)
1745 return (error);
1746
1747 error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size,
1748 zc->zc_iflags, &config);
1749 (void) nvlist_lookup_nvlist_array(config, ZPOOL_CONFIG_L2CACHE,
1750 &l2cache, &nl2cache);
1751
1752 (void) nvlist_lookup_nvlist_array(config, ZPOOL_CONFIG_SPARES,
1753 &spares, &nspares);
1754
1755 /*
1756 * A root pool with concatenated devices is not supported.
1757 * Thus, can not add a device to a root pool.
1758 *
1759 * Intent log device can not be added to a rootpool because
1760 * during mountroot, zil is replayed, a seperated log device
1761 * can not be accessed during the mountroot time.
1762 *
1763 * l2cache and spare devices are ok to be added to a rootpool.
1764 */
1765 if (spa_bootfs(spa) != 0 && nl2cache == 0 && nspares == 0) {
1766 nvlist_free(config);
1767 spa_close(spa, FTAG);
1768 return (EDOM);
1769 }
1770
1771 if (error == 0) {
1772 error = spa_vdev_add(spa, config);
1773 nvlist_free(config);
1774 }
1775 spa_close(spa, FTAG);
1776 return (error);
1777 }
1778
1779 /*
1780 * inputs:
1781 * zc_name name of the pool
1782 * zc_nvlist_conf nvlist of devices to remove
1783 * zc_cookie to stop the remove?
1784 */
1785 static int
1786 zfs_ioc_vdev_remove(zfs_cmd_t *zc)
1787 {
1788 spa_t *spa;
1789 int error;
1790
1791 error = spa_open(zc->zc_name, &spa, FTAG);
1792 if (error != 0)
1793 return (error);
1794 error = spa_vdev_remove(spa, zc->zc_guid, B_FALSE);
1795 spa_close(spa, FTAG);
1796 return (error);
1797 }
1798
1799 static int
1800 zfs_ioc_vdev_set_state(zfs_cmd_t *zc)
1801 {
1802 spa_t *spa;
1803 int error;
1804 vdev_state_t newstate = VDEV_STATE_UNKNOWN;
1805
1806 if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
1807 return (error);
1808 switch (zc->zc_cookie) {
1809 case VDEV_STATE_ONLINE:
1810 error = vdev_online(spa, zc->zc_guid, zc->zc_obj, &newstate);
1811 break;
1812
1813 case VDEV_STATE_OFFLINE:
1814 error = vdev_offline(spa, zc->zc_guid, zc->zc_obj);
1815 break;
1816
1817 case VDEV_STATE_FAULTED:
1818 if (zc->zc_obj != VDEV_AUX_ERR_EXCEEDED &&
1819 zc->zc_obj != VDEV_AUX_EXTERNAL)
1820 zc->zc_obj = VDEV_AUX_ERR_EXCEEDED;
1821
1822 error = vdev_fault(spa, zc->zc_guid, zc->zc_obj);
1823 break;
1824
1825 case VDEV_STATE_DEGRADED:
1826 if (zc->zc_obj != VDEV_AUX_ERR_EXCEEDED &&
1827 zc->zc_obj != VDEV_AUX_EXTERNAL)
1828 zc->zc_obj = VDEV_AUX_ERR_EXCEEDED;
1829
1830 error = vdev_degrade(spa, zc->zc_guid, zc->zc_obj);
1831 break;
1832
1833 default:
1834 error = EINVAL;
1835 }
1836 zc->zc_cookie = newstate;
1837 spa_close(spa, FTAG);
1838 return (error);
1839 }
1840
1841 static int
1842 zfs_ioc_vdev_attach(zfs_cmd_t *zc)
1843 {
1844 spa_t *spa;
1845 int replacing = zc->zc_cookie;
1846 nvlist_t *config;
1847 int error;
1848
1849 if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
1850 return (error);
1851
1852 if ((error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size,
1853 zc->zc_iflags, &config)) == 0) {
1854 error = spa_vdev_attach(spa, zc->zc_guid, config, replacing);
1855 nvlist_free(config);
1856 }
1857
1858 spa_close(spa, FTAG);
1859 return (error);
1860 }
1861
1862 static int
1863 zfs_ioc_vdev_detach(zfs_cmd_t *zc)
1864 {
1865 spa_t *spa;
1866 int error;
1867
1868 if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
1869 return (error);
1870
1871 error = spa_vdev_detach(spa, zc->zc_guid, 0, B_FALSE);
1872
1873 spa_close(spa, FTAG);
1874 return (error);
1875 }
1876
1877 static int
1878 zfs_ioc_vdev_split(zfs_cmd_t *zc)
1879 {
1880 spa_t *spa;
1881 nvlist_t *config, *props = NULL;
1882 int error;
1883 boolean_t exp = !!(zc->zc_cookie & ZPOOL_EXPORT_AFTER_SPLIT);
1884
1885 if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
1886 return (error);
1887
1888 if (error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size,
1889 zc->zc_iflags, &config)) {
1890 spa_close(spa, FTAG);
1891 return (error);
1892 }
1893
1894 if (zc->zc_nvlist_src_size != 0 && (error =
1895 get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
1896 zc->zc_iflags, &props))) {
1897 spa_close(spa, FTAG);
1898 nvlist_free(config);
1899 return (error);
1900 }
1901
1902 error = spa_vdev_split_mirror(spa, zc->zc_string, config, props, exp);
1903
1904 spa_close(spa, FTAG);
1905
1906 nvlist_free(config);
1907 nvlist_free(props);
1908
1909 return (error);
1910 }
1911
1912 static int
1913 zfs_ioc_vdev_setpath(zfs_cmd_t *zc)
1914 {
1915 spa_t *spa;
1916 char *path = zc->zc_value;
1917 uint64_t guid = zc->zc_guid;
1918 int error;
1919
1920 error = spa_open(zc->zc_name, &spa, FTAG);
1921 if (error != 0)
1922 return (error);
1923
1924 error = spa_vdev_setpath(spa, guid, path);
1925 spa_close(spa, FTAG);
1926 return (error);
1927 }
1928
1929 static int
1930 zfs_ioc_vdev_setfru(zfs_cmd_t *zc)
1931 {
1932 spa_t *spa;
1933 char *fru = zc->zc_value;
1934 uint64_t guid = zc->zc_guid;
1935 int error;
1936
1937 error = spa_open(zc->zc_name, &spa, FTAG);
1938 if (error != 0)
1939 return (error);
1940
1941 error = spa_vdev_setfru(spa, guid, fru);
1942 spa_close(spa, FTAG);
1943 return (error);
1944 }
1945
1946 static int
1947 zfs_ioc_objset_stats_impl(zfs_cmd_t *zc, objset_t *os)
1948 {
1949 int error = 0;
1950 nvlist_t *nv;
1951
1952 dmu_objset_fast_stat(os, &zc->zc_objset_stats);
1953
1954 if (zc->zc_nvlist_dst != 0 &&
1955 (error = dsl_prop_get_all(os, &nv)) == 0) {
1956 dmu_objset_stats(os, nv);
1957 /*
1958 * NB: zvol_get_stats() will read the objset contents,
1959 * which we aren't supposed to do with a
1960 * DS_MODE_USER hold, because it could be
1961 * inconsistent. So this is a bit of a workaround...
1962 * XXX reading with out owning
1963 */
1964 if (!zc->zc_objset_stats.dds_inconsistent &&
1965 dmu_objset_type(os) == DMU_OST_ZVOL) {
1966 error = zvol_get_stats(os, nv);
1967 if (error == EIO)
1968 return (error);
1969 VERIFY0(error);
1970 }
1971 error = put_nvlist(zc, nv);
1972 nvlist_free(nv);
1973 }
1974
1975 return (error);
1976 }
1977
1978 /*
1979 * inputs:
1980 * zc_name name of filesystem
1981 * zc_nvlist_dst_size size of buffer for property nvlist
1982 *
1983 * outputs:
1984 * zc_objset_stats stats
1985 * zc_nvlist_dst property nvlist
1986 * zc_nvlist_dst_size size of property nvlist
1987 */
1988 static int
1989 zfs_ioc_objset_stats(zfs_cmd_t *zc)
1990 {
1991 objset_t *os = NULL;
1992 int error;
1993
1994 if (error = dmu_objset_hold(zc->zc_name, FTAG, &os))
1995 return (error);
1996
1997 error = zfs_ioc_objset_stats_impl(zc, os);
1998
1999 dmu_objset_rele(os, FTAG);
2000
2001 return (error);
2002 }
2003
2004 /*
2005 * inputs:
2006 * zc_name name of filesystem
2007 * zc_nvlist_dst_size size of buffer for property nvlist
2008 *
2009 * outputs:
2010 * zc_nvlist_dst received property nvlist
2011 * zc_nvlist_dst_size size of received property nvlist
2012 *
2013 * Gets received properties (distinct from local properties on or after
2014 * SPA_VERSION_RECVD_PROPS) for callers who want to differentiate received from
2015 * local property values.
2016 */
2017 static int
2018 zfs_ioc_objset_recvd_props(zfs_cmd_t *zc)
2019 {
2020 objset_t *os = NULL;
2021 int error;
2022 nvlist_t *nv;
2023
2024 if (error = dmu_objset_hold(zc->zc_name, FTAG, &os))
2025 return (error);
2026
2027 /*
2028 * Without this check, we would return local property values if the
2029 * caller has not already received properties on or after
2030 * SPA_VERSION_RECVD_PROPS.
2031 */
2032 if (!dsl_prop_get_hasrecvd(os)) {
2033 dmu_objset_rele(os, FTAG);
2034 return (ENOTSUP);
2035 }
2036
2037 if (zc->zc_nvlist_dst != 0 &&
2038 (error = dsl_prop_get_received(os, &nv)) == 0) {
2039 error = put_nvlist(zc, nv);
2040 nvlist_free(nv);
2041 }
2042
2043 dmu_objset_rele(os, FTAG);
2044 return (error);
2045 }
2046
2047 static int
2048 nvl_add_zplprop(objset_t *os, nvlist_t *props, zfs_prop_t prop)
2049 {
2050 uint64_t value;
2051 int error;
2052
2053 /*
2054 * zfs_get_zplprop() will either find a value or give us
2055 * the default value (if there is one).
2056 */
2057 if ((error = zfs_get_zplprop(os, prop, &value)) != 0)
2058 return (error);
2059 VERIFY(nvlist_add_uint64(props, zfs_prop_to_name(prop), value) == 0);
2060 return (0);
2061 }
2062
2063 /*
2064 * inputs:
2065 * zc_name name of filesystem
2066 * zc_nvlist_dst_size size of buffer for zpl property nvlist
2067 *
2068 * outputs:
2069 * zc_nvlist_dst zpl property nvlist
2070 * zc_nvlist_dst_size size of zpl property nvlist
2071 */
2072 static int
2073 zfs_ioc_objset_zplprops(zfs_cmd_t *zc)
2074 {
2075 objset_t *os;
2076 int err;
2077
2078 /* XXX reading without owning */
2079 if (err = dmu_objset_hold(zc->zc_name, FTAG, &os))
2080 return (err);
2081
2082 dmu_objset_fast_stat(os, &zc->zc_objset_stats);
2083
2084 /*
2085 * NB: nvl_add_zplprop() will read the objset contents,
2086 * which we aren't supposed to do with a DS_MODE_USER
2087 * hold, because it could be inconsistent.
2088 */
2089 if (zc->zc_nvlist_dst != NULL &&
2090 !zc->zc_objset_stats.dds_inconsistent &&
2091 dmu_objset_type(os) == DMU_OST_ZFS) {
2092 nvlist_t *nv;
2093
2094 VERIFY(nvlist_alloc(&nv, NV_UNIQUE_NAME, KM_SLEEP) == 0);
2095 if ((err = nvl_add_zplprop(os, nv, ZFS_PROP_VERSION)) == 0 &&
2096 (err = nvl_add_zplprop(os, nv, ZFS_PROP_NORMALIZE)) == 0 &&
2097 (err = nvl_add_zplprop(os, nv, ZFS_PROP_UTF8ONLY)) == 0 &&
2098 (err = nvl_add_zplprop(os, nv, ZFS_PROP_CASE)) == 0)
2099 err = put_nvlist(zc, nv);
2100 nvlist_free(nv);
2101 } else {
2102 err = ENOENT;
2103 }
2104 dmu_objset_rele(os, FTAG);
2105 return (err);
2106 }
2107
2108 static boolean_t
2109 dataset_name_hidden(const char *name)
2110 {
2111 /*
2112 * Skip over datasets that are not visible in this zone,
2113 * internal datasets (which have a $ in their name), and
2114 * temporary datasets (which have a % in their name).
2115 */
2116 if (strchr(name, '$') != NULL)
2117 return (B_TRUE);
2118 if (strchr(name, '%') != NULL)
2119 return (B_TRUE);
2120 if (!INGLOBALZONE(curproc) && !zone_dataset_visible(name, NULL))
2121 return (B_TRUE);
2122 return (B_FALSE);
2123 }
2124
2125 /*
2126 * inputs:
2127 * zc_name name of filesystem
2128 * zc_cookie zap cursor
2129 * zc_nvlist_dst_size size of buffer for property nvlist
2130 *
2131 * outputs:
2132 * zc_name name of next filesystem
2133 * zc_cookie zap cursor
2134 * zc_objset_stats stats
2135 * zc_nvlist_dst property nvlist
2136 * zc_nvlist_dst_size size of property nvlist
2137 */
2138 static int
2139 zfs_ioc_dataset_list_next(zfs_cmd_t *zc)
2140 {
2141 objset_t *os;
2142 int error;
2143 char *p;
2144 size_t orig_len = strlen(zc->zc_name);
2145
2146 top:
2147 if (error = dmu_objset_hold(zc->zc_name, FTAG, &os)) {
2148 if (error == ENOENT)
2149 error = ESRCH;
2150 return (error);
2151 }
2152
2153 p = strrchr(zc->zc_name, '/');
2154 if (p == NULL || p[1] != '\0')
2155 (void) strlcat(zc->zc_name, "/", sizeof (zc->zc_name));
2156 p = zc->zc_name + strlen(zc->zc_name);
2157
2158 /*
2159 * Pre-fetch the datasets. dmu_objset_prefetch() always returns 0
2160 * but is not declared void because its called by dmu_objset_find().
2161 */
2162 if (zc->zc_cookie == 0) {
2163 uint64_t cookie = 0;
2164 int len = sizeof (zc->zc_name) - (p - zc->zc_name);
2165
2166 while (dmu_dir_list_next(os, len, p, NULL, &cookie) == 0) {
2167 if (!dataset_name_hidden(zc->zc_name))
2168 (void) dmu_objset_prefetch(zc->zc_name, NULL);
2169 }
2170 }
2171
2172 do {
2173 error = dmu_dir_list_next(os,
2174 sizeof (zc->zc_name) - (p - zc->zc_name), p,
2175 NULL, &zc->zc_cookie);
2176 if (error == ENOENT)
2177 error = ESRCH;
2178 } while (error == 0 && dataset_name_hidden(zc->zc_name));
2179 dmu_objset_rele(os, FTAG);
2180
2181 /*
2182 * If it's an internal dataset (ie. with a '$' in its name),
2183 * don't try to get stats for it, otherwise we'll return ENOENT.
2184 */
2185 if (error == 0 && strchr(zc->zc_name, '$') == NULL) {
2186 error = zfs_ioc_objset_stats(zc); /* fill in the stats */
2187 if (error == ENOENT) {
2188 /* We lost a race with destroy, get the next one. */
2189 zc->zc_name[orig_len] = '\0';
2190 goto top;
2191 }
2192 }
2193 return (error);
2194 }
2195
2196 /*
2197 * inputs:
2198 * zc_name name of filesystem
2199 * zc_cookie zap cursor
2200 * zc_nvlist_dst_size size of buffer for property nvlist
2201 *
2202 * outputs:
2203 * zc_name name of next snapshot
2204 * zc_objset_stats stats
2205 * zc_nvlist_dst property nvlist
2206 * zc_nvlist_dst_size size of property nvlist
2207 */
2208 static int
2209 zfs_ioc_snapshot_list_next(zfs_cmd_t *zc)
2210 {
2211 objset_t *os;
2212 int error;
2213
2214 top:
2215 if (zc->zc_cookie == 0)
2216 (void) dmu_objset_find(zc->zc_name, dmu_objset_prefetch,
2217 NULL, DS_FIND_SNAPSHOTS);
2218
2219 error = dmu_objset_hold(zc->zc_name, FTAG, &os);
2220 if (error)
2221 return (error == ENOENT ? ESRCH : error);
2222
2223 /*
2224 * A dataset name of maximum length cannot have any snapshots,
2225 * so exit immediately.
2226 */
2227 if (strlcat(zc->zc_name, "@", sizeof (zc->zc_name)) >= MAXNAMELEN) {
2228 dmu_objset_rele(os, FTAG);
2229 return (ESRCH);
2230 }
2231
2232 error = dmu_snapshot_list_next(os,
2233 sizeof (zc->zc_name) - strlen(zc->zc_name),
2234 zc->zc_name + strlen(zc->zc_name), &zc->zc_obj, &zc->zc_cookie,
2235 NULL);
2236
2237 if (error == 0) {
2238 dsl_dataset_t *ds;
2239 dsl_pool_t *dp = os->os_dsl_dataset->ds_dir->dd_pool;
2240
2241 /*
2242 * Since we probably don't have a hold on this snapshot,
2243 * it's possible that the objsetid could have been destroyed
2244 * and reused for a new objset. It's OK if this happens during
2245 * a zfs send operation, since the new createtxg will be
2246 * beyond the range we're interested in.
2247 */
2248 rw_enter(&dp->dp_config_rwlock, RW_READER);
2249 error = dsl_dataset_hold_obj(dp, zc->zc_obj, FTAG, &ds);
2250 rw_exit(&dp->dp_config_rwlock);
2251 if (error) {
2252 if (error == ENOENT) {
2253 /* Racing with destroy, get the next one. */
2254 *strchr(zc->zc_name, '@') = '\0';
2255 dmu_objset_rele(os, FTAG);
2256 goto top;
2257 }
2258 } else {
2259 objset_t *ossnap;
2260
2261 error = dmu_objset_from_ds(ds, &ossnap);
2262 if (error == 0)
2263 error = zfs_ioc_objset_stats_impl(zc, ossnap);
2264 dsl_dataset_rele(ds, FTAG);
2265 }
2266 } else if (error == ENOENT) {
2267 error = ESRCH;
2268 }
2269
2270 dmu_objset_rele(os, FTAG);
2271 /* if we failed, undo the @ that we tacked on to zc_name */
2272 if (error)
2273 *strchr(zc->zc_name, '@') = '\0';
2274 return (error);
2275 }
2276
2277 static int
2278 zfs_prop_set_userquota(const char *dsname, nvpair_t *pair)
2279 {
2280 const char *propname = nvpair_name(pair);
2281 uint64_t *valary;
2282 unsigned int vallen;
2283 const char *domain;
2284 char *dash;
2285 zfs_userquota_prop_t type;
2286 uint64_t rid;
2287 uint64_t quota;
2288 zfsvfs_t *zfsvfs;
2289 int err;
2290
2291 if (nvpair_type(pair) == DATA_TYPE_NVLIST) {
2292 nvlist_t *attrs;
2293 VERIFY(nvpair_value_nvlist(pair, &attrs) == 0);
2294 if (nvlist_lookup_nvpair(attrs, ZPROP_VALUE,
2295 &pair) != 0)
2296 return (EINVAL);
2297 }
2298
2299 /*
2300 * A correctly constructed propname is encoded as
2301 * userquota@<rid>-<domain>.
2302 */
2303 if ((dash = strchr(propname, '-')) == NULL ||
2304 nvpair_value_uint64_array(pair, &valary, &vallen) != 0 ||
2305 vallen != 3)
2306 return (EINVAL);
2307
2308 domain = dash + 1;
2309 type = valary[0];
2310 rid = valary[1];
2311 quota = valary[2];
2312
2313 err = zfsvfs_hold(dsname, FTAG, &zfsvfs, B_FALSE);
2314 if (err == 0) {
2315 err = zfs_set_userquota(zfsvfs, type, domain, rid, quota);
2316 zfsvfs_rele(zfsvfs, FTAG);
2317 }
2318
2319 return (err);
2320 }
2321
2322 /*
2323 * If the named property is one that has a special function to set its value,
2324 * return 0 on success and a positive error code on failure; otherwise if it is
2325 * not one of the special properties handled by this function, return -1.
2326 *
2327 * XXX: It would be better for callers of the property interface if we handled
2328 * these special cases in dsl_prop.c (in the dsl layer).
2329 */
2330 static int
2331 zfs_prop_set_special(const char *dsname, zprop_source_t source,
2332 nvpair_t *pair)
2333 {
2334 const char *propname = nvpair_name(pair);
2335 zfs_prop_t prop = zfs_name_to_prop(propname);
2336 uint64_t intval;
2337 int err;
2338
2339 if (prop == ZPROP_INVAL) {
2340 if (zfs_prop_userquota(propname))
2341 return (zfs_prop_set_userquota(dsname, pair));
2342 return (-1);
2343 }
2344
2345 if (nvpair_type(pair) == DATA_TYPE_NVLIST) {
2346 nvlist_t *attrs;
2347 VERIFY(nvpair_value_nvlist(pair, &attrs) == 0);
2348 VERIFY(nvlist_lookup_nvpair(attrs, ZPROP_VALUE,
2349 &pair) == 0);
2350 }
2351
2352 if (zfs_prop_get_type(prop) == PROP_TYPE_STRING)
2353 return (-1);
2354
2355 VERIFY(0 == nvpair_value_uint64(pair, &intval));
2356
2357 switch (prop) {
2358 case ZFS_PROP_QUOTA:
2359 err = dsl_dir_set_quota(dsname, source, intval);
2360 break;
2361 case ZFS_PROP_REFQUOTA:
2362 err = dsl_dataset_set_quota(dsname, source, intval);
2363 break;
2364 case ZFS_PROP_RESERVATION:
2365 err = dsl_dir_set_reservation(dsname, source, intval);
2366 break;
2367 case ZFS_PROP_REFRESERVATION:
2368 err = dsl_dataset_set_reservation(dsname, source, intval);
2369 break;
2370 case ZFS_PROP_VOLSIZE:
2371 err = zvol_set_volsize(dsname, ddi_driver_major(zfs_dip),
2372 intval);
2373 break;
2374 case ZFS_PROP_VERSION:
2375 {
2376 zfsvfs_t *zfsvfs;
2377
2378 if ((err = zfsvfs_hold(dsname, FTAG, &zfsvfs, B_TRUE)) != 0)
2379 break;
2380
2381 err = zfs_set_version(zfsvfs, intval);
2382 zfsvfs_rele(zfsvfs, FTAG);
2383
2384 if (err == 0 && intval >= ZPL_VERSION_USERSPACE) {
2385 zfs_cmd_t *zc;
2386
2387 zc = kmem_zalloc(sizeof (zfs_cmd_t), KM_SLEEP);
2388 (void) strcpy(zc->zc_name, dsname);
2389 (void) zfs_ioc_userspace_upgrade(zc);
2390 kmem_free(zc, sizeof (zfs_cmd_t));
2391 }
2392 break;
2393 }
2394 case ZFS_PROP_COMPRESSION:
2395 {
2396 if (intval == ZIO_COMPRESS_LZ4) {
2397 zfeature_info_t *feature =
2398 &spa_feature_table[SPA_FEATURE_LZ4_COMPRESS];
2399 spa_t *spa;
2400 dsl_pool_t *dp;
2401
2402 if ((err = spa_open(dsname, &spa, FTAG)) != 0)
2403 return (err);
2404
2405 dp = spa->spa_dsl_pool;
2406
2407 /*
2408 * Setting the LZ4 compression algorithm activates
2409 * the feature.
2410 */
2411 if (!spa_feature_is_active(spa, feature)) {
2412 if ((err = zfs_prop_activate_feature(dp,
2413 feature)) != 0) {
2414 spa_close(spa, FTAG);
2415 return (err);
2416 }
2417 }
2418
2419 spa_close(spa, FTAG);
2420 }
2421 /*
2422 * We still want the default set action to be performed in the
2423 * caller, we only performed zfeature settings here.
2424 */
2425 err = -1;
2426 break;
2427 }
2428
2429 default:
2430 err = -1;
2431 }
2432
2433 return (err);
2434 }
2435
2436 /*
2437 * This function is best effort. If it fails to set any of the given properties,
2438 * it continues to set as many as it can and returns the last error
2439 * encountered. If the caller provides a non-NULL errlist, it will be filled in
2440 * with the list of names of all the properties that failed along with the
2441 * corresponding error numbers.
2442 *
2443 * If every property is set successfully, zero is returned and errlist is not
2444 * modified.
2445 */
2446 int
2447 zfs_set_prop_nvlist(const char *dsname, zprop_source_t source, nvlist_t *nvl,
2448 nvlist_t *errlist)
2449 {
2450 nvpair_t *pair;
2451 nvpair_t *propval;
2452 int rv = 0;
2453 uint64_t intval;
2454 char *strval;
2455 nvlist_t *genericnvl = fnvlist_alloc();
2456 nvlist_t *retrynvl = fnvlist_alloc();
2457
2458 retry:
2459 pair = NULL;
2460 while ((pair = nvlist_next_nvpair(nvl, pair)) != NULL) {
2461 const char *propname = nvpair_name(pair);
2462 zfs_prop_t prop = zfs_name_to_prop(propname);
2463 int err = 0;
2464
2465 /* decode the property value */
2466 propval = pair;
2467 if (nvpair_type(pair) == DATA_TYPE_NVLIST) {
2468 nvlist_t *attrs;
2469 attrs = fnvpair_value_nvlist(pair);
2470 if (nvlist_lookup_nvpair(attrs, ZPROP_VALUE,
2471 &propval) != 0)
2472 err = EINVAL;
2473 }
2474
2475 /* Validate value type */
2476 if (err == 0 && prop == ZPROP_INVAL) {
2477 if (zfs_prop_user(propname)) {
2478 if (nvpair_type(propval) != DATA_TYPE_STRING)
2479 err = EINVAL;
2480 } else if (zfs_prop_userquota(propname)) {
2481 if (nvpair_type(propval) !=
2482 DATA_TYPE_UINT64_ARRAY)
2483 err = EINVAL;
2484 } else {
2485 err = EINVAL;
2486 }
2487 } else if (err == 0) {
2488 if (nvpair_type(propval) == DATA_TYPE_STRING) {
2489 if (zfs_prop_get_type(prop) != PROP_TYPE_STRING)
2490 err = EINVAL;
2491 } else if (nvpair_type(propval) == DATA_TYPE_UINT64) {
2492 const char *unused;
2493
2494 intval = fnvpair_value_uint64(propval);
2495
2496 switch (zfs_prop_get_type(prop)) {
2497 case PROP_TYPE_NUMBER:
2498 break;
2499 case PROP_TYPE_STRING:
2500 err = EINVAL;
2501 break;
2502 case PROP_TYPE_INDEX:
2503 if (zfs_prop_index_to_string(prop,
2504 intval, &unused) != 0)
2505 err = EINVAL;
2506 break;
2507 default:
2508 cmn_err(CE_PANIC,
2509 "unknown property type");
2510 }
2511 } else {
2512 err = EINVAL;
2513 }
2514 }
2515
2516 /* Validate permissions */
2517 if (err == 0)
2518 err = zfs_check_settable(dsname, pair, CRED());
2519
2520 if (err == 0) {
2521 err = zfs_prop_set_special(dsname, source, pair);
2522 if (err == -1) {
2523 /*
2524 * For better performance we build up a list of
2525 * properties to set in a single transaction.
2526 */
2527 err = nvlist_add_nvpair(genericnvl, pair);
2528 } else if (err != 0 && nvl != retrynvl) {
2529 /*
2530 * This may be a spurious error caused by
2531 * receiving quota and reservation out of order.
2532 * Try again in a second pass.
2533 */
2534 err = nvlist_add_nvpair(retrynvl, pair);
2535 }
2536 }
2537
2538 if (err != 0) {
2539 if (errlist != NULL)
2540 fnvlist_add_int32(errlist, propname, err);
2541 rv = err;
2542 }
2543 }
2544
2545 if (nvl != retrynvl && !nvlist_empty(retrynvl)) {
2546 nvl = retrynvl;
2547 goto retry;
2548 }
2549
2550 if (!nvlist_empty(genericnvl) &&
2551 dsl_props_set(dsname, source, genericnvl) != 0) {
2552 /*
2553 * If this fails, we still want to set as many properties as we
2554 * can, so try setting them individually.
2555 */
2556 pair = NULL;
2557 while ((pair = nvlist_next_nvpair(genericnvl, pair)) != NULL) {
2558 const char *propname = nvpair_name(pair);
2559 int err = 0;
2560
2561 propval = pair;
2562 if (nvpair_type(pair) == DATA_TYPE_NVLIST) {
2563 nvlist_t *attrs;
2564 attrs = fnvpair_value_nvlist(pair);
2565 propval = fnvlist_lookup_nvpair(attrs,
2566 ZPROP_VALUE);
2567 }
2568
2569 if (nvpair_type(propval) == DATA_TYPE_STRING) {
2570 strval = fnvpair_value_string(propval);
2571 err = dsl_prop_set(dsname, propname, source, 1,
2572 strlen(strval) + 1, strval);
2573 } else {
2574 intval = fnvpair_value_uint64(propval);
2575 err = dsl_prop_set(dsname, propname, source, 8,
2576 1, &intval);
2577 }
2578
2579 if (err != 0) {
2580 if (errlist != NULL) {
2581 fnvlist_add_int32(errlist, propname,
2582 err);
2583 }
2584 rv = err;
2585 }
2586 }
2587 }
2588 nvlist_free(genericnvl);
2589 nvlist_free(retrynvl);
2590
2591 return (rv);
2592 }
2593
2594 /*
2595 * Check that all the properties are valid user properties.
2596 */
2597 static int
2598 zfs_check_userprops(const char *fsname, nvlist_t *nvl)
2599 {
2600 nvpair_t *pair = NULL;
2601 int error = 0;
2602
2603 while ((pair = nvlist_next_nvpair(nvl, pair)) != NULL) {
2604 const char *propname = nvpair_name(pair);
2605 char *valstr;
2606
2607 if (!zfs_prop_user(propname) ||
2608 nvpair_type(pair) != DATA_TYPE_STRING)
2609 return (EINVAL);
2610
2611 if (error = zfs_secpolicy_write_perms(fsname,
2612 ZFS_DELEG_PERM_USERPROP, CRED()))
2613 return (error);
2614
2615 if (strlen(propname) >= ZAP_MAXNAMELEN)
2616 return (ENAMETOOLONG);
2617
2618 VERIFY(nvpair_value_string(pair, &valstr) == 0);
2619 if (strlen(valstr) >= ZAP_MAXVALUELEN)
2620 return (E2BIG);
2621 }
2622 return (0);
2623 }
2624
2625 static void
2626 props_skip(nvlist_t *props, nvlist_t *skipped, nvlist_t **newprops)
2627 {
2628 nvpair_t *pair;
2629
2630 VERIFY(nvlist_alloc(newprops, NV_UNIQUE_NAME, KM_SLEEP) == 0);
2631
2632 pair = NULL;
2633 while ((pair = nvlist_next_nvpair(props, pair)) != NULL) {
2634 if (nvlist_exists(skipped, nvpair_name(pair)))
2635 continue;
2636
2637 VERIFY(nvlist_add_nvpair(*newprops, pair) == 0);
2638 }
2639 }
2640
2641 static int
2642 clear_received_props(objset_t *os, const char *fs, nvlist_t *props,
2643 nvlist_t *skipped)
2644 {
2645 int err = 0;
2646 nvlist_t *cleared_props = NULL;
2647 props_skip(props, skipped, &cleared_props);
2648 if (!nvlist_empty(cleared_props)) {
2649 /*
2650 * Acts on local properties until the dataset has received
2651 * properties at least once on or after SPA_VERSION_RECVD_PROPS.
2652 */
2653 zprop_source_t flags = (ZPROP_SRC_NONE |
2654 (dsl_prop_get_hasrecvd(os) ? ZPROP_SRC_RECEIVED : 0));
2655 err = zfs_set_prop_nvlist(fs, flags, cleared_props, NULL);
2656 }
2657 nvlist_free(cleared_props);
2658 return (err);
2659 }
2660
2661 /*
2662 * inputs:
2663 * zc_name name of filesystem
2664 * zc_value name of property to set
2665 * zc_nvlist_src{_size} nvlist of properties to apply
2666 * zc_cookie received properties flag
2667 *
2668 * outputs:
2669 * zc_nvlist_dst{_size} error for each unapplied received property
2670 */
2671 static int
2672 zfs_ioc_set_prop(zfs_cmd_t *zc)
2673 {
2674 nvlist_t *nvl;
2675 boolean_t received = zc->zc_cookie;
2676 zprop_source_t source = (received ? ZPROP_SRC_RECEIVED :
2677 ZPROP_SRC_LOCAL);
2678 nvlist_t *errors;
2679 int error;
2680
2681 if ((error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
2682 zc->zc_iflags, &nvl)) != 0)
2683 return (error);
2684
2685 if (received) {
2686 nvlist_t *origprops;
2687 objset_t *os;
2688
2689 if (dmu_objset_hold(zc->zc_name, FTAG, &os) == 0) {
2690 if (dsl_prop_get_received(os, &origprops) == 0) {
2691 (void) clear_received_props(os,
2692 zc->zc_name, origprops, nvl);
2693 nvlist_free(origprops);
2694 }
2695
2696 dsl_prop_set_hasrecvd(os);
2697 dmu_objset_rele(os, FTAG);
2698 }
2699 }
2700
2701 errors = fnvlist_alloc();
2702 error = zfs_set_prop_nvlist(zc->zc_name, source, nvl, errors);
2703
2704 if (zc->zc_nvlist_dst != NULL && errors != NULL) {
2705 (void) put_nvlist(zc, errors);
2706 }
2707
2708 nvlist_free(errors);
2709 nvlist_free(nvl);
2710 return (error);
2711 }
2712
2713 /*
2714 * inputs:
2715 * zc_name name of filesystem
2716 * zc_value name of property to inherit
2717 * zc_cookie revert to received value if TRUE
2718 *
2719 * outputs: none
2720 */
2721 static int
2722 zfs_ioc_inherit_prop(zfs_cmd_t *zc)
2723 {
2724 const char *propname = zc->zc_value;
2725 zfs_prop_t prop = zfs_name_to_prop(propname);
2726 boolean_t received = zc->zc_cookie;
2727 zprop_source_t source = (received
2728 ? ZPROP_SRC_NONE /* revert to received value, if any */
2729 : ZPROP_SRC_INHERITED); /* explicitly inherit */
2730
2731 if (received) {
2732 nvlist_t *dummy;
2733 nvpair_t *pair;
2734 zprop_type_t type;
2735 int err;
2736
2737 /*
2738 * zfs_prop_set_special() expects properties in the form of an
2739 * nvpair with type info.
2740 */
2741 if (prop == ZPROP_INVAL) {
2742 if (!zfs_prop_user(propname))
2743 return (EINVAL);
2744
2745 type = PROP_TYPE_STRING;
2746 } else if (prop == ZFS_PROP_VOLSIZE ||
2747 prop == ZFS_PROP_VERSION) {
2748 return (EINVAL);
2749 } else {
2750 type = zfs_prop_get_type(prop);
2751 }
2752
2753 VERIFY(nvlist_alloc(&dummy, NV_UNIQUE_NAME, KM_SLEEP) == 0);
2754
2755 switch (type) {
2756 case PROP_TYPE_STRING:
2757 VERIFY(0 == nvlist_add_string(dummy, propname, ""));
2758 break;
2759 case PROP_TYPE_NUMBER:
2760 case PROP_TYPE_INDEX:
2761 VERIFY(0 == nvlist_add_uint64(dummy, propname, 0));
2762 break;
2763 default:
2764 nvlist_free(dummy);
2765 return (EINVAL);
2766 }
2767
2768 pair = nvlist_next_nvpair(dummy, NULL);
2769 err = zfs_prop_set_special(zc->zc_name, source, pair);
2770 nvlist_free(dummy);
2771 if (err != -1)
2772 return (err); /* special property already handled */
2773 } else {
2774 /*
2775 * Only check this in the non-received case. We want to allow
2776 * 'inherit -S' to revert non-inheritable properties like quota
2777 * and reservation to the received or default values even though
2778 * they are not considered inheritable.
2779 */
2780 if (prop != ZPROP_INVAL && !zfs_prop_inheritable(prop))
2781 return (EINVAL);
2782 }
2783
2784 /* property name has been validated by zfs_secpolicy_inherit_prop() */
2785 return (dsl_prop_set(zc->zc_name, zc->zc_value, source, 0, 0, NULL));
2786 }
2787
2788 static int
2789 zfs_ioc_pool_set_props(zfs_cmd_t *zc)
2790 {
2791 nvlist_t *props;
2792 spa_t *spa;
2793 int error;
2794 nvpair_t *pair;
2795
2796 if (error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
2797 zc->zc_iflags, &props))
2798 return (error);
2799
2800 /*
2801 * If the only property is the configfile, then just do a spa_lookup()
2802 * to handle the faulted case.
2803 */
2804 pair = nvlist_next_nvpair(props, NULL);
2805 if (pair != NULL && strcmp(nvpair_name(pair),
2806 zpool_prop_to_name(ZPOOL_PROP_CACHEFILE)) == 0 &&
2807 nvlist_next_nvpair(props, pair) == NULL) {
2808 mutex_enter(&spa_namespace_lock);
2809 if ((spa = spa_lookup(zc->zc_name)) != NULL) {
2810 spa_configfile_set(spa, props, B_FALSE);
2811 spa_config_sync(spa, B_FALSE, B_TRUE);
2812 }
2813 mutex_exit(&spa_namespace_lock);
2814 if (spa != NULL) {
2815 nvlist_free(props);
2816 return (0);
2817 }
2818 }
2819
2820 if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0) {
2821 nvlist_free(props);
2822 return (error);
2823 }
2824
2825 error = spa_prop_set(spa, props);
2826
2827 nvlist_free(props);
2828 spa_close(spa, FTAG);
2829
2830 return (error);
2831 }
2832
2833 static int
2834 zfs_ioc_pool_get_props(zfs_cmd_t *zc)
2835 {
2836 spa_t *spa;
2837 int error;
2838 nvlist_t *nvp = NULL;
2839
2840 if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0) {
2841 /*
2842 * If the pool is faulted, there may be properties we can still
2843 * get (such as altroot and cachefile), so attempt to get them
2844 * anyway.
2845 */
2846 mutex_enter(&spa_namespace_lock);
2847 if ((spa = spa_lookup(zc->zc_name)) != NULL)
2848 error = spa_prop_get(spa, &nvp);
2849 mutex_exit(&spa_namespace_lock);
2850 } else {
2851 error = spa_prop_get(spa, &nvp);
2852 spa_close(spa, FTAG);
2853 }
2854
2855 if (error == 0 && zc->zc_nvlist_dst != NULL)
2856 error = put_nvlist(zc, nvp);
2857 else
2858 error = EFAULT;
2859
2860 nvlist_free(nvp);
2861 return (error);
2862 }
2863
2864 /*
2865 * inputs:
2866 * zc_name name of filesystem
2867 * zc_nvlist_src{_size} nvlist of delegated permissions
2868 * zc_perm_action allow/unallow flag
2869 *
2870 * outputs: none
2871 */
2872 static int
2873 zfs_ioc_set_fsacl(zfs_cmd_t *zc)
2874 {
2875 int error;
2876 nvlist_t *fsaclnv = NULL;
2877
2878 if ((error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
2879 zc->zc_iflags, &fsaclnv)) != 0)
2880 return (error);
2881
2882 /*
2883 * Verify nvlist is constructed correctly
2884 */
2885 if ((error = zfs_deleg_verify_nvlist(fsaclnv)) != 0) {
2886 nvlist_free(fsaclnv);
2887 return (EINVAL);
2888 }
2889
2890 /*
2891 * If we don't have PRIV_SYS_MOUNT, then validate
2892 * that user is allowed to hand out each permission in
2893 * the nvlist(s)
2894 */
2895
2896 error = secpolicy_zfs(CRED());
2897 if (error) {
2898 if (zc->zc_perm_action == B_FALSE) {
2899 error = dsl_deleg_can_allow(zc->zc_name,
2900 fsaclnv, CRED());
2901 } else {
2902 error = dsl_deleg_can_unallow(zc->zc_name,
2903 fsaclnv, CRED());
2904 }
2905 }
2906
2907 if (error == 0)
2908 error = dsl_deleg_set(zc->zc_name, fsaclnv, zc->zc_perm_action);
2909
2910 nvlist_free(fsaclnv);
2911 return (error);
2912 }
2913
2914 /*
2915 * inputs:
2916 * zc_name name of filesystem
2917 *
2918 * outputs:
2919 * zc_nvlist_src{_size} nvlist of delegated permissions
2920 */
2921 static int
2922 zfs_ioc_get_fsacl(zfs_cmd_t *zc)
2923 {
2924 nvlist_t *nvp;
2925 int error;
2926
2927 if ((error = dsl_deleg_get(zc->zc_name, &nvp)) == 0) {
2928 error = put_nvlist(zc, nvp);
2929 nvlist_free(nvp);
2930 }
2931
2932 return (error);
2933 }
2934
2935 /*
2936 * Search the vfs list for a specified resource. Returns a pointer to it
2937 * or NULL if no suitable entry is found. The caller of this routine
2938 * is responsible for releasing the returned vfs pointer.
2939 */
2940 static vfs_t *
2941 zfs_get_vfs(const char *resource)
2942 {
2943 struct vfs *vfsp;
2944 struct vfs *vfs_found = NULL;
2945
2946 vfs_list_read_lock();
2947 vfsp = rootvfs;
2948 do {
2949 if (strcmp(refstr_value(vfsp->vfs_resource), resource) == 0) {
2950 VFS_HOLD(vfsp);
2951 vfs_found = vfsp;
2952 break;
2953 }
2954 vfsp = vfsp->vfs_next;
2955 } while (vfsp != rootvfs);
2956 vfs_list_unlock();
2957 return (vfs_found);
2958 }
2959
2960 /* ARGSUSED */
2961 static void
2962 zfs_create_cb(objset_t *os, void *arg, cred_t *cr, dmu_tx_t *tx)
2963 {
2964 zfs_creat_t *zct = arg;
2965
2966 zfs_create_fs(os, cr, zct->zct_zplprops, tx);
2967 }
2968
2969 #define ZFS_PROP_UNDEFINED ((uint64_t)-1)
2970
2971 /*
2972 * inputs:
2973 * createprops list of properties requested by creator
2974 * default_zplver zpl version to use if unspecified in createprops
2975 * fuids_ok fuids allowed in this version of the spa?
2976 * os parent objset pointer (NULL if root fs)
2977 *
2978 * outputs:
2979 * zplprops values for the zplprops we attach to the master node object
2980 * is_ci true if requested file system will be purely case-insensitive
2981 *
2982 * Determine the settings for utf8only, normalization and
2983 * casesensitivity. Specific values may have been requested by the
2984 * creator and/or we can inherit values from the parent dataset. If
2985 * the file system is of too early a vintage, a creator can not
2986 * request settings for these properties, even if the requested
2987 * setting is the default value. We don't actually want to create dsl
2988 * properties for these, so remove them from the source nvlist after
2989 * processing.
2990 */
2991 static int
2992 zfs_fill_zplprops_impl(objset_t *os, uint64_t zplver,
2993 boolean_t fuids_ok, boolean_t sa_ok, nvlist_t *createprops,
2994 nvlist_t *zplprops, boolean_t *is_ci)
2995 {
2996 uint64_t sense = ZFS_PROP_UNDEFINED;
2997 uint64_t norm = ZFS_PROP_UNDEFINED;
2998 uint64_t u8 = ZFS_PROP_UNDEFINED;
2999
3000 ASSERT(zplprops != NULL);
3001
3002 /*
3003 * Pull out creator prop choices, if any.
3004 */
3005 if (createprops) {
3006 (void) nvlist_lookup_uint64(createprops,
3007 zfs_prop_to_name(ZFS_PROP_VERSION), &zplver);
3008 (void) nvlist_lookup_uint64(createprops,
3009 zfs_prop_to_name(ZFS_PROP_NORMALIZE), &norm);
3010 (void) nvlist_remove_all(createprops,
3011 zfs_prop_to_name(ZFS_PROP_NORMALIZE));
3012 (void) nvlist_lookup_uint64(createprops,
3013 zfs_prop_to_name(ZFS_PROP_UTF8ONLY), &u8);
3014 (void) nvlist_remove_all(createprops,
3015 zfs_prop_to_name(ZFS_PROP_UTF8ONLY));
3016 (void) nvlist_lookup_uint64(createprops,
3017 zfs_prop_to_name(ZFS_PROP_CASE), &sense);
3018 (void) nvlist_remove_all(createprops,
3019 zfs_prop_to_name(ZFS_PROP_CASE));
3020 }
3021
3022 /*
3023 * If the zpl version requested is whacky or the file system
3024 * or pool is version is too "young" to support normalization
3025 * and the creator tried to set a value for one of the props,
3026 * error out.
3027 */
3028 if ((zplver < ZPL_VERSION_INITIAL || zplver > ZPL_VERSION) ||
3029 (zplver >= ZPL_VERSION_FUID && !fuids_ok) ||
3030 (zplver >= ZPL_VERSION_SA && !sa_ok) ||
3031 (zplver < ZPL_VERSION_NORMALIZATION &&
3032 (norm != ZFS_PROP_UNDEFINED || u8 != ZFS_PROP_UNDEFINED ||
3033 sense != ZFS_PROP_UNDEFINED)))
3034 return (ENOTSUP);
3035
3036 /*
3037 * Put the version in the zplprops
3038 */
3039 VERIFY(nvlist_add_uint64(zplprops,
3040 zfs_prop_to_name(ZFS_PROP_VERSION), zplver) == 0);
3041
3042 if (norm == ZFS_PROP_UNDEFINED)
3043 VERIFY(zfs_get_zplprop(os, ZFS_PROP_NORMALIZE, &norm) == 0);
3044 VERIFY(nvlist_add_uint64(zplprops,
3045 zfs_prop_to_name(ZFS_PROP_NORMALIZE), norm) == 0);
3046
3047 /*
3048 * If we're normalizing, names must always be valid UTF-8 strings.
3049 */
3050 if (norm)
3051 u8 = 1;
3052 if (u8 == ZFS_PROP_UNDEFINED)
3053 VERIFY(zfs_get_zplprop(os, ZFS_PROP_UTF8ONLY, &u8) == 0);
3054 VERIFY(nvlist_add_uint64(zplprops,
3055 zfs_prop_to_name(ZFS_PROP_UTF8ONLY), u8) == 0);
3056
3057 if (sense == ZFS_PROP_UNDEFINED)
3058 VERIFY(zfs_get_zplprop(os, ZFS_PROP_CASE, &sense) == 0);
3059 VERIFY(nvlist_add_uint64(zplprops,
3060 zfs_prop_to_name(ZFS_PROP_CASE), sense) == 0);
3061
3062 if (is_ci)
3063 *is_ci = (sense == ZFS_CASE_INSENSITIVE);
3064
3065 return (0);
3066 }
3067
3068 static int
3069 zfs_fill_zplprops(const char *dataset, nvlist_t *createprops,
3070 nvlist_t *zplprops, boolean_t *is_ci)
3071 {
3072 boolean_t fuids_ok, sa_ok;
3073 uint64_t zplver = ZPL_VERSION;
3074 objset_t *os = NULL;
3075 char parentname[MAXNAMELEN];
3076 char *cp;
3077 spa_t *spa;
3078 uint64_t spa_vers;
3079 int error;
3080
3081 (void) strlcpy(parentname, dataset, sizeof (parentname));
3082 cp = strrchr(parentname, '/');
3083 ASSERT(cp != NULL);
3084 cp[0] = '\0';
3085
3086 if ((error = spa_open(dataset, &spa, FTAG)) != 0)
3087 return (error);
3088
3089 spa_vers = spa_version(spa);
3090 spa_close(spa, FTAG);
3091
3092 zplver = zfs_zpl_version_map(spa_vers);
3093 fuids_ok = (zplver >= ZPL_VERSION_FUID);
3094 sa_ok = (zplver >= ZPL_VERSION_SA);
3095
3096 /*
3097 * Open parent object set so we can inherit zplprop values.
3098 */
3099 if ((error = dmu_objset_hold(parentname, FTAG, &os)) != 0)
3100 return (error);
3101
3102 error = zfs_fill_zplprops_impl(os, zplver, fuids_ok, sa_ok, createprops,
3103 zplprops, is_ci);
3104 dmu_objset_rele(os, FTAG);
3105 return (error);
3106 }
3107
3108 static int
3109 zfs_fill_zplprops_root(uint64_t spa_vers, nvlist_t *createprops,
3110 nvlist_t *zplprops, boolean_t *is_ci)
3111 {
3112 boolean_t fuids_ok;
3113 boolean_t sa_ok;
3114 uint64_t zplver = ZPL_VERSION;
3115 int error;
3116
3117 zplver = zfs_zpl_version_map(spa_vers);
3118 fuids_ok = (zplver >= ZPL_VERSION_FUID);
3119 sa_ok = (zplver >= ZPL_VERSION_SA);
3120
3121 error = zfs_fill_zplprops_impl(NULL, zplver, fuids_ok, sa_ok,
3122 createprops, zplprops, is_ci);
3123 return (error);
3124 }
3125
3126 /*
3127 * innvl: {
3128 * "type" -> dmu_objset_type_t (int32)
3129 * (optional) "props" -> { prop -> value }
3130 * }
3131 *
3132 * outnvl: propname -> error code (int32)
3133 */
3134 static int
3135 zfs_ioc_create(const char *fsname, nvlist_t *innvl, nvlist_t *outnvl)
3136 {
3137 int error = 0;
3138 zfs_creat_t zct = { 0 };
3139 nvlist_t *nvprops = NULL;
3140 void (*cbfunc)(objset_t *os, void *arg, cred_t *cr, dmu_tx_t *tx);
3141 int32_t type32;
3142 dmu_objset_type_t type;
3143 boolean_t is_insensitive = B_FALSE;
3144
3145 if (nvlist_lookup_int32(innvl, "type", &type32) != 0)
3146 return (EINVAL);
3147 type = type32;
3148 (void) nvlist_lookup_nvlist(innvl, "props", &nvprops);
3149
3150 switch (type) {
3151 case DMU_OST_ZFS:
3152 cbfunc = zfs_create_cb;
3153 break;
3154
3155 case DMU_OST_ZVOL:
3156 cbfunc = zvol_create_cb;
3157 break;
3158
3159 default:
3160 cbfunc = NULL;
3161 break;
3162 }
3163 if (strchr(fsname, '@') ||
3164 strchr(fsname, '%'))
3165 return (EINVAL);
3166
3167 zct.zct_props = nvprops;
3168
3169 if (cbfunc == NULL)
3170 return (EINVAL);
3171
3172 if (type == DMU_OST_ZVOL) {
3173 uint64_t volsize, volblocksize;
3174
3175 if (nvprops == NULL)
3176 return (EINVAL);
3177 if (nvlist_lookup_uint64(nvprops,
3178 zfs_prop_to_name(ZFS_PROP_VOLSIZE), &volsize) != 0)
3179 return (EINVAL);
3180
3181 if ((error = nvlist_lookup_uint64(nvprops,
3182 zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE),
3183 &volblocksize)) != 0 && error != ENOENT)
3184 return (EINVAL);
3185
3186 if (error != 0)
3187 volblocksize = zfs_prop_default_numeric(
3188 ZFS_PROP_VOLBLOCKSIZE);
3189
3190 if ((error = zvol_check_volblocksize(
3191 volblocksize)) != 0 ||
3192 (error = zvol_check_volsize(volsize,
3193 volblocksize)) != 0)
3194 return (error);
3195 } else if (type == DMU_OST_ZFS) {
3196 int error;
3197
3198 /*
3199 * We have to have normalization and
3200 * case-folding flags correct when we do the
3201 * file system creation, so go figure them out
3202 * now.
3203 */
3204 VERIFY(nvlist_alloc(&zct.zct_zplprops,
3205 NV_UNIQUE_NAME, KM_SLEEP) == 0);
3206 error = zfs_fill_zplprops(fsname, nvprops,
3207 zct.zct_zplprops, &is_insensitive);
3208 if (error != 0) {
3209 nvlist_free(zct.zct_zplprops);
3210 return (error);
3211 }
3212 }
3213
3214 error = dmu_objset_create(fsname, type,
3215 is_insensitive ? DS_FLAG_CI_DATASET : 0, cbfunc, &zct);
3216 nvlist_free(zct.zct_zplprops);
3217
3218 /*
3219 * It would be nice to do this atomically.
3220 */
3221 if (error == 0) {
3222 error = zfs_set_prop_nvlist(fsname, ZPROP_SRC_LOCAL,
3223 nvprops, outnvl);
3224 if (error != 0)
3225 (void) dmu_objset_destroy(fsname, B_FALSE);
3226 }
3227 return (error);
3228 }
3229
3230 /*
3231 * innvl: {
3232 * "origin" -> name of origin snapshot
3233 * (optional) "props" -> { prop -> value }
3234 * }
3235 *
3236 * outnvl: propname -> error code (int32)
3237 */
3238 static int
3239 zfs_ioc_clone(const char *fsname, nvlist_t *innvl, nvlist_t *outnvl)
3240 {
3241 int error = 0;
3242 nvlist_t *nvprops = NULL;
3243 char *origin_name;
3244 dsl_dataset_t *origin;
3245
3246 if (nvlist_lookup_string(innvl, "origin", &origin_name) != 0)
3247 return (EINVAL);
3248 (void) nvlist_lookup_nvlist(innvl, "props", &nvprops);
3249
3250 if (strchr(fsname, '@') ||
3251 strchr(fsname, '%'))
3252 return (EINVAL);
3253
3254 if (dataset_namecheck(origin_name, NULL, NULL) != 0)
3255 return (EINVAL);
3256
3257 error = dsl_dataset_hold(origin_name, FTAG, &origin);
3258 if (error)
3259 return (error);
3260
3261 error = dmu_objset_clone(fsname, origin, 0);
3262 dsl_dataset_rele(origin, FTAG);
3263 if (error)
3264 return (error);
3265
3266 /*
3267 * It would be nice to do this atomically.
3268 */
3269 if (error == 0) {
3270 error = zfs_set_prop_nvlist(fsname, ZPROP_SRC_LOCAL,
3271 nvprops, outnvl);
3272 if (error != 0)
3273 (void) dmu_objset_destroy(fsname, B_FALSE);
3274 }
3275 return (error);
3276 }
3277
3278 /*
3279 * innvl: {
3280 * "snaps" -> { snapshot1, snapshot2 }
3281 * (optional) "props" -> { prop -> value (string) }
3282 * }
3283 *
3284 * outnvl: snapshot -> error code (int32)
3285 *
3286 */
3287 static int
3288 zfs_ioc_snapshot(const char *poolname, nvlist_t *innvl, nvlist_t *outnvl)
3289 {
3290 nvlist_t *snaps;
3291 nvlist_t *props = NULL;
3292 int error, poollen;
3293 nvpair_t *pair;
3294
3295 (void) nvlist_lookup_nvlist(innvl, "props", &props);
3296 if ((error = zfs_check_userprops(poolname, props)) != 0)
3297 return (error);
3298
3299 if (!nvlist_empty(props) &&
3300 zfs_earlier_version(poolname, SPA_VERSION_SNAP_PROPS))
3301 return (ENOTSUP);
3302
3303 if (nvlist_lookup_nvlist(innvl, "snaps", &snaps) != 0)
3304 return (EINVAL);
3305 poollen = strlen(poolname);
3306 for (pair = nvlist_next_nvpair(snaps, NULL); pair != NULL;
3307 pair = nvlist_next_nvpair(snaps, pair)) {
3308 const char *name = nvpair_name(pair);
3309 const char *cp = strchr(name, '@');
3310
3311 /*
3312 * The snap name must contain an @, and the part after it must
3313 * contain only valid characters.
3314 */
3315 if (cp == NULL || snapshot_namecheck(cp + 1, NULL, NULL) != 0)
3316 return (EINVAL);
3317
3318 /*
3319 * The snap must be in the specified pool.
3320 */
3321 if (strncmp(name, poolname, poollen) != 0 ||
3322 (name[poollen] != '/' && name[poollen] != '@'))
3323 return (EXDEV);
3324
3325 /* This must be the only snap of this fs. */
3326 for (nvpair_t *pair2 = nvlist_next_nvpair(snaps, pair);
3327 pair2 != NULL; pair2 = nvlist_next_nvpair(snaps, pair2)) {
3328 if (strncmp(name, nvpair_name(pair2), cp - name + 1)
3329 == 0) {
3330 return (EXDEV);
3331 }
3332 }
3333 }
3334
3335 error = dmu_objset_snapshot(snaps, props, outnvl);
3336 return (error);
3337 }
3338
3339 /*
3340 * innvl: "message" -> string
3341 */
3342 /* ARGSUSED */
3343 static int
3344 zfs_ioc_log_history(const char *unused, nvlist_t *innvl, nvlist_t *outnvl)
3345 {
3346 char *message;
3347 spa_t *spa;
3348 int error;
3349 char *poolname;
3350
3351 /*
3352 * The poolname in the ioctl is not set, we get it from the TSD,
3353 * which was set at the end of the last successful ioctl that allows
3354 * logging. The secpolicy func already checked that it is set.
3355 * Only one log ioctl is allowed after each successful ioctl, so
3356 * we clear the TSD here.
3357 */
3358 poolname = tsd_get(zfs_allow_log_key);
3359 (void) tsd_set(zfs_allow_log_key, NULL);
3360 error = spa_open(poolname, &spa, FTAG);
3361 strfree(poolname);
3362 if (error != 0)
3363 return (error);
3364
3365 if (nvlist_lookup_string(innvl, "message", &message) != 0) {
3366 spa_close(spa, FTAG);
3367 return (EINVAL);
3368 }
3369
3370 if (spa_version(spa) < SPA_VERSION_ZPOOL_HISTORY) {
3371 spa_close(spa, FTAG);
3372 return (ENOTSUP);
3373 }
3374
3375 error = spa_history_log(spa, message);
3376 spa_close(spa, FTAG);
3377 return (error);
3378 }
3379
3380 /* ARGSUSED */
3381 int
3382 zfs_unmount_snap(const char *name, void *arg)
3383 {
3384 vfs_t *vfsp;
3385 int err;
3386
3387 if (strchr(name, '@') == NULL)
3388 return (0);
3389
3390 vfsp = zfs_get_vfs(name);
3391 if (vfsp == NULL)
3392 return (0);
3393
3394 if ((err = vn_vfswlock(vfsp->vfs_vnodecovered)) != 0) {
3395 VFS_RELE(vfsp);
3396 return (err);
3397 }
3398 VFS_RELE(vfsp);
3399
3400 /*
3401 * Always force the unmount for snapshots.
3402 */
3403 return (dounmount(vfsp, MS_FORCE, kcred));
3404 }
3405
3406 /*
3407 * innvl: {
3408 * "snaps" -> { snapshot1, snapshot2 }
3409 * (optional boolean) "defer"
3410 * }
3411 *
3412 * outnvl: snapshot -> error code (int32)
3413 *
3414 */
3415 static int
3416 zfs_ioc_destroy_snaps(const char *poolname, nvlist_t *innvl, nvlist_t *outnvl)
3417 {
3418 int poollen;
3419 nvlist_t *snaps;
3420 nvpair_t *pair;
3421 boolean_t defer;
3422
3423 if (nvlist_lookup_nvlist(innvl, "snaps", &snaps) != 0)
3424 return (EINVAL);
3425 defer = nvlist_exists(innvl, "defer");
3426
3427 poollen = strlen(poolname);
3428 for (pair = nvlist_next_nvpair(snaps, NULL); pair != NULL;
3429 pair = nvlist_next_nvpair(snaps, pair)) {
3430 const char *name = nvpair_name(pair);
3431
3432 /*
3433 * The snap must be in the specified pool.
3434 */
3435 if (strncmp(name, poolname, poollen) != 0 ||
3436 (name[poollen] != '/' && name[poollen] != '@'))
3437 return (EXDEV);
3438
3439 /*
3440 * Ignore failures to unmount; dmu_snapshots_destroy_nvl()
3441 * will deal with this gracefully (by filling in outnvl).
3442 */
3443 (void) zfs_unmount_snap(name, NULL);
3444 }
3445
3446 return (dmu_snapshots_destroy_nvl(snaps, defer, outnvl));
3447 }
3448
3449 /*
3450 * inputs:
3451 * zc_name name of dataset to destroy
3452 * zc_objset_type type of objset
3453 * zc_defer_destroy mark for deferred destroy
3454 *
3455 * outputs: none
3456 */
3457 static int
3458 zfs_ioc_destroy(zfs_cmd_t *zc)
3459 {
3460 int err;
3461 if (strchr(zc->zc_name, '@') && zc->zc_objset_type == DMU_OST_ZFS) {
3462 err = zfs_unmount_snap(zc->zc_name, NULL);
3463 if (err)
3464 return (err);
3465 }
3466
3467 err = dmu_objset_destroy(zc->zc_name, zc->zc_defer_destroy);
3468 if (zc->zc_objset_type == DMU_OST_ZVOL && err == 0)
3469 (void) zvol_remove_minor(zc->zc_name);
3470 return (err);
3471 }
3472
3473 /*
3474 * inputs:
3475 * zc_name name of dataset to rollback (to most recent snapshot)
3476 *
3477 * outputs: none
3478 */
3479 static int
3480 zfs_ioc_rollback(zfs_cmd_t *zc)
3481 {
3482 dsl_dataset_t *ds, *clone;
3483 int error;
3484 zfsvfs_t *zfsvfs;
3485 char *clone_name;
3486
3487 error = dsl_dataset_hold(zc->zc_name, FTAG, &ds);
3488 if (error)
3489 return (error);
3490
3491 /* must not be a snapshot */
3492 if (dsl_dataset_is_snapshot(ds)) {
3493 dsl_dataset_rele(ds, FTAG);
3494 return (EINVAL);
3495 }
3496
3497 /* must have a most recent snapshot */
3498 if (ds->ds_phys->ds_prev_snap_txg < TXG_INITIAL) {
3499 dsl_dataset_rele(ds, FTAG);
3500 return (EINVAL);
3501 }
3502
3503 /*
3504 * Create clone of most recent snapshot.
3505 */
3506 clone_name = kmem_asprintf("%s/%%rollback", zc->zc_name);
3507 error = dmu_objset_clone(clone_name, ds->ds_prev, DS_FLAG_INCONSISTENT);
3508 if (error)
3509 goto out;
3510
3511 error = dsl_dataset_own(clone_name, B_TRUE, FTAG, &clone);
3512 if (error)
3513 goto out;
3514
3515 /*
3516 * Do clone swap.
3517 */
3518 if (getzfsvfs(zc->zc_name, &zfsvfs) == 0) {
3519 error = zfs_suspend_fs(zfsvfs);
3520 if (error == 0) {
3521 int resume_err;
3522
3523 if (dsl_dataset_tryown(ds, B_FALSE, FTAG)) {
3524 error = dsl_dataset_clone_swap(clone, ds,
3525 B_TRUE);
3526 dsl_dataset_disown(ds, FTAG);
3527 ds = NULL;
3528 } else {
3529 error = EBUSY;
3530 }
3531 resume_err = zfs_resume_fs(zfsvfs, zc->zc_name);
3532 error = error ? error : resume_err;
3533 }
3534 VFS_RELE(zfsvfs->z_vfs);
3535 } else {
3536 if (dsl_dataset_tryown(ds, B_FALSE, FTAG)) {
3537 error = dsl_dataset_clone_swap(clone, ds, B_TRUE);
3538 dsl_dataset_disown(ds, FTAG);
3539 ds = NULL;
3540 } else {
3541 error = EBUSY;
3542 }
3543 }
3544
3545 /*
3546 * Destroy clone (which also closes it).
3547 */
3548 (void) dsl_dataset_destroy(clone, FTAG, B_FALSE);
3549
3550 out:
3551 strfree(clone_name);
3552 if (ds)
3553 dsl_dataset_rele(ds, FTAG);
3554 return (error);
3555 }
3556
3557 /*
3558 * inputs:
3559 * zc_name old name of dataset
3560 * zc_value new name of dataset
3561 * zc_cookie recursive flag (only valid for snapshots)
3562 *
3563 * outputs: none
3564 */
3565 static int
3566 zfs_ioc_rename(zfs_cmd_t *zc)
3567 {
3568 boolean_t recursive = zc->zc_cookie & 1;
3569
3570 zc->zc_value[sizeof (zc->zc_value) - 1] = '\0';
3571 if (dataset_namecheck(zc->zc_value, NULL, NULL) != 0 ||
3572 strchr(zc->zc_value, '%'))
3573 return (EINVAL);
3574
3575 /*
3576 * Unmount snapshot unless we're doing a recursive rename,
3577 * in which case the dataset code figures out which snapshots
3578 * to unmount.
3579 */
3580 if (!recursive && strchr(zc->zc_name, '@') != NULL &&
3581 zc->zc_objset_type == DMU_OST_ZFS) {
3582 int err = zfs_unmount_snap(zc->zc_name, NULL);
3583 if (err)
3584 return (err);
3585 }
3586 if (zc->zc_objset_type == DMU_OST_ZVOL)
3587 (void) zvol_remove_minor(zc->zc_name);
3588 return (dmu_objset_rename(zc->zc_name, zc->zc_value, recursive));
3589 }
3590
3591 static int
3592 zfs_check_settable(const char *dsname, nvpair_t *pair, cred_t *cr)
3593 {
3594 const char *propname = nvpair_name(pair);
3595 boolean_t issnap = (strchr(dsname, '@') != NULL);
3596 zfs_prop_t prop = zfs_name_to_prop(propname);
3597 uint64_t intval;
3598 int err;
3599
3600 if (prop == ZPROP_INVAL) {
3601 if (zfs_prop_user(propname)) {
3602 if (err = zfs_secpolicy_write_perms(dsname,
3603 ZFS_DELEG_PERM_USERPROP, cr))
3604 return (err);
3605 return (0);
3606 }
3607
3608 if (!issnap && zfs_prop_userquota(propname)) {
3609 const char *perm = NULL;
3610 const char *uq_prefix =
3611 zfs_userquota_prop_prefixes[ZFS_PROP_USERQUOTA];
3612 const char *gq_prefix =
3613 zfs_userquota_prop_prefixes[ZFS_PROP_GROUPQUOTA];
3614
3615 if (strncmp(propname, uq_prefix,
3616 strlen(uq_prefix)) == 0) {
3617 perm = ZFS_DELEG_PERM_USERQUOTA;
3618 } else if (strncmp(propname, gq_prefix,
3619 strlen(gq_prefix)) == 0) {
3620 perm = ZFS_DELEG_PERM_GROUPQUOTA;
3621 } else {
3622 /* USERUSED and GROUPUSED are read-only */
3623 return (EINVAL);
3624 }
3625
3626 if (err = zfs_secpolicy_write_perms(dsname, perm, cr))
3627 return (err);
3628 return (0);
3629 }
3630
3631 return (EINVAL);
3632 }
3633
3634 if (issnap)
3635 return (EINVAL);
3636
3637 if (nvpair_type(pair) == DATA_TYPE_NVLIST) {
3638 /*
3639 * dsl_prop_get_all_impl() returns properties in this
3640 * format.
3641 */
3642 nvlist_t *attrs;
3643 VERIFY(nvpair_value_nvlist(pair, &attrs) == 0);
3644 VERIFY(nvlist_lookup_nvpair(attrs, ZPROP_VALUE,
3645 &pair) == 0);
3646 }
3647
3648 /*
3649 * Check that this value is valid for this pool version
3650 */
3651 switch (prop) {
3652 case ZFS_PROP_COMPRESSION:
3653 /*
3654 * If the user specified gzip compression, make sure
3655 * the SPA supports it. We ignore any errors here since
3656 * we'll catch them later.
3657 */
3658 if (nvpair_type(pair) == DATA_TYPE_UINT64 &&
3659 nvpair_value_uint64(pair, &intval) == 0) {
3660 if (intval >= ZIO_COMPRESS_GZIP_1 &&
3661 intval <= ZIO_COMPRESS_GZIP_9 &&
3662 zfs_earlier_version(dsname,
3663 SPA_VERSION_GZIP_COMPRESSION)) {
3664 return (ENOTSUP);
3665 }
3666
3667 if (intval == ZIO_COMPRESS_ZLE &&
3668 zfs_earlier_version(dsname,
3669 SPA_VERSION_ZLE_COMPRESSION))
3670 return (ENOTSUP);
3671
3672 if (intval == ZIO_COMPRESS_LZ4) {
3673 zfeature_info_t *feature =
3674 &spa_feature_table[
3675 SPA_FEATURE_LZ4_COMPRESS];
3676 spa_t *spa;
3677
3678 if ((err = spa_open(dsname, &spa, FTAG)) != 0)
3679 return (err);
3680
3681 if (!spa_feature_is_enabled(spa, feature)) {
3682 spa_close(spa, FTAG);
3683 return (ENOTSUP);
3684 }
3685 spa_close(spa, FTAG);
3686 }
3687
3688 /*
3689 * If this is a bootable dataset then
3690 * verify that the compression algorithm
3691 * is supported for booting. We must return
3692 * something other than ENOTSUP since it
3693 * implies a downrev pool version.
3694 */
3695 if (zfs_is_bootfs(dsname) &&
3696 !BOOTFS_COMPRESS_VALID(intval)) {
3697 return (ERANGE);
3698 }
3699 }
3700 break;
3701
3702 case ZFS_PROP_COPIES:
3703 if (zfs_earlier_version(dsname, SPA_VERSION_DITTO_BLOCKS))
3704 return (ENOTSUP);
3705 break;
3706
3707 case ZFS_PROP_DEDUP:
3708 if (zfs_earlier_version(dsname, SPA_VERSION_DEDUP))
3709 return (ENOTSUP);
3710 break;
3711
3712 case ZFS_PROP_SHARESMB:
3713 if (zpl_earlier_version(dsname, ZPL_VERSION_FUID))
3714 return (ENOTSUP);
3715 break;
3716
3717 case ZFS_PROP_ACLINHERIT:
3718 if (nvpair_type(pair) == DATA_TYPE_UINT64 &&
3719 nvpair_value_uint64(pair, &intval) == 0) {
3720 if (intval == ZFS_ACL_PASSTHROUGH_X &&
3721 zfs_earlier_version(dsname,
3722 SPA_VERSION_PASSTHROUGH_X))
3723 return (ENOTSUP);
3724 }
3725 break;
3726 }
3727
3728 return (zfs_secpolicy_setprop(dsname, prop, pair, CRED()));
3729 }
3730
3731 /*
3732 * Activates a feature on a pool in response to a property setting. This
3733 * creates a new sync task which modifies the pool to reflect the feature
3734 * as being active.
3735 */
3736 static int
3737 zfs_prop_activate_feature(dsl_pool_t *dp, zfeature_info_t *feature)
3738 {
3739 int err;
3740
3741 /* EBUSY here indicates that the feature is already active */
3742 err = dsl_sync_task_do(dp, zfs_prop_activate_feature_check,
3743 zfs_prop_activate_feature_sync, dp->dp_spa, feature, 2);
3744
3745 if (err != 0 && err != EBUSY)
3746 return (err);
3747 else
3748 return (0);
3749 }
3750
3751 /*
3752 * Checks for a race condition to make sure we don't increment a feature flag
3753 * multiple times.
3754 */
3755 /*ARGSUSED*/
3756 static int
3757 zfs_prop_activate_feature_check(void *arg1, void *arg2, dmu_tx_t *tx)
3758 {
3759 spa_t *spa = arg1;
3760 zfeature_info_t *feature = arg2;
3761
3762 if (!spa_feature_is_active(spa, feature))
3763 return (0);
3764 else
3765 return (EBUSY);
3766 }
3767
3768 /*
3769 * The callback invoked on feature activation in the sync task caused by
3770 * zfs_prop_activate_feature.
3771 */
3772 static void
3773 zfs_prop_activate_feature_sync(void *arg1, void *arg2, dmu_tx_t *tx)
3774 {
3775 spa_t *spa = arg1;
3776 zfeature_info_t *feature = arg2;
3777
3778 spa_feature_incr(spa, feature, tx);
3779 }
3780
3781 /*
3782 * Removes properties from the given props list that fail permission checks
3783 * needed to clear them and to restore them in case of a receive error. For each
3784 * property, make sure we have both set and inherit permissions.
3785 *
3786 * Returns the first error encountered if any permission checks fail. If the
3787 * caller provides a non-NULL errlist, it also gives the complete list of names
3788 * of all the properties that failed a permission check along with the
3789 * corresponding error numbers. The caller is responsible for freeing the
3790 * returned errlist.
3791 *
3792 * If every property checks out successfully, zero is returned and the list
3793 * pointed at by errlist is NULL.
3794 */
3795 static int
3796 zfs_check_clearable(char *dataset, nvlist_t *props, nvlist_t **errlist)
3797 {
3798 zfs_cmd_t *zc;
3799 nvpair_t *pair, *next_pair;
3800 nvlist_t *errors;
3801 int err, rv = 0;
3802
3803 if (props == NULL)
3804 return (0);
3805
3806 VERIFY(nvlist_alloc(&errors, NV_UNIQUE_NAME, KM_SLEEP) == 0);
3807
3808 zc = kmem_alloc(sizeof (zfs_cmd_t), KM_SLEEP);
3809 (void) strcpy(zc->zc_name, dataset);
3810 pair = nvlist_next_nvpair(props, NULL);
3811 while (pair != NULL) {
3812 next_pair = nvlist_next_nvpair(props, pair);
3813
3814 (void) strcpy(zc->zc_value, nvpair_name(pair));
3815 if ((err = zfs_check_settable(dataset, pair, CRED())) != 0 ||
3816 (err = zfs_secpolicy_inherit_prop(zc, NULL, CRED())) != 0) {
3817 VERIFY(nvlist_remove_nvpair(props, pair) == 0);
3818 VERIFY(nvlist_add_int32(errors,
3819 zc->zc_value, err) == 0);
3820 }
3821 pair = next_pair;
3822 }
3823 kmem_free(zc, sizeof (zfs_cmd_t));
3824
3825 if ((pair = nvlist_next_nvpair(errors, NULL)) == NULL) {
3826 nvlist_free(errors);
3827 errors = NULL;
3828 } else {
3829 VERIFY(nvpair_value_int32(pair, &rv) == 0);
3830 }
3831
3832 if (errlist == NULL)
3833 nvlist_free(errors);
3834 else
3835 *errlist = errors;
3836
3837 return (rv);
3838 }
3839
3840 static boolean_t
3841 propval_equals(nvpair_t *p1, nvpair_t *p2)
3842 {
3843 if (nvpair_type(p1) == DATA_TYPE_NVLIST) {
3844 /* dsl_prop_get_all_impl() format */
3845 nvlist_t *attrs;
3846 VERIFY(nvpair_value_nvlist(p1, &attrs) == 0);
3847 VERIFY(nvlist_lookup_nvpair(attrs, ZPROP_VALUE,
3848 &p1) == 0);
3849 }
3850
3851 if (nvpair_type(p2) == DATA_TYPE_NVLIST) {
3852 nvlist_t *attrs;
3853 VERIFY(nvpair_value_nvlist(p2, &attrs) == 0);
3854 VERIFY(nvlist_lookup_nvpair(attrs, ZPROP_VALUE,
3855 &p2) == 0);
3856 }
3857
3858 if (nvpair_type(p1) != nvpair_type(p2))
3859 return (B_FALSE);
3860
3861 if (nvpair_type(p1) == DATA_TYPE_STRING) {
3862 char *valstr1, *valstr2;
3863
3864 VERIFY(nvpair_value_string(p1, (char **)&valstr1) == 0);
3865 VERIFY(nvpair_value_string(p2, (char **)&valstr2) == 0);
3866 return (strcmp(valstr1, valstr2) == 0);
3867 } else {
3868 uint64_t intval1, intval2;
3869
3870 VERIFY(nvpair_value_uint64(p1, &intval1) == 0);
3871 VERIFY(nvpair_value_uint64(p2, &intval2) == 0);
3872 return (intval1 == intval2);
3873 }
3874 }
3875
3876 /*
3877 * Remove properties from props if they are not going to change (as determined
3878 * by comparison with origprops). Remove them from origprops as well, since we
3879 * do not need to clear or restore properties that won't change.
3880 */
3881 static void
3882 props_reduce(nvlist_t *props, nvlist_t *origprops)
3883 {
3884 nvpair_t *pair, *next_pair;
3885
3886 if (origprops == NULL)
3887 return; /* all props need to be received */
3888
3889 pair = nvlist_next_nvpair(props, NULL);
3890 while (pair != NULL) {
3891 const char *propname = nvpair_name(pair);
3892 nvpair_t *match;
3893
3894 next_pair = nvlist_next_nvpair(props, pair);
3895
3896 if ((nvlist_lookup_nvpair(origprops, propname,
3897 &match) != 0) || !propval_equals(pair, match))
3898 goto next; /* need to set received value */
3899
3900 /* don't clear the existing received value */
3901 (void) nvlist_remove_nvpair(origprops, match);
3902 /* don't bother receiving the property */
3903 (void) nvlist_remove_nvpair(props, pair);
3904 next:
3905 pair = next_pair;
3906 }
3907 }
3908
3909 #ifdef DEBUG
3910 static boolean_t zfs_ioc_recv_inject_err;
3911 #endif
3912
3913 /*
3914 * inputs:
3915 * zc_name name of containing filesystem
3916 * zc_nvlist_src{_size} nvlist of properties to apply
3917 * zc_value name of snapshot to create
3918 * zc_string name of clone origin (if DRR_FLAG_CLONE)
3919 * zc_cookie file descriptor to recv from
3920 * zc_begin_record the BEGIN record of the stream (not byteswapped)
3921 * zc_guid force flag
3922 * zc_cleanup_fd cleanup-on-exit file descriptor
3923 * zc_action_handle handle for this guid/ds mapping (or zero on first call)
3924 *
3925 * outputs:
3926 * zc_cookie number of bytes read
3927 * zc_nvlist_dst{_size} error for each unapplied received property
3928 * zc_obj zprop_errflags_t
3929 * zc_action_handle handle for this guid/ds mapping
3930 */
3931 static int
3932 zfs_ioc_recv(zfs_cmd_t *zc)
3933 {
3934 file_t *fp;
3935 objset_t *os;
3936 dmu_recv_cookie_t drc;
3937 boolean_t force = (boolean_t)zc->zc_guid;
3938 int fd;
3939 int error = 0;
3940 int props_error = 0;
3941 nvlist_t *errors;
3942 offset_t off;
3943 nvlist_t *props = NULL; /* sent properties */
3944 nvlist_t *origprops = NULL; /* existing properties */
3945 objset_t *origin = NULL;
3946 char *tosnap;
3947 char tofs[ZFS_MAXNAMELEN];
3948 boolean_t first_recvd_props = B_FALSE;
3949
3950 if (dataset_namecheck(zc->zc_value, NULL, NULL) != 0 ||
3951 strchr(zc->zc_value, '@') == NULL ||
3952 strchr(zc->zc_value, '%'))
3953 return (EINVAL);
3954
3955 (void) strcpy(tofs, zc->zc_value);
3956 tosnap = strchr(tofs, '@');
3957 *tosnap++ = '\0';
3958
3959 if (zc->zc_nvlist_src != NULL &&
3960 (error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
3961 zc->zc_iflags, &props)) != 0)
3962 return (error);
3963
3964 fd = zc->zc_cookie;
3965 fp = getf(fd);
3966 if (fp == NULL) {
3967 nvlist_free(props);
3968 return (EBADF);
3969 }
3970
3971 VERIFY(nvlist_alloc(&errors, NV_UNIQUE_NAME, KM_SLEEP) == 0);
3972
3973 if (props && dmu_objset_hold(tofs, FTAG, &os) == 0) {
3974 if ((spa_version(os->os_spa) >= SPA_VERSION_RECVD_PROPS) &&
3975 !dsl_prop_get_hasrecvd(os)) {
3976 first_recvd_props = B_TRUE;
3977 }
3978
3979 /*
3980 * If new received properties are supplied, they are to
3981 * completely replace the existing received properties, so stash
3982 * away the existing ones.
3983 */
3984 if (dsl_prop_get_received(os, &origprops) == 0) {
3985 nvlist_t *errlist = NULL;
3986 /*
3987 * Don't bother writing a property if its value won't
3988 * change (and avoid the unnecessary security checks).
3989 *
3990 * The first receive after SPA_VERSION_RECVD_PROPS is a
3991 * special case where we blow away all local properties
3992 * regardless.
3993 */
3994 if (!first_recvd_props)
3995 props_reduce(props, origprops);
3996 if (zfs_check_clearable(tofs, origprops,
3997 &errlist) != 0)
3998 (void) nvlist_merge(errors, errlist, 0);
3999 nvlist_free(errlist);
4000 }
4001
4002 dmu_objset_rele(os, FTAG);
4003 }
4004
4005 if (zc->zc_string[0]) {
4006 error = dmu_objset_hold(zc->zc_string, FTAG, &origin);
4007 if (error)
4008 goto out;
4009 }
4010
4011 error = dmu_recv_begin(tofs, tosnap, zc->zc_top_ds,
4012 &zc->zc_begin_record, force, origin, &drc);
4013 if (origin)
4014 dmu_objset_rele(origin, FTAG);
4015 if (error)
4016 goto out;
4017
4018 /*
4019 * Set properties before we receive the stream so that they are applied
4020 * to the new data. Note that we must call dmu_recv_stream() if
4021 * dmu_recv_begin() succeeds.
4022 */
4023 if (props) {
4024 if (dmu_objset_from_ds(drc.drc_logical_ds, &os) == 0) {
4025 if (drc.drc_newfs) {
4026 if (spa_version(os->os_spa) >=
4027 SPA_VERSION_RECVD_PROPS)
4028 first_recvd_props = B_TRUE;
4029 } else if (origprops != NULL) {
4030 if (clear_received_props(os, tofs, origprops,
4031 first_recvd_props ? NULL : props) != 0)
4032 zc->zc_obj |= ZPROP_ERR_NOCLEAR;
4033 } else {
4034 zc->zc_obj |= ZPROP_ERR_NOCLEAR;
4035 }
4036 dsl_prop_set_hasrecvd(os);
4037 } else if (!drc.drc_newfs) {
4038 zc->zc_obj |= ZPROP_ERR_NOCLEAR;
4039 }
4040
4041 (void) zfs_set_prop_nvlist(tofs, ZPROP_SRC_RECEIVED,
4042 props, errors);
4043 }
4044
4045 if (zc->zc_nvlist_dst_size != 0 &&
4046 (nvlist_smush(errors, zc->zc_nvlist_dst_size) != 0 ||
4047 put_nvlist(zc, errors) != 0)) {
4048 /*
4049 * Caller made zc->zc_nvlist_dst less than the minimum expected
4050 * size or supplied an invalid address.
4051 */
4052 props_error = EINVAL;
4053 }
4054
4055 off = fp->f_offset;
4056 error = dmu_recv_stream(&drc, fp->f_vnode, &off, zc->zc_cleanup_fd,
4057 &zc->zc_action_handle);
4058
4059 if (error == 0) {
4060 zfsvfs_t *zfsvfs = NULL;
4061
4062 if (getzfsvfs(tofs, &zfsvfs) == 0) {
4063 /* online recv */
4064 int end_err;
4065
4066 error = zfs_suspend_fs(zfsvfs);
4067 /*
4068 * If the suspend fails, then the recv_end will
4069 * likely also fail, and clean up after itself.
4070 */
4071 end_err = dmu_recv_end(&drc);
4072 if (error == 0)
4073 error = zfs_resume_fs(zfsvfs, tofs);
4074 error = error ? error : end_err;
4075 VFS_RELE(zfsvfs->z_vfs);
4076 } else {
4077 error = dmu_recv_end(&drc);
4078 }
4079 }
4080
4081 zc->zc_cookie = off - fp->f_offset;
4082 if (VOP_SEEK(fp->f_vnode, fp->f_offset, &off, NULL) == 0)
4083 fp->f_offset = off;
4084
4085 #ifdef DEBUG
4086 if (zfs_ioc_recv_inject_err) {
4087 zfs_ioc_recv_inject_err = B_FALSE;
4088 error = 1;
4089 }
4090 #endif
4091 /*
4092 * On error, restore the original props.
4093 */
4094 if (error && props) {
4095 if (dmu_objset_hold(tofs, FTAG, &os) == 0) {
4096 if (clear_received_props(os, tofs, props, NULL) != 0) {
4097 /*
4098 * We failed to clear the received properties.
4099 * Since we may have left a $recvd value on the
4100 * system, we can't clear the $hasrecvd flag.
4101 */
4102 zc->zc_obj |= ZPROP_ERR_NORESTORE;
4103 } else if (first_recvd_props) {
4104 dsl_prop_unset_hasrecvd(os);
4105 }
4106 dmu_objset_rele(os, FTAG);
4107 } else if (!drc.drc_newfs) {
4108 /* We failed to clear the received properties. */
4109 zc->zc_obj |= ZPROP_ERR_NORESTORE;
4110 }
4111
4112 if (origprops == NULL && !drc.drc_newfs) {
4113 /* We failed to stash the original properties. */
4114 zc->zc_obj |= ZPROP_ERR_NORESTORE;
4115 }
4116
4117 /*
4118 * dsl_props_set() will not convert RECEIVED to LOCAL on or
4119 * after SPA_VERSION_RECVD_PROPS, so we need to specify LOCAL
4120 * explictly if we're restoring local properties cleared in the
4121 * first new-style receive.
4122 */
4123 if (origprops != NULL &&
4124 zfs_set_prop_nvlist(tofs, (first_recvd_props ?
4125 ZPROP_SRC_LOCAL : ZPROP_SRC_RECEIVED),
4126 origprops, NULL) != 0) {
4127 /*
4128 * We stashed the original properties but failed to
4129 * restore them.
4130 */
4131 zc->zc_obj |= ZPROP_ERR_NORESTORE;
4132 }
4133 }
4134 out:
4135 nvlist_free(props);
4136 nvlist_free(origprops);
4137 nvlist_free(errors);
4138 releasef(fd);
4139
4140 if (error == 0)
4141 error = props_error;
4142
4143 return (error);
4144 }
4145
4146 /*
4147 * inputs:
4148 * zc_name name of snapshot to send
4149 * zc_cookie file descriptor to send stream to
4150 * zc_obj fromorigin flag (mutually exclusive with zc_fromobj)
4151 * zc_sendobj objsetid of snapshot to send
4152 * zc_fromobj objsetid of incremental fromsnap (may be zero)
4153 * zc_guid if set, estimate size of stream only. zc_cookie is ignored.
4154 * output size in zc_objset_type.
4155 *
4156 * outputs: none
4157 */
4158 static int
4159 zfs_ioc_send(zfs_cmd_t *zc)
4160 {
4161 objset_t *fromsnap = NULL;
4162 objset_t *tosnap;
4163 int error;
4164 offset_t off;
4165 dsl_dataset_t *ds;
4166 dsl_dataset_t *dsfrom = NULL;
4167 spa_t *spa;
4168 dsl_pool_t *dp;
4169 boolean_t estimate = (zc->zc_guid != 0);
4170
4171 error = spa_open(zc->zc_name, &spa, FTAG);
4172 if (error)
4173 return (error);
4174
4175 dp = spa_get_dsl(spa);
4176 rw_enter(&dp->dp_config_rwlock, RW_READER);
4177 error = dsl_dataset_hold_obj(dp, zc->zc_sendobj, FTAG, &ds);
4178 rw_exit(&dp->dp_config_rwlock);
4179 spa_close(spa, FTAG);
4180 if (error)
4181 return (error);
4182
4183 error = dmu_objset_from_ds(ds, &tosnap);
4184 if (error) {
4185 dsl_dataset_rele(ds, FTAG);
4186 return (error);
4187 }
4188
4189 if (zc->zc_fromobj != 0) {
4190 rw_enter(&dp->dp_config_rwlock, RW_READER);
4191 error = dsl_dataset_hold_obj(dp, zc->zc_fromobj, FTAG, &dsfrom);
4192 rw_exit(&dp->dp_config_rwlock);
4193 if (error) {
4194 dsl_dataset_rele(ds, FTAG);
4195 return (error);
4196 }
4197 error = dmu_objset_from_ds(dsfrom, &fromsnap);
4198 if (error) {
4199 dsl_dataset_rele(dsfrom, FTAG);
4200 dsl_dataset_rele(ds, FTAG);
4201 return (error);
4202 }
4203 }
4204
4205 if (zc->zc_obj) {
4206 dsl_pool_t *dp = ds->ds_dir->dd_pool;
4207
4208 if (fromsnap != NULL) {
4209 dsl_dataset_rele(dsfrom, FTAG);
4210 dsl_dataset_rele(ds, FTAG);
4211 return (EINVAL);
4212 }
4213
4214 if (dsl_dir_is_clone(ds->ds_dir)) {
4215 rw_enter(&dp->dp_config_rwlock, RW_READER);
4216 error = dsl_dataset_hold_obj(dp,
4217 ds->ds_dir->dd_phys->dd_origin_obj, FTAG, &dsfrom);
4218 rw_exit(&dp->dp_config_rwlock);
4219 if (error) {
4220 dsl_dataset_rele(ds, FTAG);
4221 return (error);
4222 }
4223 error = dmu_objset_from_ds(dsfrom, &fromsnap);
4224 if (error) {
4225 dsl_dataset_rele(dsfrom, FTAG);
4226 dsl_dataset_rele(ds, FTAG);
4227 return (error);
4228 }
4229 }
4230 }
4231
4232 if (estimate) {
4233 error = dmu_send_estimate(tosnap, fromsnap,
4234 &zc->zc_objset_type);
4235 } else {
4236 file_t *fp = getf(zc->zc_cookie);
4237 if (fp == NULL) {
4238 dsl_dataset_rele(ds, FTAG);
4239 if (dsfrom)
4240 dsl_dataset_rele(dsfrom, FTAG);
4241 return (EBADF);
4242 }
4243
4244 off = fp->f_offset;
4245 error = dmu_send(tosnap, fromsnap,
4246 zc->zc_cookie, fp->f_vnode, &off);
4247
4248 if (VOP_SEEK(fp->f_vnode, fp->f_offset, &off, NULL) == 0)
4249 fp->f_offset = off;
4250 releasef(zc->zc_cookie);
4251 }
4252 if (dsfrom)
4253 dsl_dataset_rele(dsfrom, FTAG);
4254 dsl_dataset_rele(ds, FTAG);
4255 return (error);
4256 }
4257
4258 /*
4259 * inputs:
4260 * zc_name name of snapshot on which to report progress
4261 * zc_cookie file descriptor of send stream
4262 *
4263 * outputs:
4264 * zc_cookie number of bytes written in send stream thus far
4265 */
4266 static int
4267 zfs_ioc_send_progress(zfs_cmd_t *zc)
4268 {
4269 dsl_dataset_t *ds;
4270 dmu_sendarg_t *dsp = NULL;
4271 int error;
4272
4273 if ((error = dsl_dataset_hold(zc->zc_name, FTAG, &ds)) != 0)
4274 return (error);
4275
4276 mutex_enter(&ds->ds_sendstream_lock);
4277
4278 /*
4279 * Iterate over all the send streams currently active on this dataset.
4280 * If there's one which matches the specified file descriptor _and_ the
4281 * stream was started by the current process, return the progress of
4282 * that stream.
4283 */
4284 for (dsp = list_head(&ds->ds_sendstreams); dsp != NULL;
4285 dsp = list_next(&ds->ds_sendstreams, dsp)) {
4286 if (dsp->dsa_outfd == zc->zc_cookie &&
4287 dsp->dsa_proc == curproc)
4288 break;
4289 }
4290
4291 if (dsp != NULL)
4292 zc->zc_cookie = *(dsp->dsa_off);
4293 else
4294 error = ENOENT;
4295
4296 mutex_exit(&ds->ds_sendstream_lock);
4297 dsl_dataset_rele(ds, FTAG);
4298 return (error);
4299 }
4300
4301 static int
4302 zfs_ioc_inject_fault(zfs_cmd_t *zc)
4303 {
4304 int id, error;
4305
4306 error = zio_inject_fault(zc->zc_name, (int)zc->zc_guid, &id,
4307 &zc->zc_inject_record);
4308
4309 if (error == 0)
4310 zc->zc_guid = (uint64_t)id;
4311
4312 return (error);
4313 }
4314
4315 static int
4316 zfs_ioc_clear_fault(zfs_cmd_t *zc)
4317 {
4318 return (zio_clear_fault((int)zc->zc_guid));
4319 }
4320
4321 static int
4322 zfs_ioc_inject_list_next(zfs_cmd_t *zc)
4323 {
4324 int id = (int)zc->zc_guid;
4325 int error;
4326
4327 error = zio_inject_list_next(&id, zc->zc_name, sizeof (zc->zc_name),
4328 &zc->zc_inject_record);
4329
4330 zc->zc_guid = id;
4331
4332 return (error);
4333 }
4334
4335 static int
4336 zfs_ioc_error_log(zfs_cmd_t *zc)
4337 {
4338 spa_t *spa;
4339 int error;
4340 size_t count = (size_t)zc->zc_nvlist_dst_size;
4341
4342 if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
4343 return (error);
4344
4345 error = spa_get_errlog(spa, (void *)(uintptr_t)zc->zc_nvlist_dst,
4346 &count);
4347 if (error == 0)
4348 zc->zc_nvlist_dst_size = count;
4349 else
4350 zc->zc_nvlist_dst_size = spa_get_errlog_size(spa);
4351
4352 spa_close(spa, FTAG);
4353
4354 return (error);
4355 }
4356
4357 static int
4358 zfs_ioc_clear(zfs_cmd_t *zc)
4359 {
4360 spa_t *spa;
4361 vdev_t *vd;
4362 int error;
4363
4364 /*
4365 * On zpool clear we also fix up missing slogs
4366 */
4367 mutex_enter(&spa_namespace_lock);
4368 spa = spa_lookup(zc->zc_name);
4369 if (spa == NULL) {
4370 mutex_exit(&spa_namespace_lock);
4371 return (EIO);
4372 }
4373 if (spa_get_log_state(spa) == SPA_LOG_MISSING) {
4374 /* we need to let spa_open/spa_load clear the chains */
4375 spa_set_log_state(spa, SPA_LOG_CLEAR);
4376 }
4377 spa->spa_last_open_failed = 0;
4378 mutex_exit(&spa_namespace_lock);
4379
4380 if (zc->zc_cookie & ZPOOL_NO_REWIND) {
4381 error = spa_open(zc->zc_name, &spa, FTAG);
4382 } else {
4383 nvlist_t *policy;
4384 nvlist_t *config = NULL;
4385
4386 if (zc->zc_nvlist_src == NULL)
4387 return (EINVAL);
4388
4389 if ((error = get_nvlist(zc->zc_nvlist_src,
4390 zc->zc_nvlist_src_size, zc->zc_iflags, &policy)) == 0) {
4391 error = spa_open_rewind(zc->zc_name, &spa, FTAG,
4392 policy, &config);
4393 if (config != NULL) {
4394 int err;
4395
4396 if ((err = put_nvlist(zc, config)) != 0)
4397 error = err;
4398 nvlist_free(config);
4399 }
4400 nvlist_free(policy);
4401 }
4402 }
4403
4404 if (error)
4405 return (error);
4406
4407 spa_vdev_state_enter(spa, SCL_NONE);
4408
4409 if (zc->zc_guid == 0) {
4410 vd = NULL;
4411 } else {
4412 vd = spa_lookup_by_guid(spa, zc->zc_guid, B_TRUE);
4413 if (vd == NULL) {
4414 (void) spa_vdev_state_exit(spa, NULL, ENODEV);
4415 spa_close(spa, FTAG);
4416 return (ENODEV);
4417 }
4418 }
4419
4420 vdev_clear(spa, vd);
4421
4422 (void) spa_vdev_state_exit(spa, NULL, 0);
4423
4424 /*
4425 * Resume any suspended I/Os.
4426 */
4427 if (zio_resume(spa) != 0)
4428 error = EIO;
4429
4430 spa_close(spa, FTAG);
4431
4432 return (error);
4433 }
4434
4435 static int
4436 zfs_ioc_pool_reopen(zfs_cmd_t *zc)
4437 {
4438 spa_t *spa;
4439 int error;
4440
4441 error = spa_open(zc->zc_name, &spa, FTAG);
4442 if (error)
4443 return (error);
4444
4445 spa_vdev_state_enter(spa, SCL_NONE);
4446
4447 /*
4448 * If a resilver is already in progress then set the
4449 * spa_scrub_reopen flag to B_TRUE so that we don't restart
4450 * the scan as a side effect of the reopen. Otherwise, let
4451 * vdev_open() decided if a resilver is required.
4452 */
4453 spa->spa_scrub_reopen = dsl_scan_resilvering(spa->spa_dsl_pool);
4454 vdev_reopen(spa->spa_root_vdev);
4455 spa->spa_scrub_reopen = B_FALSE;
4456
4457 (void) spa_vdev_state_exit(spa, NULL, 0);
4458 spa_close(spa, FTAG);
4459 return (0);
4460 }
4461 /*
4462 * inputs:
4463 * zc_name name of filesystem
4464 * zc_value name of origin snapshot
4465 *
4466 * outputs:
4467 * zc_string name of conflicting snapshot, if there is one
4468 */
4469 static int
4470 zfs_ioc_promote(zfs_cmd_t *zc)
4471 {
4472 char *cp;
4473
4474 /*
4475 * We don't need to unmount *all* the origin fs's snapshots, but
4476 * it's easier.
4477 */
4478 cp = strchr(zc->zc_value, '@');
4479 if (cp)
4480 *cp = '\0';
4481 (void) dmu_objset_find(zc->zc_value,
4482 zfs_unmount_snap, NULL, DS_FIND_SNAPSHOTS);
4483 return (dsl_dataset_promote(zc->zc_name, zc->zc_string));
4484 }
4485
4486 /*
4487 * Retrieve a single {user|group}{used|quota}@... property.
4488 *
4489 * inputs:
4490 * zc_name name of filesystem
4491 * zc_objset_type zfs_userquota_prop_t
4492 * zc_value domain name (eg. "S-1-234-567-89")
4493 * zc_guid RID/UID/GID
4494 *
4495 * outputs:
4496 * zc_cookie property value
4497 */
4498 static int
4499 zfs_ioc_userspace_one(zfs_cmd_t *zc)
4500 {
4501 zfsvfs_t *zfsvfs;
4502 int error;
4503
4504 if (zc->zc_objset_type >= ZFS_NUM_USERQUOTA_PROPS)
4505 return (EINVAL);
4506
4507 error = zfsvfs_hold(zc->zc_name, FTAG, &zfsvfs, B_FALSE);
4508 if (error)
4509 return (error);
4510
4511 error = zfs_userspace_one(zfsvfs,
4512 zc->zc_objset_type, zc->zc_value, zc->zc_guid, &zc->zc_cookie);
4513 zfsvfs_rele(zfsvfs, FTAG);
4514
4515 return (error);
4516 }
4517
4518 /*
4519 * inputs:
4520 * zc_name name of filesystem
4521 * zc_cookie zap cursor
4522 * zc_objset_type zfs_userquota_prop_t
4523 * zc_nvlist_dst[_size] buffer to fill (not really an nvlist)
4524 *
4525 * outputs:
4526 * zc_nvlist_dst[_size] data buffer (array of zfs_useracct_t)
4527 * zc_cookie zap cursor
4528 */
4529 static int
4530 zfs_ioc_userspace_many(zfs_cmd_t *zc)
4531 {
4532 zfsvfs_t *zfsvfs;
4533 int bufsize = zc->zc_nvlist_dst_size;
4534
4535 if (bufsize <= 0)
4536 return (ENOMEM);
4537
4538 int error = zfsvfs_hold(zc->zc_name, FTAG, &zfsvfs, B_FALSE);
4539 if (error)
4540 return (error);
4541
4542 void *buf = kmem_alloc(bufsize, KM_SLEEP);
4543
4544 error = zfs_userspace_many(zfsvfs, zc->zc_objset_type, &zc->zc_cookie,
4545 buf, &zc->zc_nvlist_dst_size);
4546
4547 if (error == 0) {
4548 error = xcopyout(buf,
4549 (void *)(uintptr_t)zc->zc_nvlist_dst,
4550 zc->zc_nvlist_dst_size);
4551 }
4552 kmem_free(buf, bufsize);
4553 zfsvfs_rele(zfsvfs, FTAG);
4554
4555 return (error);
4556 }
4557
4558 /*
4559 * inputs:
4560 * zc_name name of filesystem
4561 *
4562 * outputs:
4563 * none
4564 */
4565 static int
4566 zfs_ioc_userspace_upgrade(zfs_cmd_t *zc)
4567 {
4568 objset_t *os;
4569 int error = 0;
4570 zfsvfs_t *zfsvfs;
4571
4572 if (getzfsvfs(zc->zc_name, &zfsvfs) == 0) {
4573 if (!dmu_objset_userused_enabled(zfsvfs->z_os)) {
4574 /*
4575 * If userused is not enabled, it may be because the
4576 * objset needs to be closed & reopened (to grow the
4577 * objset_phys_t). Suspend/resume the fs will do that.
4578 */
4579 error = zfs_suspend_fs(zfsvfs);
4580 if (error == 0)
4581 error = zfs_resume_fs(zfsvfs, zc->zc_name);
4582 }
4583 if (error == 0)
4584 error = dmu_objset_userspace_upgrade(zfsvfs->z_os);
4585 VFS_RELE(zfsvfs->z_vfs);
4586 } else {
4587 /* XXX kind of reading contents without owning */
4588 error = dmu_objset_hold(zc->zc_name, FTAG, &os);
4589 if (error)
4590 return (error);
4591
4592 error = dmu_objset_userspace_upgrade(os);
4593 dmu_objset_rele(os, FTAG);
4594 }
4595
4596 return (error);
4597 }
4598
4599 /*
4600 * We don't want to have a hard dependency
4601 * against some special symbols in sharefs
4602 * nfs, and smbsrv. Determine them if needed when
4603 * the first file system is shared.
4604 * Neither sharefs, nfs or smbsrv are unloadable modules.
4605 */
4606 int (*znfsexport_fs)(void *arg);
4607 int (*zshare_fs)(enum sharefs_sys_op, share_t *, uint32_t);
4608 int (*zsmbexport_fs)(void *arg, boolean_t add_share);
4609
4610 int zfs_nfsshare_inited;
4611 int zfs_smbshare_inited;
4612
4613 ddi_modhandle_t nfs_mod;
4614 ddi_modhandle_t sharefs_mod;
4615 ddi_modhandle_t smbsrv_mod;
4616 kmutex_t zfs_share_lock;
4617
4618 static int
4619 zfs_init_sharefs()
4620 {
4621 int error;
4622
4623 ASSERT(MUTEX_HELD(&zfs_share_lock));
4624 /* Both NFS and SMB shares also require sharetab support. */
4625 if (sharefs_mod == NULL && ((sharefs_mod =
4626 ddi_modopen("fs/sharefs",
4627 KRTLD_MODE_FIRST, &error)) == NULL)) {
4628 return (ENOSYS);
4629 }
4630 if (zshare_fs == NULL && ((zshare_fs =
4631 (int (*)(enum sharefs_sys_op, share_t *, uint32_t))
4632 ddi_modsym(sharefs_mod, "sharefs_impl", &error)) == NULL)) {
4633 return (ENOSYS);
4634 }
4635 return (0);
4636 }
4637
4638 static int
4639 zfs_ioc_share(zfs_cmd_t *zc)
4640 {
4641 int error;
4642 int opcode;
4643
4644 switch (zc->zc_share.z_sharetype) {
4645 case ZFS_SHARE_NFS:
4646 case ZFS_UNSHARE_NFS:
4647 if (zfs_nfsshare_inited == 0) {
4648 mutex_enter(&zfs_share_lock);
4649 if (nfs_mod == NULL && ((nfs_mod = ddi_modopen("fs/nfs",
4650 KRTLD_MODE_FIRST, &error)) == NULL)) {
4651 mutex_exit(&zfs_share_lock);
4652 return (ENOSYS);
4653 }
4654 if (znfsexport_fs == NULL &&
4655 ((znfsexport_fs = (int (*)(void *))
4656 ddi_modsym(nfs_mod,
4657 "nfs_export", &error)) == NULL)) {
4658 mutex_exit(&zfs_share_lock);
4659 return (ENOSYS);
4660 }
4661 error = zfs_init_sharefs();
4662 if (error) {
4663 mutex_exit(&zfs_share_lock);
4664 return (ENOSYS);
4665 }
4666 zfs_nfsshare_inited = 1;
4667 mutex_exit(&zfs_share_lock);
4668 }
4669 break;
4670 case ZFS_SHARE_SMB:
4671 case ZFS_UNSHARE_SMB:
4672 if (zfs_smbshare_inited == 0) {
4673 mutex_enter(&zfs_share_lock);
4674 if (smbsrv_mod == NULL && ((smbsrv_mod =
4675 ddi_modopen("drv/smbsrv",
4676 KRTLD_MODE_FIRST, &error)) == NULL)) {
4677 mutex_exit(&zfs_share_lock);
4678 return (ENOSYS);
4679 }
4680 if (zsmbexport_fs == NULL && ((zsmbexport_fs =
4681 (int (*)(void *, boolean_t))ddi_modsym(smbsrv_mod,
4682 "smb_server_share", &error)) == NULL)) {
4683 mutex_exit(&zfs_share_lock);
4684 return (ENOSYS);
4685 }
4686 error = zfs_init_sharefs();
4687 if (error) {
4688 mutex_exit(&zfs_share_lock);
4689 return (ENOSYS);
4690 }
4691 zfs_smbshare_inited = 1;
4692 mutex_exit(&zfs_share_lock);
4693 }
4694 break;
4695 default:
4696 return (EINVAL);
4697 }
4698
4699 switch (zc->zc_share.z_sharetype) {
4700 case ZFS_SHARE_NFS:
4701 case ZFS_UNSHARE_NFS:
4702 if (error =
4703 znfsexport_fs((void *)
4704 (uintptr_t)zc->zc_share.z_exportdata))
4705 return (error);
4706 break;
4707 case ZFS_SHARE_SMB:
4708 case ZFS_UNSHARE_SMB:
4709 if (error = zsmbexport_fs((void *)
4710 (uintptr_t)zc->zc_share.z_exportdata,
4711 zc->zc_share.z_sharetype == ZFS_SHARE_SMB ?
4712 B_TRUE: B_FALSE)) {
4713 return (error);
4714 }
4715 break;
4716 }
4717
4718 opcode = (zc->zc_share.z_sharetype == ZFS_SHARE_NFS ||
4719 zc->zc_share.z_sharetype == ZFS_SHARE_SMB) ?
4720 SHAREFS_ADD : SHAREFS_REMOVE;
4721
4722 /*
4723 * Add or remove share from sharetab
4724 */
4725 error = zshare_fs(opcode,
4726 (void *)(uintptr_t)zc->zc_share.z_sharedata,
4727 zc->zc_share.z_sharemax);
4728
4729 return (error);
4730
4731 }
4732
4733 ace_t full_access[] = {
4734 {(uid_t)-1, ACE_ALL_PERMS, ACE_EVERYONE, 0}
4735 };
4736
4737 /*
4738 * inputs:
4739 * zc_name name of containing filesystem
4740 * zc_obj object # beyond which we want next in-use object #
4741 *
4742 * outputs:
4743 * zc_obj next in-use object #
4744 */
4745 static int
4746 zfs_ioc_next_obj(zfs_cmd_t *zc)
4747 {
4748 objset_t *os = NULL;
4749 int error;
4750
4751 error = dmu_objset_hold(zc->zc_name, FTAG, &os);
4752 if (error)
4753 return (error);
4754
4755 error = dmu_object_next(os, &zc->zc_obj, B_FALSE,
4756 os->os_dsl_dataset->ds_phys->ds_prev_snap_txg);
4757
4758 dmu_objset_rele(os, FTAG);
4759 return (error);
4760 }
4761
4762 /*
4763 * inputs:
4764 * zc_name name of filesystem
4765 * zc_value prefix name for snapshot
4766 * zc_cleanup_fd cleanup-on-exit file descriptor for calling process
4767 *
4768 * outputs:
4769 * zc_value short name of new snapshot
4770 */
4771 static int
4772 zfs_ioc_tmp_snapshot(zfs_cmd_t *zc)
4773 {
4774 char *snap_name;
4775 int error;
4776
4777 snap_name = kmem_asprintf("%s@%s-%016llx", zc->zc_name, zc->zc_value,
4778 (u_longlong_t)ddi_get_lbolt64());
4779
4780 if (strlen(snap_name) >= MAXPATHLEN) {
4781 strfree(snap_name);
4782 return (E2BIG);
4783 }
4784
4785 error = dmu_objset_snapshot_tmp(snap_name, "%temp", zc->zc_cleanup_fd);
4786 if (error != 0) {
4787 strfree(snap_name);
4788 return (error);
4789 }
4790
4791 (void) strcpy(zc->zc_value, strchr(snap_name, '@') + 1);
4792 strfree(snap_name);
4793 return (0);
4794 }
4795
4796 /*
4797 * inputs:
4798 * zc_name name of "to" snapshot
4799 * zc_value name of "from" snapshot
4800 * zc_cookie file descriptor to write diff data on
4801 *
4802 * outputs:
4803 * dmu_diff_record_t's to the file descriptor
4804 */
4805 static int
4806 zfs_ioc_diff(zfs_cmd_t *zc)
4807 {
4808 objset_t *fromsnap;
4809 objset_t *tosnap;
4810 file_t *fp;
4811 offset_t off;
4812 int error;
4813
4814 error = dmu_objset_hold(zc->zc_name, FTAG, &tosnap);
4815 if (error)
4816 return (error);
4817
4818 error = dmu_objset_hold(zc->zc_value, FTAG, &fromsnap);
4819 if (error) {
4820 dmu_objset_rele(tosnap, FTAG);
4821 return (error);
4822 }
4823
4824 fp = getf(zc->zc_cookie);
4825 if (fp == NULL) {
4826 dmu_objset_rele(fromsnap, FTAG);
4827 dmu_objset_rele(tosnap, FTAG);
4828 return (EBADF);
4829 }
4830
4831 off = fp->f_offset;
4832
4833 error = dmu_diff(tosnap, fromsnap, fp->f_vnode, &off);
4834
4835 if (VOP_SEEK(fp->f_vnode, fp->f_offset, &off, NULL) == 0)
4836 fp->f_offset = off;
4837 releasef(zc->zc_cookie);
4838
4839 dmu_objset_rele(fromsnap, FTAG);
4840 dmu_objset_rele(tosnap, FTAG);
4841 return (error);
4842 }
4843
4844 /*
4845 * Remove all ACL files in shares dir
4846 */
4847 static int
4848 zfs_smb_acl_purge(znode_t *dzp)
4849 {
4850 zap_cursor_t zc;
4851 zap_attribute_t zap;
4852 zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
4853 int error;
4854
4855 for (zap_cursor_init(&zc, zfsvfs->z_os, dzp->z_id);
4856 (error = zap_cursor_retrieve(&zc, &zap)) == 0;
4857 zap_cursor_advance(&zc)) {
4858 if ((error = VOP_REMOVE(ZTOV(dzp), zap.za_name, kcred,
4859 NULL, 0)) != 0)
4860 break;
4861 }
4862 zap_cursor_fini(&zc);
4863 return (error);
4864 }
4865
4866 static int
4867 zfs_ioc_smb_acl(zfs_cmd_t *zc)
4868 {
4869 vnode_t *vp;
4870 znode_t *dzp;
4871 vnode_t *resourcevp = NULL;
4872 znode_t *sharedir;
4873 zfsvfs_t *zfsvfs;
4874 nvlist_t *nvlist;
4875 char *src, *target;
4876 vattr_t vattr;
4877 vsecattr_t vsec;
4878 int error = 0;
4879
4880 if ((error = lookupname(zc->zc_value, UIO_SYSSPACE,
4881 NO_FOLLOW, NULL, &vp)) != 0)
4882 return (error);
4883
4884 /* Now make sure mntpnt and dataset are ZFS */
4885
4886 if (vp->v_vfsp->vfs_fstype != zfsfstype ||
4887 (strcmp((char *)refstr_value(vp->v_vfsp->vfs_resource),
4888 zc->zc_name) != 0)) {
4889 VN_RELE(vp);
4890 return (EINVAL);
4891 }
4892
4893 dzp = VTOZ(vp);
4894 zfsvfs = dzp->z_zfsvfs;
4895 ZFS_ENTER(zfsvfs);
4896
4897 /*
4898 * Create share dir if its missing.
4899 */
4900 mutex_enter(&zfsvfs->z_lock);
4901 if (zfsvfs->z_shares_dir == 0) {
4902 dmu_tx_t *tx;
4903
4904 tx = dmu_tx_create(zfsvfs->z_os);
4905 dmu_tx_hold_zap(tx, MASTER_NODE_OBJ, TRUE,
4906 ZFS_SHARES_DIR);
4907 dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, FALSE, NULL);
4908 error = dmu_tx_assign(tx, TXG_WAIT);
4909 if (error) {
4910 dmu_tx_abort(tx);
4911 } else {
4912 error = zfs_create_share_dir(zfsvfs, tx);
4913 dmu_tx_commit(tx);
4914 }
4915 if (error) {
4916 mutex_exit(&zfsvfs->z_lock);
4917 VN_RELE(vp);
4918 ZFS_EXIT(zfsvfs);
4919 return (error);
4920 }
4921 }
4922 mutex_exit(&zfsvfs->z_lock);
4923
4924 ASSERT(zfsvfs->z_shares_dir);
4925 if ((error = zfs_zget(zfsvfs, zfsvfs->z_shares_dir, &sharedir)) != 0) {
4926 VN_RELE(vp);
4927 ZFS_EXIT(zfsvfs);
4928 return (error);
4929 }
4930
4931 switch (zc->zc_cookie) {
4932 case ZFS_SMB_ACL_ADD:
4933 vattr.va_mask = AT_MODE|AT_UID|AT_GID|AT_TYPE;
4934 vattr.va_type = VREG;
4935 vattr.va_mode = S_IFREG|0777;
4936 vattr.va_uid = 0;
4937 vattr.va_gid = 0;
4938
4939 vsec.vsa_mask = VSA_ACE;
4940 vsec.vsa_aclentp = &full_access;
4941 vsec.vsa_aclentsz = sizeof (full_access);
4942 vsec.vsa_aclcnt = 1;
4943
4944 error = VOP_CREATE(ZTOV(sharedir), zc->zc_string,
4945 &vattr, EXCL, 0, &resourcevp, kcred, 0, NULL, &vsec);
4946 if (resourcevp)
4947 VN_RELE(resourcevp);
4948 break;
4949
4950 case ZFS_SMB_ACL_REMOVE:
4951 error = VOP_REMOVE(ZTOV(sharedir), zc->zc_string, kcred,
4952 NULL, 0);
4953 break;
4954
4955 case ZFS_SMB_ACL_RENAME:
4956 if ((error = get_nvlist(zc->zc_nvlist_src,
4957 zc->zc_nvlist_src_size, zc->zc_iflags, &nvlist)) != 0) {
4958 VN_RELE(vp);
4959 ZFS_EXIT(zfsvfs);
4960 return (error);
4961 }
4962 if (nvlist_lookup_string(nvlist, ZFS_SMB_ACL_SRC, &src) ||
4963 nvlist_lookup_string(nvlist, ZFS_SMB_ACL_TARGET,
4964 &target)) {
4965 VN_RELE(vp);
4966 VN_RELE(ZTOV(sharedir));
4967 ZFS_EXIT(zfsvfs);
4968 nvlist_free(nvlist);
4969 return (error);
4970 }
4971 error = VOP_RENAME(ZTOV(sharedir), src, ZTOV(sharedir), target,
4972 kcred, NULL, 0);
4973 nvlist_free(nvlist);
4974 break;
4975
4976 case ZFS_SMB_ACL_PURGE:
4977 error = zfs_smb_acl_purge(sharedir);
4978 break;
4979
4980 default:
4981 error = EINVAL;
4982 break;
4983 }
4984
4985 VN_RELE(vp);
4986 VN_RELE(ZTOV(sharedir));
4987
4988 ZFS_EXIT(zfsvfs);
4989
4990 return (error);
4991 }
4992
4993 /*
4994 * inputs:
4995 * zc_name name of filesystem
4996 * zc_value short name of snap
4997 * zc_string user-supplied tag for this hold
4998 * zc_cookie recursive flag
4999 * zc_temphold set if hold is temporary
5000 * zc_cleanup_fd cleanup-on-exit file descriptor for calling process
5001 * zc_sendobj if non-zero, the objid for zc_name@zc_value
5002 * zc_createtxg if zc_sendobj is non-zero, snap must have zc_createtxg
5003 *
5004 * outputs: none
5005 */
5006 static int
5007 zfs_ioc_hold(zfs_cmd_t *zc)
5008 {
5009 boolean_t recursive = zc->zc_cookie;
5010 spa_t *spa;
5011 dsl_pool_t *dp;
5012 dsl_dataset_t *ds;
5013 int error;
5014 minor_t minor = 0;
5015
5016 if (snapshot_namecheck(zc->zc_value, NULL, NULL) != 0)
5017 return (EINVAL);
5018
5019 if (zc->zc_sendobj == 0) {
5020 return (dsl_dataset_user_hold(zc->zc_name, zc->zc_value,
5021 zc->zc_string, recursive, zc->zc_temphold,
5022 zc->zc_cleanup_fd));
5023 }
5024
5025 if (recursive)
5026 return (EINVAL);
5027
5028 error = spa_open(zc->zc_name, &spa, FTAG);
5029 if (error)
5030 return (error);
5031
5032 dp = spa_get_dsl(spa);
5033 rw_enter(&dp->dp_config_rwlock, RW_READER);
5034 error = dsl_dataset_hold_obj(dp, zc->zc_sendobj, FTAG, &ds);
5035 rw_exit(&dp->dp_config_rwlock);
5036 spa_close(spa, FTAG);
5037 if (error)
5038 return (error);
5039
5040 /*
5041 * Until we have a hold on this snapshot, it's possible that
5042 * zc_sendobj could've been destroyed and reused as part
5043 * of a later txg. Make sure we're looking at the right object.
5044 */
5045 if (zc->zc_createtxg != ds->ds_phys->ds_creation_txg) {
5046 dsl_dataset_rele(ds, FTAG);
5047 return (ENOENT);
5048 }
5049
5050 if (zc->zc_cleanup_fd != -1 && zc->zc_temphold) {
5051 error = zfs_onexit_fd_hold(zc->zc_cleanup_fd, &minor);
5052 if (error) {
5053 dsl_dataset_rele(ds, FTAG);
5054 return (error);
5055 }
5056 }
5057
5058 error = dsl_dataset_user_hold_for_send(ds, zc->zc_string,
5059 zc->zc_temphold);
5060 if (minor != 0) {
5061 if (error == 0) {
5062 dsl_register_onexit_hold_cleanup(ds, zc->zc_string,
5063 minor);
5064 }
5065 zfs_onexit_fd_rele(zc->zc_cleanup_fd);
5066 }
5067 dsl_dataset_rele(ds, FTAG);
5068
5069 return (error);
5070 }
5071
5072 /*
5073 * inputs:
5074 * zc_name name of dataset from which we're releasing a user hold
5075 * zc_value short name of snap
5076 * zc_string user-supplied tag for this hold
5077 * zc_cookie recursive flag
5078 *
5079 * outputs: none
5080 */
5081 static int
5082 zfs_ioc_release(zfs_cmd_t *zc)
5083 {
5084 boolean_t recursive = zc->zc_cookie;
5085
5086 if (snapshot_namecheck(zc->zc_value, NULL, NULL) != 0)
5087 return (EINVAL);
5088
5089 return (dsl_dataset_user_release(zc->zc_name, zc->zc_value,
5090 zc->zc_string, recursive));
5091 }
5092
5093 /*
5094 * inputs:
5095 * zc_name name of filesystem
5096 *
5097 * outputs:
5098 * zc_nvlist_src{_size} nvlist of snapshot holds
5099 */
5100 static int
5101 zfs_ioc_get_holds(zfs_cmd_t *zc)
5102 {
5103 nvlist_t *nvp;
5104 int error;
5105
5106 if ((error = dsl_dataset_get_holds(zc->zc_name, &nvp)) == 0) {
5107 error = put_nvlist(zc, nvp);
5108 nvlist_free(nvp);
5109 }
5110
5111 return (error);
5112 }
5113
5114 /*
5115 * inputs:
5116 * zc_name name of new filesystem or snapshot
5117 * zc_value full name of old snapshot
5118 *
5119 * outputs:
5120 * zc_cookie space in bytes
5121 * zc_objset_type compressed space in bytes
5122 * zc_perm_action uncompressed space in bytes
5123 */
5124 static int
5125 zfs_ioc_space_written(zfs_cmd_t *zc)
5126 {
5127 int error;
5128 dsl_dataset_t *new, *old;
5129
5130 error = dsl_dataset_hold(zc->zc_name, FTAG, &new);
5131 if (error != 0)
5132 return (error);
5133 error = dsl_dataset_hold(zc->zc_value, FTAG, &old);
5134 if (error != 0) {
5135 dsl_dataset_rele(new, FTAG);
5136 return (error);
5137 }
5138
5139 error = dsl_dataset_space_written(old, new, &zc->zc_cookie,
5140 &zc->zc_objset_type, &zc->zc_perm_action);
5141 dsl_dataset_rele(old, FTAG);
5142 dsl_dataset_rele(new, FTAG);
5143 return (error);
5144 }
5145 /*
5146 * innvl: {
5147 * "firstsnap" -> snapshot name
5148 * }
5149 *
5150 * outnvl: {
5151 * "used" -> space in bytes
5152 * "compressed" -> compressed space in bytes
5153 * "uncompressed" -> uncompressed space in bytes
5154 * }
5155 */
5156 static int
5157 zfs_ioc_space_snaps(const char *lastsnap, nvlist_t *innvl, nvlist_t *outnvl)
5158 {
5159 int error;
5160 dsl_dataset_t *new, *old;
5161 char *firstsnap;
5162 uint64_t used, comp, uncomp;
5163
5164 if (nvlist_lookup_string(innvl, "firstsnap", &firstsnap) != 0)
5165 return (EINVAL);
5166
5167 error = dsl_dataset_hold(lastsnap, FTAG, &new);
5168 if (error != 0)
5169 return (error);
5170 error = dsl_dataset_hold(firstsnap, FTAG, &old);
5171 if (error != 0) {
5172 dsl_dataset_rele(new, FTAG);
5173 return (error);
5174 }
5175
5176 error = dsl_dataset_space_wouldfree(old, new, &used, &comp, &uncomp);
5177 dsl_dataset_rele(old, FTAG);
5178 dsl_dataset_rele(new, FTAG);
5179 fnvlist_add_uint64(outnvl, "used", used);
5180 fnvlist_add_uint64(outnvl, "compressed", comp);
5181 fnvlist_add_uint64(outnvl, "uncompressed", uncomp);
5182 return (error);
5183 }
5184
5185 /*
5186 * innvl: {
5187 * "fd" -> file descriptor to write stream to (int32)
5188 * (optional) "fromsnap" -> full snap name to send an incremental from
5189 * }
5190 *
5191 * outnvl is unused
5192 */
5193 /* ARGSUSED */
5194 static int
5195 zfs_ioc_send_new(const char *snapname, nvlist_t *innvl, nvlist_t *outnvl)
5196 {
5197 objset_t *fromsnap = NULL;
5198 objset_t *tosnap;
5199 int error;
5200 offset_t off;
5201 char *fromname;
5202 int fd;
5203
5204 error = nvlist_lookup_int32(innvl, "fd", &fd);
5205 if (error != 0)
5206 return (EINVAL);
5207
5208 error = dmu_objset_hold(snapname, FTAG, &tosnap);
5209 if (error)
5210 return (error);
5211
5212 error = nvlist_lookup_string(innvl, "fromsnap", &fromname);
5213 if (error == 0) {
5214 error = dmu_objset_hold(fromname, FTAG, &fromsnap);
5215 if (error) {
5216 dmu_objset_rele(tosnap, FTAG);
5217 return (error);
5218 }
5219 }
5220
5221 file_t *fp = getf(fd);
5222 if (fp == NULL) {
5223 dmu_objset_rele(tosnap, FTAG);
5224 if (fromsnap != NULL)
5225 dmu_objset_rele(fromsnap, FTAG);
5226 return (EBADF);
5227 }
5228
5229 off = fp->f_offset;
5230 error = dmu_send(tosnap, fromsnap, fd, fp->f_vnode, &off);
5231
5232 if (VOP_SEEK(fp->f_vnode, fp->f_offset, &off, NULL) == 0)
5233 fp->f_offset = off;
5234 releasef(fd);
5235 if (fromsnap != NULL)
5236 dmu_objset_rele(fromsnap, FTAG);
5237 dmu_objset_rele(tosnap, FTAG);
5238 return (error);
5239 }
5240
5241 /*
5242 * Determine approximately how large a zfs send stream will be -- the number
5243 * of bytes that will be written to the fd supplied to zfs_ioc_send_new().
5244 *
5245 * innvl: {
5246 * (optional) "fromsnap" -> full snap name to send an incremental from
5247 * }
5248 *
5249 * outnvl: {
5250 * "space" -> bytes of space (uint64)
5251 * }
5252 */
5253 static int
5254 zfs_ioc_send_space(const char *snapname, nvlist_t *innvl, nvlist_t *outnvl)
5255 {
5256 objset_t *fromsnap = NULL;
5257 objset_t *tosnap;
5258 int error;
5259 char *fromname;
5260 uint64_t space;
5261
5262 error = dmu_objset_hold(snapname, FTAG, &tosnap);
5263 if (error)
5264 return (error);
5265
5266 error = nvlist_lookup_string(innvl, "fromsnap", &fromname);
5267 if (error == 0) {
5268 error = dmu_objset_hold(fromname, FTAG, &fromsnap);
5269 if (error) {
5270 dmu_objset_rele(tosnap, FTAG);
5271 return (error);
5272 }
5273 }
5274
5275 error = dmu_send_estimate(tosnap, fromsnap, &space);
5276 fnvlist_add_uint64(outnvl, "space", space);
5277
5278 if (fromsnap != NULL)
5279 dmu_objset_rele(fromsnap, FTAG);
5280 dmu_objset_rele(tosnap, FTAG);
5281 return (error);
5282 }
5283
5284
5285 static zfs_ioc_vec_t zfs_ioc_vec[ZFS_IOC_LAST - ZFS_IOC_FIRST];
5286
5287 static void
5288 zfs_ioctl_register_legacy(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func,
5289 zfs_secpolicy_func_t *secpolicy, zfs_ioc_namecheck_t namecheck,
5290 boolean_t log_history, zfs_ioc_poolcheck_t pool_check)
5291 {
5292 zfs_ioc_vec_t *vec = &zfs_ioc_vec[ioc - ZFS_IOC_FIRST];
5293
5294 ASSERT3U(ioc, >=, ZFS_IOC_FIRST);
5295 ASSERT3U(ioc, <, ZFS_IOC_LAST);
5296 ASSERT3P(vec->zvec_legacy_func, ==, NULL);
5297 ASSERT3P(vec->zvec_func, ==, NULL);
5298
5299 vec->zvec_legacy_func = func;
5300 vec->zvec_secpolicy = secpolicy;
5301 vec->zvec_namecheck = namecheck;
5302 vec->zvec_allow_log = log_history;
5303 vec->zvec_pool_check = pool_check;
5304 }
5305
5306 /*
5307 * See the block comment at the beginning of this file for details on
5308 * each argument to this function.
5309 */
5310 static void
5311 zfs_ioctl_register(const char *name, zfs_ioc_t ioc, zfs_ioc_func_t *func,
5312 zfs_secpolicy_func_t *secpolicy, zfs_ioc_namecheck_t namecheck,
5313 zfs_ioc_poolcheck_t pool_check, boolean_t smush_outnvlist,
5314 boolean_t allow_log)
5315 {
5316 zfs_ioc_vec_t *vec = &zfs_ioc_vec[ioc - ZFS_IOC_FIRST];
5317
5318 ASSERT3U(ioc, >=, ZFS_IOC_FIRST);
5319 ASSERT3U(ioc, <, ZFS_IOC_LAST);
5320 ASSERT3P(vec->zvec_legacy_func, ==, NULL);
5321 ASSERT3P(vec->zvec_func, ==, NULL);
5322
5323 /* if we are logging, the name must be valid */
5324 ASSERT(!allow_log || namecheck != NO_NAME);
5325
5326 vec->zvec_name = name;
5327 vec->zvec_func = func;
5328 vec->zvec_secpolicy = secpolicy;
5329 vec->zvec_namecheck = namecheck;
5330 vec->zvec_pool_check = pool_check;
5331 vec->zvec_smush_outnvlist = smush_outnvlist;
5332 vec->zvec_allow_log = allow_log;
5333 }
5334
5335 static void
5336 zfs_ioctl_register_pool(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func,
5337 zfs_secpolicy_func_t *secpolicy, boolean_t log_history,
5338 zfs_ioc_poolcheck_t pool_check)
5339 {
5340 zfs_ioctl_register_legacy(ioc, func, secpolicy,
5341 POOL_NAME, log_history, pool_check);
5342 }
5343
5344 static void
5345 zfs_ioctl_register_dataset_nolog(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func,
5346 zfs_secpolicy_func_t *secpolicy, zfs_ioc_poolcheck_t pool_check)
5347 {
5348 zfs_ioctl_register_legacy(ioc, func, secpolicy,
5349 DATASET_NAME, B_FALSE, pool_check);
5350 }
5351
5352 static void
5353 zfs_ioctl_register_pool_modify(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func)
5354 {
5355 zfs_ioctl_register_legacy(ioc, func, zfs_secpolicy_config,
5356 POOL_NAME, B_TRUE, POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY);
5357 }
5358
5359 static void
5360 zfs_ioctl_register_pool_meta(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func,
5361 zfs_secpolicy_func_t *secpolicy)
5362 {
5363 zfs_ioctl_register_legacy(ioc, func, secpolicy,
5364 NO_NAME, B_FALSE, POOL_CHECK_NONE);
5365 }
5366
5367 static void
5368 zfs_ioctl_register_dataset_read_secpolicy(zfs_ioc_t ioc,
5369 zfs_ioc_legacy_func_t *func, zfs_secpolicy_func_t *secpolicy)
5370 {
5371 zfs_ioctl_register_legacy(ioc, func, secpolicy,
5372 DATASET_NAME, B_FALSE, POOL_CHECK_SUSPENDED);
5373 }
5374
5375 static void
5376 zfs_ioctl_register_dataset_read(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func)
5377 {
5378 zfs_ioctl_register_dataset_read_secpolicy(ioc, func,
5379 zfs_secpolicy_read);
5380 }
5381
5382 static void
5383 zfs_ioctl_register_dataset_modify(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func,
5384 zfs_secpolicy_func_t *secpolicy)
5385 {
5386 zfs_ioctl_register_legacy(ioc, func, secpolicy,
5387 DATASET_NAME, B_TRUE, POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY);
5388 }
5389
5390 static void
5391 zfs_ioctl_init(void)
5392 {
5393 zfs_ioctl_register("snapshot", ZFS_IOC_SNAPSHOT,
5394 zfs_ioc_snapshot, zfs_secpolicy_snapshot, POOL_NAME,
5395 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE);
5396
5397 zfs_ioctl_register("log_history", ZFS_IOC_LOG_HISTORY,
5398 zfs_ioc_log_history, zfs_secpolicy_log_history, NO_NAME,
5399 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_FALSE, B_FALSE);
5400
5401 zfs_ioctl_register("space_snaps", ZFS_IOC_SPACE_SNAPS,
5402 zfs_ioc_space_snaps, zfs_secpolicy_read, DATASET_NAME,
5403 POOL_CHECK_SUSPENDED, B_FALSE, B_FALSE);
5404
5405 zfs_ioctl_register("send", ZFS_IOC_SEND_NEW,
5406 zfs_ioc_send_new, zfs_secpolicy_send_new, DATASET_NAME,
5407 POOL_CHECK_SUSPENDED, B_FALSE, B_FALSE);
5408
5409 zfs_ioctl_register("send_space", ZFS_IOC_SEND_SPACE,
5410 zfs_ioc_send_space, zfs_secpolicy_read, DATASET_NAME,
5411 POOL_CHECK_SUSPENDED, B_FALSE, B_FALSE);
5412
5413 zfs_ioctl_register("create", ZFS_IOC_CREATE,
5414 zfs_ioc_create, zfs_secpolicy_create_clone, DATASET_NAME,
5415 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE);
5416
5417 zfs_ioctl_register("clone", ZFS_IOC_CLONE,
5418 zfs_ioc_clone, zfs_secpolicy_create_clone, DATASET_NAME,
5419 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE);
5420
5421 zfs_ioctl_register("destroy_snaps", ZFS_IOC_DESTROY_SNAPS,
5422 zfs_ioc_destroy_snaps, zfs_secpolicy_destroy_snaps, POOL_NAME,
5423 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE);
5424
5425 /* IOCTLS that use the legacy function signature */
5426
5427 zfs_ioctl_register_legacy(ZFS_IOC_POOL_FREEZE, zfs_ioc_pool_freeze,
5428 zfs_secpolicy_config, NO_NAME, B_FALSE, POOL_CHECK_READONLY);
5429
5430 zfs_ioctl_register_pool(ZFS_IOC_POOL_CREATE, zfs_ioc_pool_create,
5431 zfs_secpolicy_config, B_TRUE, POOL_CHECK_NONE);
5432 zfs_ioctl_register_pool_modify(ZFS_IOC_POOL_SCAN,
5433 zfs_ioc_pool_scan);
5434 zfs_ioctl_register_pool_modify(ZFS_IOC_POOL_UPGRADE,
5435 zfs_ioc_pool_upgrade);
5436 zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_ADD,
5437 zfs_ioc_vdev_add);
5438 zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_REMOVE,
5439 zfs_ioc_vdev_remove);
5440 zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_SET_STATE,
5441 zfs_ioc_vdev_set_state);
5442 zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_ATTACH,
5443 zfs_ioc_vdev_attach);
5444 zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_DETACH,
5445 zfs_ioc_vdev_detach);
5446 zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_SETPATH,
5447 zfs_ioc_vdev_setpath);
5448 zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_SETFRU,
5449 zfs_ioc_vdev_setfru);
5450 zfs_ioctl_register_pool_modify(ZFS_IOC_POOL_SET_PROPS,
5451 zfs_ioc_pool_set_props);
5452 zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_SPLIT,
5453 zfs_ioc_vdev_split);
5454 zfs_ioctl_register_pool_modify(ZFS_IOC_POOL_REGUID,
5455 zfs_ioc_pool_reguid);
5456
5457 zfs_ioctl_register_pool_meta(ZFS_IOC_POOL_CONFIGS,
5458 zfs_ioc_pool_configs, zfs_secpolicy_none);
5459 zfs_ioctl_register_pool_meta(ZFS_IOC_POOL_TRYIMPORT,
5460 zfs_ioc_pool_tryimport, zfs_secpolicy_config);
5461 zfs_ioctl_register_pool_meta(ZFS_IOC_INJECT_FAULT,
5462 zfs_ioc_inject_fault, zfs_secpolicy_inject);
5463 zfs_ioctl_register_pool_meta(ZFS_IOC_CLEAR_FAULT,
5464 zfs_ioc_clear_fault, zfs_secpolicy_inject);
5465 zfs_ioctl_register_pool_meta(ZFS_IOC_INJECT_LIST_NEXT,
5466 zfs_ioc_inject_list_next, zfs_secpolicy_inject);
5467
5468 /*
5469 * pool destroy, and export don't log the history as part of
5470 * zfsdev_ioctl, but rather zfs_ioc_pool_export
5471 * does the logging of those commands.
5472 */
5473 zfs_ioctl_register_pool(ZFS_IOC_POOL_DESTROY, zfs_ioc_pool_destroy,
5474 zfs_secpolicy_config, B_FALSE, POOL_CHECK_NONE);
5475 zfs_ioctl_register_pool(ZFS_IOC_POOL_EXPORT, zfs_ioc_pool_export,
5476 zfs_secpolicy_config, B_FALSE, POOL_CHECK_NONE);
5477
5478 zfs_ioctl_register_pool(ZFS_IOC_POOL_STATS, zfs_ioc_pool_stats,
5479 zfs_secpolicy_read, B_FALSE, POOL_CHECK_NONE);
5480 zfs_ioctl_register_pool(ZFS_IOC_POOL_GET_PROPS, zfs_ioc_pool_get_props,
5481 zfs_secpolicy_read, B_FALSE, POOL_CHECK_NONE);
5482
5483 zfs_ioctl_register_pool(ZFS_IOC_ERROR_LOG, zfs_ioc_error_log,
5484 zfs_secpolicy_inject, B_FALSE, POOL_CHECK_SUSPENDED);
5485 zfs_ioctl_register_pool(ZFS_IOC_DSOBJ_TO_DSNAME,
5486 zfs_ioc_dsobj_to_dsname,
5487 zfs_secpolicy_diff, B_FALSE, POOL_CHECK_SUSPENDED);
5488 zfs_ioctl_register_pool(ZFS_IOC_POOL_GET_HISTORY,
5489 zfs_ioc_pool_get_history,
5490 zfs_secpolicy_config, B_FALSE, POOL_CHECK_SUSPENDED);
5491
5492 zfs_ioctl_register_pool(ZFS_IOC_POOL_IMPORT, zfs_ioc_pool_import,
5493 zfs_secpolicy_config, B_TRUE, POOL_CHECK_NONE);
5494
5495 zfs_ioctl_register_pool(ZFS_IOC_CLEAR, zfs_ioc_clear,
5496 zfs_secpolicy_config, B_TRUE, POOL_CHECK_SUSPENDED);
5497 zfs_ioctl_register_pool(ZFS_IOC_POOL_REOPEN, zfs_ioc_pool_reopen,
5498 zfs_secpolicy_config, B_TRUE, POOL_CHECK_SUSPENDED);
5499
5500 zfs_ioctl_register_dataset_read(ZFS_IOC_SPACE_WRITTEN,
5501 zfs_ioc_space_written);
5502 zfs_ioctl_register_dataset_read(ZFS_IOC_GET_HOLDS,
5503 zfs_ioc_get_holds);
5504 zfs_ioctl_register_dataset_read(ZFS_IOC_OBJSET_RECVD_PROPS,
5505 zfs_ioc_objset_recvd_props);
5506 zfs_ioctl_register_dataset_read(ZFS_IOC_NEXT_OBJ,
5507 zfs_ioc_next_obj);
5508 zfs_ioctl_register_dataset_read(ZFS_IOC_GET_FSACL,
5509 zfs_ioc_get_fsacl);
5510 zfs_ioctl_register_dataset_read(ZFS_IOC_OBJSET_STATS,
5511 zfs_ioc_objset_stats);
5512 zfs_ioctl_register_dataset_read(ZFS_IOC_OBJSET_ZPLPROPS,
5513 zfs_ioc_objset_zplprops);
5514 zfs_ioctl_register_dataset_read(ZFS_IOC_DATASET_LIST_NEXT,
5515 zfs_ioc_dataset_list_next);
5516 zfs_ioctl_register_dataset_read(ZFS_IOC_SNAPSHOT_LIST_NEXT,
5517 zfs_ioc_snapshot_list_next);
5518 zfs_ioctl_register_dataset_read(ZFS_IOC_SEND_PROGRESS,
5519 zfs_ioc_send_progress);
5520
5521 zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_DIFF,
5522 zfs_ioc_diff, zfs_secpolicy_diff);
5523 zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_OBJ_TO_STATS,
5524 zfs_ioc_obj_to_stats, zfs_secpolicy_diff);
5525 zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_OBJ_TO_PATH,
5526 zfs_ioc_obj_to_path, zfs_secpolicy_diff);
5527 zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_USERSPACE_ONE,
5528 zfs_ioc_userspace_one, zfs_secpolicy_userspace_one);
5529 zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_USERSPACE_MANY,
5530 zfs_ioc_userspace_many, zfs_secpolicy_userspace_many);
5531 zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_SEND,
5532 zfs_ioc_send, zfs_secpolicy_send);
5533
5534 zfs_ioctl_register_dataset_modify(ZFS_IOC_SET_PROP, zfs_ioc_set_prop,
5535 zfs_secpolicy_none);
5536 zfs_ioctl_register_dataset_modify(ZFS_IOC_DESTROY, zfs_ioc_destroy,
5537 zfs_secpolicy_destroy);
5538 zfs_ioctl_register_dataset_modify(ZFS_IOC_ROLLBACK, zfs_ioc_rollback,
5539 zfs_secpolicy_rollback);
5540 zfs_ioctl_register_dataset_modify(ZFS_IOC_RENAME, zfs_ioc_rename,
5541 zfs_secpolicy_rename);
5542 zfs_ioctl_register_dataset_modify(ZFS_IOC_RECV, zfs_ioc_recv,
5543 zfs_secpolicy_recv);
5544 zfs_ioctl_register_dataset_modify(ZFS_IOC_PROMOTE, zfs_ioc_promote,
5545 zfs_secpolicy_promote);
5546 zfs_ioctl_register_dataset_modify(ZFS_IOC_HOLD, zfs_ioc_hold,
5547 zfs_secpolicy_hold);
5548 zfs_ioctl_register_dataset_modify(ZFS_IOC_RELEASE, zfs_ioc_release,
5549 zfs_secpolicy_release);
5550 zfs_ioctl_register_dataset_modify(ZFS_IOC_INHERIT_PROP,
5551 zfs_ioc_inherit_prop, zfs_secpolicy_inherit_prop);
5552 zfs_ioctl_register_dataset_modify(ZFS_IOC_SET_FSACL, zfs_ioc_set_fsacl,
5553 zfs_secpolicy_set_fsacl);
5554
5555 zfs_ioctl_register_dataset_nolog(ZFS_IOC_SHARE, zfs_ioc_share,
5556 zfs_secpolicy_share, POOL_CHECK_NONE);
5557 zfs_ioctl_register_dataset_nolog(ZFS_IOC_SMB_ACL, zfs_ioc_smb_acl,
5558 zfs_secpolicy_smb_acl, POOL_CHECK_NONE);
5559 zfs_ioctl_register_dataset_nolog(ZFS_IOC_USERSPACE_UPGRADE,
5560 zfs_ioc_userspace_upgrade, zfs_secpolicy_userspace_upgrade,
5561 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY);
5562 zfs_ioctl_register_dataset_nolog(ZFS_IOC_TMP_SNAPSHOT,
5563 zfs_ioc_tmp_snapshot, zfs_secpolicy_tmp_snapshot,
5564 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY);
5565 }
5566
5567 int
5568 pool_status_check(const char *name, zfs_ioc_namecheck_t type,
5569 zfs_ioc_poolcheck_t check)
5570 {
5571 spa_t *spa;
5572 int error;
5573
5574 ASSERT(type == POOL_NAME || type == DATASET_NAME);
5575
5576 if (check & POOL_CHECK_NONE)
5577 return (0);
5578
5579 error = spa_open(name, &spa, FTAG);
5580 if (error == 0) {
5581 if ((check & POOL_CHECK_SUSPENDED) && spa_suspended(spa))
5582 error = EAGAIN;
5583 else if ((check & POOL_CHECK_READONLY) && !spa_writeable(spa))
5584 error = EROFS;
5585 spa_close(spa, FTAG);
5586 }
5587 return (error);
5588 }
5589
5590 /*
5591 * Find a free minor number.
5592 */
5593 minor_t
5594 zfsdev_minor_alloc(void)
5595 {
5596 static minor_t last_minor;
5597 minor_t m;
5598
5599 ASSERT(MUTEX_HELD(&zfsdev_state_lock));
5600
5601 for (m = last_minor + 1; m != last_minor; m++) {
5602 if (m > ZFSDEV_MAX_MINOR)
5603 m = 1;
5604 if (ddi_get_soft_state(zfsdev_state, m) == NULL) {
5605 last_minor = m;
5606 return (m);
5607 }
5608 }
5609
5610 return (0);
5611 }
5612
5613 static int
5614 zfs_ctldev_init(dev_t *devp)
5615 {
5616 minor_t minor;
5617 zfs_soft_state_t *zs;
5618
5619 ASSERT(MUTEX_HELD(&zfsdev_state_lock));
5620 ASSERT(getminor(*devp) == 0);
5621
5622 minor = zfsdev_minor_alloc();
5623 if (minor == 0)
5624 return (ENXIO);
5625
5626 if (ddi_soft_state_zalloc(zfsdev_state, minor) != DDI_SUCCESS)
5627 return (EAGAIN);
5628
5629 *devp = makedevice(getemajor(*devp), minor);
5630
5631 zs = ddi_get_soft_state(zfsdev_state, minor);
5632 zs->zss_type = ZSST_CTLDEV;
5633 zfs_onexit_init((zfs_onexit_t **)&zs->zss_data);
5634
5635 return (0);
5636 }
5637
5638 static void
5639 zfs_ctldev_destroy(zfs_onexit_t *zo, minor_t minor)
5640 {
5641 ASSERT(MUTEX_HELD(&zfsdev_state_lock));
5642
5643 zfs_onexit_destroy(zo);
5644 ddi_soft_state_free(zfsdev_state, minor);
5645 }
5646
5647 void *
5648 zfsdev_get_soft_state(minor_t minor, enum zfs_soft_state_type which)
5649 {
5650 zfs_soft_state_t *zp;
5651
5652 zp = ddi_get_soft_state(zfsdev_state, minor);
5653 if (zp == NULL || zp->zss_type != which)
5654 return (NULL);
5655
5656 return (zp->zss_data);
5657 }
5658
5659 static int
5660 zfsdev_open(dev_t *devp, int flag, int otyp, cred_t *cr)
5661 {
5662 int error = 0;
5663
5664 if (getminor(*devp) != 0)
5665 return (zvol_open(devp, flag, otyp, cr));
5666
5667 /* This is the control device. Allocate a new minor if requested. */
5668 if (flag & FEXCL) {
5669 mutex_enter(&zfsdev_state_lock);
5670 error = zfs_ctldev_init(devp);
5671 mutex_exit(&zfsdev_state_lock);
5672 }
5673
5674 return (error);
5675 }
5676
5677 static int
5678 zfsdev_close(dev_t dev, int flag, int otyp, cred_t *cr)
5679 {
5680 zfs_onexit_t *zo;
5681 minor_t minor = getminor(dev);
5682
5683 if (minor == 0)
5684 return (0);
5685
5686 mutex_enter(&zfsdev_state_lock);
5687 zo = zfsdev_get_soft_state(minor, ZSST_CTLDEV);
5688 if (zo == NULL) {
5689 mutex_exit(&zfsdev_state_lock);
5690 return (zvol_close(dev, flag, otyp, cr));
5691 }
5692 zfs_ctldev_destroy(zo, minor);
5693 mutex_exit(&zfsdev_state_lock);
5694
5695 return (0);
5696 }
5697
5698 static int
5699 zfsdev_ioctl(dev_t dev, int cmd, intptr_t arg, int flag, cred_t *cr, int *rvalp)
5700 {
5701 zfs_cmd_t *zc;
5702 uint_t vecnum;
5703 int error, rc, len;
5704 minor_t minor = getminor(dev);
5705 const zfs_ioc_vec_t *vec;
5706 char *saved_poolname = NULL;
5707 nvlist_t *innvl = NULL;
5708
5709 if (minor != 0 &&
5710 zfsdev_get_soft_state(minor, ZSST_CTLDEV) == NULL)
5711 return (zvol_ioctl(dev, cmd, arg, flag, cr, rvalp));
5712
5713 vecnum = cmd - ZFS_IOC_FIRST;
5714 ASSERT3U(getmajor(dev), ==, ddi_driver_major(zfs_dip));
5715
5716 if (vecnum >= sizeof (zfs_ioc_vec) / sizeof (zfs_ioc_vec[0]))
5717 return (EINVAL);
5718 vec = &zfs_ioc_vec[vecnum];
5719
5720 zc = kmem_zalloc(sizeof (zfs_cmd_t), KM_SLEEP);
5721
5722 error = ddi_copyin((void *)arg, zc, sizeof (zfs_cmd_t), flag);
5723 if (error != 0) {
5724 error = EFAULT;
5725 goto out;
5726 }
5727
5728 zc->zc_iflags = flag & FKIOCTL;
5729 if (zc->zc_nvlist_src_size != 0) {
5730 error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
5731 zc->zc_iflags, &innvl);
5732 if (error != 0)
5733 goto out;
5734 }
5735
5736 /*
5737 * Ensure that all pool/dataset names are valid before we pass down to
5738 * the lower layers.
5739 */
5740 zc->zc_name[sizeof (zc->zc_name) - 1] = '\0';
5741 switch (vec->zvec_namecheck) {
5742 case POOL_NAME:
5743 if (pool_namecheck(zc->zc_name, NULL, NULL) != 0)
5744 error = EINVAL;
5745 else
5746 error = pool_status_check(zc->zc_name,
5747 vec->zvec_namecheck, vec->zvec_pool_check);
5748 break;
5749
5750 case DATASET_NAME:
5751 if (dataset_namecheck(zc->zc_name, NULL, NULL) != 0)
5752 error = EINVAL;
5753 else
5754 error = pool_status_check(zc->zc_name,
5755 vec->zvec_namecheck, vec->zvec_pool_check);
5756 break;
5757
5758 case NO_NAME:
5759 break;
5760 }
5761
5762
5763 if (error == 0 && !(flag & FKIOCTL))
5764 error = vec->zvec_secpolicy(zc, innvl, cr);
5765
5766 if (error != 0)
5767 goto out;
5768
5769 /* legacy ioctls can modify zc_name */
5770 len = strcspn(zc->zc_name, "/@") + 1;
5771 saved_poolname = kmem_alloc(len, KM_SLEEP);
5772 (void) strlcpy(saved_poolname, zc->zc_name, len);
5773
5774 if (vec->zvec_func != NULL) {
5775 nvlist_t *outnvl;
5776 int puterror = 0;
5777 spa_t *spa;
5778 nvlist_t *lognv = NULL;
5779
5780 ASSERT(vec->zvec_legacy_func == NULL);
5781
5782 /*
5783 * Add the innvl to the lognv before calling the func,
5784 * in case the func changes the innvl.
5785 */
5786 if (vec->zvec_allow_log) {
5787 lognv = fnvlist_alloc();
5788 fnvlist_add_string(lognv, ZPOOL_HIST_IOCTL,
5789 vec->zvec_name);
5790 if (!nvlist_empty(innvl)) {
5791 fnvlist_add_nvlist(lognv, ZPOOL_HIST_INPUT_NVL,
5792 innvl);
5793 }
5794 }
5795
5796 outnvl = fnvlist_alloc();
5797 error = vec->zvec_func(zc->zc_name, innvl, outnvl);
5798
5799 if (error == 0 && vec->zvec_allow_log &&
5800 spa_open(zc->zc_name, &spa, FTAG) == 0) {
5801 if (!nvlist_empty(outnvl)) {
5802 fnvlist_add_nvlist(lognv, ZPOOL_HIST_OUTPUT_NVL,
5803 outnvl);
5804 }
5805 (void) spa_history_log_nvl(spa, lognv);
5806 spa_close(spa, FTAG);
5807 }
5808 fnvlist_free(lognv);
5809
5810 if (!nvlist_empty(outnvl) || zc->zc_nvlist_dst_size != 0) {
5811 int smusherror = 0;
5812 if (vec->zvec_smush_outnvlist) {
5813 smusherror = nvlist_smush(outnvl,
5814 zc->zc_nvlist_dst_size);
5815 }
5816 if (smusherror == 0)
5817 puterror = put_nvlist(zc, outnvl);
5818 }
5819
5820 if (puterror != 0)
5821 error = puterror;
5822
5823 nvlist_free(outnvl);
5824 } else {
5825 error = vec->zvec_legacy_func(zc);
5826 }
5827
5828 out:
5829 nvlist_free(innvl);
5830 rc = ddi_copyout(zc, (void *)arg, sizeof (zfs_cmd_t), flag);
5831 if (error == 0 && rc != 0)
5832 error = EFAULT;
5833 if (error == 0 && vec->zvec_allow_log) {
5834 char *s = tsd_get(zfs_allow_log_key);
5835 if (s != NULL)
5836 strfree(s);
5837 (void) tsd_set(zfs_allow_log_key, saved_poolname);
5838 } else {
5839 if (saved_poolname != NULL)
5840 strfree(saved_poolname);
5841 }
5842
5843 kmem_free(zc, sizeof (zfs_cmd_t));
5844 return (error);
5845 }
5846
5847 static int
5848 zfs_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
5849 {
5850 if (cmd != DDI_ATTACH)
5851 return (DDI_FAILURE);
5852
5853 if (ddi_create_minor_node(dip, "zfs", S_IFCHR, 0,
5854 DDI_PSEUDO, 0) == DDI_FAILURE)
5855 return (DDI_FAILURE);
5856
5857 zfs_dip = dip;
5858
5859 ddi_report_dev(dip);
5860
5861 return (DDI_SUCCESS);
5862 }
5863
5864 static int
5865 zfs_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
5866 {
5867 if (spa_busy() || zfs_busy() || zvol_busy())
5868 return (DDI_FAILURE);
5869
5870 if (cmd != DDI_DETACH)
5871 return (DDI_FAILURE);
5872
5873 zfs_dip = NULL;
5874
5875 ddi_prop_remove_all(dip);
5876 ddi_remove_minor_node(dip, NULL);
5877
5878 return (DDI_SUCCESS);
5879 }
5880
5881 /*ARGSUSED*/
5882 static int
5883 zfs_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
5884 {
5885 switch (infocmd) {
5886 case DDI_INFO_DEVT2DEVINFO:
5887 *result = zfs_dip;
5888 return (DDI_SUCCESS);
5889
5890 case DDI_INFO_DEVT2INSTANCE:
5891 *result = (void *)0;
5892 return (DDI_SUCCESS);
5893 }
5894
5895 return (DDI_FAILURE);
5896 }
5897
5898 /*
5899 * OK, so this is a little weird.
5900 *
5901 * /dev/zfs is the control node, i.e. minor 0.
5902 * /dev/zvol/[r]dsk/pool/dataset are the zvols, minor > 0.
5903 *
5904 * /dev/zfs has basically nothing to do except serve up ioctls,
5905 * so most of the standard driver entry points are in zvol.c.
5906 */
5907 static struct cb_ops zfs_cb_ops = {
5908 zfsdev_open, /* open */
5909 zfsdev_close, /* close */
5910 zvol_strategy, /* strategy */
5911 nodev, /* print */
5912 zvol_dump, /* dump */
5913 zvol_read, /* read */
5914 zvol_write, /* write */
5915 zfsdev_ioctl, /* ioctl */
5916 nodev, /* devmap */
5917 nodev, /* mmap */
5918 nodev, /* segmap */
5919 nochpoll, /* poll */
5920 ddi_prop_op, /* prop_op */
5921 NULL, /* streamtab */
5922 D_NEW | D_MP | D_64BIT, /* Driver compatibility flag */
5923 CB_REV, /* version */
5924 nodev, /* async read */
5925 nodev, /* async write */
5926 };
5927
5928 static struct dev_ops zfs_dev_ops = {
5929 DEVO_REV, /* version */
5930 0, /* refcnt */
5931 zfs_info, /* info */
5932 nulldev, /* identify */
5933 nulldev, /* probe */
5934 zfs_attach, /* attach */
5935 zfs_detach, /* detach */
5936 nodev, /* reset */
5937 &zfs_cb_ops, /* driver operations */
5938 NULL, /* no bus operations */
5939 NULL, /* power */
5940 ddi_quiesce_not_needed, /* quiesce */
5941 };
5942
5943 static struct modldrv zfs_modldrv = {
5944 &mod_driverops,
5945 "ZFS storage pool",
5946 &zfs_dev_ops
5947 };
5948
5949 static struct modlinkage modlinkage = {
5950 MODREV_1,
5951 (void *)&zfs_modlfs,
5952 (void *)&zfs_modldrv,
5953 NULL
5954 };
5955
5956 static void
5957 zfs_allow_log_destroy(void *arg)
5958 {
5959 char *poolname = arg;
5960 strfree(poolname);
5961 }
5962
5963 int
5964 _init(void)
5965 {
5966 int error;
5967
5968 spa_init(FREAD | FWRITE);
5969 zfs_init();
5970 zvol_init();
5971 zfs_ioctl_init();
5972
5973 if ((error = mod_install(&modlinkage)) != 0) {
5974 zvol_fini();
5975 zfs_fini();
5976 spa_fini();
5977 return (error);
5978 }
5979
5980 tsd_create(&zfs_fsyncer_key, NULL);
5981 tsd_create(&rrw_tsd_key, rrw_tsd_destroy);
5982 tsd_create(&zfs_allow_log_key, zfs_allow_log_destroy);
5983
5984 error = ldi_ident_from_mod(&modlinkage, &zfs_li);
5985 ASSERT(error == 0);
5986 mutex_init(&zfs_share_lock, NULL, MUTEX_DEFAULT, NULL);
5987
5988 return (0);
5989 }
5990
5991 int
5992 _fini(void)
5993 {
5994 int error;
5995
5996 if (spa_busy() || zfs_busy() || zvol_busy() || zio_injection_enabled)
5997 return (EBUSY);
5998
5999 if ((error = mod_remove(&modlinkage)) != 0)
6000 return (error);
6001
6002 zvol_fini();
6003 zfs_fini();
6004 spa_fini();
6005 if (zfs_nfsshare_inited)
6006 (void) ddi_modclose(nfs_mod);
6007 if (zfs_smbshare_inited)
6008 (void) ddi_modclose(smbsrv_mod);
6009 if (zfs_nfsshare_inited || zfs_smbshare_inited)
6010 (void) ddi_modclose(sharefs_mod);
6011
6012 tsd_destroy(&zfs_fsyncer_key);
6013 ldi_ident_release(zfs_li);
6014 zfs_li = NULL;
6015 mutex_destroy(&zfs_share_lock);
6016
6017 return (error);
6018 }
6019
6020 int
6021 _info(struct modinfo *modinfop)
6022 {
6023 return (mod_info(&modlinkage, modinfop));
6024 }