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