1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
24 * Portions Copyright 2011 Martin Matuska
25 * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
26 * Copyright 2015, OmniTI Computer Consulting, Inc. All rights reserved.
27 * Copyright (c) 2014, Joyent, Inc. All rights reserved.
28 * Copyright (c) 2011, 2014 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 * Copyright (c) 2014, Nexenta Systems, Inc. All rights reserved.
32 */
33
34 /*
35 * ZFS ioctls.
36 *
37 * This file handles the ioctls to /dev/zfs, used for configuring ZFS storage
38 * pools and filesystems, e.g. with /sbin/zfs and /sbin/zpool.
39 *
40 * There are two ways that we handle ioctls: the legacy way where almost
41 * all of the logic is in the ioctl callback, and the new way where most
42 * of the marshalling is handled in the common entry point, zfsdev_ioctl().
43 *
44 * Non-legacy ioctls should be registered by calling
45 * zfs_ioctl_register() from zfs_ioctl_init(). The ioctl is invoked
46 * from userland by lzc_ioctl().
47 *
48 * The registration arguments are as follows:
49 *
50 * const char *name
51 * The name of the ioctl. This is used for history logging. If the
52 * ioctl returns successfully (the callback returns 0), and allow_log
53 * is true, then a history log entry will be recorded with the input &
54 * output nvlists. The log entry can be printed with "zpool history -i".
55 *
56 * zfs_ioc_t ioc
57 * The ioctl request number, which userland will pass to ioctl(2).
58 * The ioctl numbers can change from release to release, because
59 * the caller (libzfs) must be matched to the kernel.
60 *
61 * zfs_secpolicy_func_t *secpolicy
62 * This function will be called before the zfs_ioc_func_t, to
63 * determine if this operation is permitted. It should return EPERM
64 * on failure, and 0 on success. Checks include determining if the
65 * dataset is visible in this zone, and if the user has either all
66 * zfs privileges in the zone (SYS_MOUNT), or has been granted permission
67 * to do this operation on this dataset with "zfs allow".
68 *
69 * zfs_ioc_namecheck_t namecheck
70 * This specifies what to expect in the zfs_cmd_t:zc_name -- a pool
71 * name, a dataset name, or nothing. If the name is not well-formed,
72 * the ioctl will fail and the callback will not be called.
73 * Therefore, the callback can assume that the name is well-formed
74 * (e.g. is null-terminated, doesn't have more than one '@' character,
75 * doesn't have invalid characters).
76 *
77 * zfs_ioc_poolcheck_t pool_check
78 * This specifies requirements on the pool state. If the pool does
79 * not meet them (is suspended or is readonly), the ioctl will fail
80 * and the callback will not be called. If any checks are specified
81 * (i.e. it is not POOL_CHECK_NONE), namecheck must not be NO_NAME.
82 * Multiple checks can be or-ed together (e.g. POOL_CHECK_SUSPENDED |
83 * POOL_CHECK_READONLY).
84 *
85 * boolean_t smush_outnvlist
86 * If smush_outnvlist is true, then the output is presumed to be a
87 * list of errors, and it will be "smushed" down to fit into the
88 * caller's buffer, by removing some entries and replacing them with a
89 * single "N_MORE_ERRORS" entry indicating how many were removed. See
90 * nvlist_smush() for details. If smush_outnvlist is false, and the
91 * outnvlist does not fit into the userland-provided buffer, then the
92 * ioctl will fail with ENOMEM.
93 *
94 * zfs_ioc_func_t *func
95 * The callback function that will perform the operation.
96 *
97 * The callback should return 0 on success, or an error number on
98 * failure. If the function fails, the userland ioctl will return -1,
99 * and errno will be set to the callback's return value. The callback
100 * will be called with the following arguments:
101 *
102 * const char *name
103 * The name of the pool or dataset to operate on, from
104 * zfs_cmd_t:zc_name. The 'namecheck' argument specifies the
105 * expected type (pool, dataset, or none).
106 *
107 * nvlist_t *innvl
108 * The input nvlist, deserialized from zfs_cmd_t:zc_nvlist_src. Or
109 * NULL if no input nvlist was provided. Changes to this nvlist are
110 * ignored. If the input nvlist could not be deserialized, the
111 * ioctl will fail and the callback will not be called.
112 *
113 * nvlist_t *outnvl
114 * The output nvlist, initially empty. The callback can fill it in,
115 * and it will be returned to userland by serializing it into
116 * zfs_cmd_t:zc_nvlist_dst. If it is non-empty, and serialization
117 * fails (e.g. because the caller didn't supply a large enough
118 * buffer), then the overall ioctl will fail. See the
119 * 'smush_nvlist' argument above for additional behaviors.
120 *
121 * There are two typical uses of the output nvlist:
122 * - To return state, e.g. property values. In this case,
123 * smush_outnvlist should be false. If the buffer was not large
124 * enough, the caller will reallocate a larger buffer and try
125 * the ioctl again.
126 *
127 * - To return multiple errors from an ioctl which makes on-disk
128 * changes. In this case, smush_outnvlist should be true.
129 * Ioctls which make on-disk modifications should generally not
130 * use the outnvl if they succeed, because the caller can not
131 * distinguish between the operation failing, and
132 * deserialization failing.
133 */
134
135 #include <sys/types.h>
136 #include <sys/param.h>
137 #include <sys/errno.h>
138 #include <sys/uio.h>
139 #include <sys/buf.h>
140 #include <sys/modctl.h>
141 #include <sys/open.h>
142 #include <sys/file.h>
143 #include <sys/kmem.h>
144 #include <sys/conf.h>
145 #include <sys/cmn_err.h>
146 #include <sys/stat.h>
147 #include <sys/zfs_ioctl.h>
148 #include <sys/zfs_vfsops.h>
149 #include <sys/zfs_znode.h>
150 #include <sys/zap.h>
151 #include <sys/spa.h>
152 #include <sys/spa_impl.h>
153 #include <sys/vdev.h>
154 #include <sys/priv_impl.h>
155 #include <sys/dmu.h>
156 #include <sys/dsl_dir.h>
157 #include <sys/dsl_dataset.h>
158 #include <sys/dsl_prop.h>
159 #include <sys/dsl_deleg.h>
160 #include <sys/dmu_objset.h>
161 #include <sys/dmu_impl.h>
162 #include <sys/dmu_tx.h>
163 #include <sys/ddi.h>
164 #include <sys/sunddi.h>
165 #include <sys/sunldi.h>
166 #include <sys/policy.h>
167 #include <sys/zone.h>
168 #include <sys/nvpair.h>
169 #include <sys/pathname.h>
170 #include <sys/mount.h>
171 #include <sys/sdt.h>
172 #include <sys/fs/zfs.h>
173 #include <sys/zfs_ctldir.h>
174 #include <sys/zfs_dir.h>
175 #include <sys/zfs_onexit.h>
176 #include <sys/zvol.h>
177 #include <sys/dsl_scan.h>
178 #include <sharefs/share.h>
179 #include <sys/dmu_objset.h>
180 #include <sys/dmu_send.h>
181 #include <sys/dsl_destroy.h>
182 #include <sys/dsl_bookmark.h>
183 #include <sys/dsl_userhold.h>
184 #include <sys/zfeature.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 (error);
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_DEDUP:
3823 if (zfs_earlier_version(dsname, SPA_VERSION_DEDUP))
3824 return (SET_ERROR(ENOTSUP));
3825 break;
3826
3827 case ZFS_PROP_RECORDSIZE:
3828 /* Record sizes above 128k need the feature to be enabled */
3829 if (nvpair_value_uint64(pair, &intval) == 0 &&
3830 intval > SPA_OLD_MAXBLOCKSIZE) {
3831 spa_t *spa;
3832
3833 /*
3834 * If this is a bootable dataset then
3835 * the we don't allow large (>128K) blocks,
3836 * because GRUB doesn't support them.
3837 */
3838 if (zfs_is_bootfs(dsname) &&
3839 intval > SPA_OLD_MAXBLOCKSIZE) {
3840 return (SET_ERROR(EDOM));
3841 }
3842
3843 /*
3844 * We don't allow setting the property above 1MB,
3845 * unless the tunable has been changed.
3846 */
3847 if (intval > zfs_max_recordsize ||
3848 intval > SPA_MAXBLOCKSIZE)
3849 return (SET_ERROR(EDOM));
3850
3851 if ((err = spa_open(dsname, &spa, FTAG)) != 0)
3852 return (err);
3853
3854 if (!spa_feature_is_enabled(spa,
3855 SPA_FEATURE_LARGE_BLOCKS)) {
3856 spa_close(spa, FTAG);
3857 return (SET_ERROR(ENOTSUP));
3858 }
3859 spa_close(spa, FTAG);
3860 }
3861 break;
3862
3863 case ZFS_PROP_SHARESMB:
3864 if (zpl_earlier_version(dsname, ZPL_VERSION_FUID))
3865 return (SET_ERROR(ENOTSUP));
3866 break;
3867
3868 case ZFS_PROP_ACLINHERIT:
3869 if (nvpair_type(pair) == DATA_TYPE_UINT64 &&
3870 nvpair_value_uint64(pair, &intval) == 0) {
3871 if (intval == ZFS_ACL_PASSTHROUGH_X &&
3872 zfs_earlier_version(dsname,
3873 SPA_VERSION_PASSTHROUGH_X))
3874 return (SET_ERROR(ENOTSUP));
3875 }
3876 break;
3877 }
3878
3879 return (zfs_secpolicy_setprop(dsname, prop, pair, CRED()));
3880 }
3881
3882 /*
3883 * Checks for a race condition to make sure we don't increment a feature flag
3884 * multiple times.
3885 */
3886 static int
3887 zfs_prop_activate_feature_check(void *arg, dmu_tx_t *tx)
3888 {
3889 spa_t *spa = dmu_tx_pool(tx)->dp_spa;
3890 spa_feature_t *featurep = arg;
3891
3892 if (!spa_feature_is_active(spa, *featurep))
3893 return (0);
3894 else
3895 return (SET_ERROR(EBUSY));
3896 }
3897
3898 /*
3899 * The callback invoked on feature activation in the sync task caused by
3900 * zfs_prop_activate_feature.
3901 */
3902 static void
3903 zfs_prop_activate_feature_sync(void *arg, dmu_tx_t *tx)
3904 {
3905 spa_t *spa = dmu_tx_pool(tx)->dp_spa;
3906 spa_feature_t *featurep = arg;
3907
3908 spa_feature_incr(spa, *featurep, tx);
3909 }
3910
3911 /*
3912 * Activates a feature on a pool in response to a property setting. This
3913 * creates a new sync task which modifies the pool to reflect the feature
3914 * as being active.
3915 */
3916 static int
3917 zfs_prop_activate_feature(spa_t *spa, spa_feature_t feature)
3918 {
3919 int err;
3920
3921 /* EBUSY here indicates that the feature is already active */
3922 err = dsl_sync_task(spa_name(spa),
3923 zfs_prop_activate_feature_check, zfs_prop_activate_feature_sync,
3924 &feature, 2, ZFS_SPACE_CHECK_RESERVED);
3925
3926 if (err != 0 && err != EBUSY)
3927 return (err);
3928 else
3929 return (0);
3930 }
3931
3932 /*
3933 * Removes properties from the given props list that fail permission checks
3934 * needed to clear them and to restore them in case of a receive error. For each
3935 * property, make sure we have both set and inherit permissions.
3936 *
3937 * Returns the first error encountered if any permission checks fail. If the
3938 * caller provides a non-NULL errlist, it also gives the complete list of names
3939 * of all the properties that failed a permission check along with the
3940 * corresponding error numbers. The caller is responsible for freeing the
3941 * returned errlist.
3942 *
3943 * If every property checks out successfully, zero is returned and the list
3944 * pointed at by errlist is NULL.
3945 */
3946 static int
3947 zfs_check_clearable(char *dataset, nvlist_t *props, nvlist_t **errlist)
3948 {
3949 zfs_cmd_t *zc;
3950 nvpair_t *pair, *next_pair;
3951 nvlist_t *errors;
3952 int err, rv = 0;
3953
3954 if (props == NULL)
3955 return (0);
3956
3957 VERIFY(nvlist_alloc(&errors, NV_UNIQUE_NAME, KM_SLEEP) == 0);
3958
3959 zc = kmem_alloc(sizeof (zfs_cmd_t), KM_SLEEP);
3960 (void) strcpy(zc->zc_name, dataset);
3961 pair = nvlist_next_nvpair(props, NULL);
3962 while (pair != NULL) {
3963 next_pair = nvlist_next_nvpair(props, pair);
3964
3965 (void) strcpy(zc->zc_value, nvpair_name(pair));
3966 if ((err = zfs_check_settable(dataset, pair, CRED())) != 0 ||
3967 (err = zfs_secpolicy_inherit_prop(zc, NULL, CRED())) != 0) {
3968 VERIFY(nvlist_remove_nvpair(props, pair) == 0);
3969 VERIFY(nvlist_add_int32(errors,
3970 zc->zc_value, err) == 0);
3971 }
3972 pair = next_pair;
3973 }
3974 kmem_free(zc, sizeof (zfs_cmd_t));
3975
3976 if ((pair = nvlist_next_nvpair(errors, NULL)) == NULL) {
3977 nvlist_free(errors);
3978 errors = NULL;
3979 } else {
3980 VERIFY(nvpair_value_int32(pair, &rv) == 0);
3981 }
3982
3983 if (errlist == NULL)
3984 nvlist_free(errors);
3985 else
3986 *errlist = errors;
3987
3988 return (rv);
3989 }
3990
3991 static boolean_t
3992 propval_equals(nvpair_t *p1, nvpair_t *p2)
3993 {
3994 if (nvpair_type(p1) == DATA_TYPE_NVLIST) {
3995 /* dsl_prop_get_all_impl() format */
3996 nvlist_t *attrs;
3997 VERIFY(nvpair_value_nvlist(p1, &attrs) == 0);
3998 VERIFY(nvlist_lookup_nvpair(attrs, ZPROP_VALUE,
3999 &p1) == 0);
4000 }
4001
4002 if (nvpair_type(p2) == DATA_TYPE_NVLIST) {
4003 nvlist_t *attrs;
4004 VERIFY(nvpair_value_nvlist(p2, &attrs) == 0);
4005 VERIFY(nvlist_lookup_nvpair(attrs, ZPROP_VALUE,
4006 &p2) == 0);
4007 }
4008
4009 if (nvpair_type(p1) != nvpair_type(p2))
4010 return (B_FALSE);
4011
4012 if (nvpair_type(p1) == DATA_TYPE_STRING) {
4013 char *valstr1, *valstr2;
4014
4015 VERIFY(nvpair_value_string(p1, (char **)&valstr1) == 0);
4016 VERIFY(nvpair_value_string(p2, (char **)&valstr2) == 0);
4017 return (strcmp(valstr1, valstr2) == 0);
4018 } else {
4019 uint64_t intval1, intval2;
4020
4021 VERIFY(nvpair_value_uint64(p1, &intval1) == 0);
4022 VERIFY(nvpair_value_uint64(p2, &intval2) == 0);
4023 return (intval1 == intval2);
4024 }
4025 }
4026
4027 /*
4028 * Remove properties from props if they are not going to change (as determined
4029 * by comparison with origprops). Remove them from origprops as well, since we
4030 * do not need to clear or restore properties that won't change.
4031 */
4032 static void
4033 props_reduce(nvlist_t *props, nvlist_t *origprops)
4034 {
4035 nvpair_t *pair, *next_pair;
4036
4037 if (origprops == NULL)
4038 return; /* all props need to be received */
4039
4040 pair = nvlist_next_nvpair(props, NULL);
4041 while (pair != NULL) {
4042 const char *propname = nvpair_name(pair);
4043 nvpair_t *match;
4044
4045 next_pair = nvlist_next_nvpair(props, pair);
4046
4047 if ((nvlist_lookup_nvpair(origprops, propname,
4048 &match) != 0) || !propval_equals(pair, match))
4049 goto next; /* need to set received value */
4050
4051 /* don't clear the existing received value */
4052 (void) nvlist_remove_nvpair(origprops, match);
4053 /* don't bother receiving the property */
4054 (void) nvlist_remove_nvpair(props, pair);
4055 next:
4056 pair = next_pair;
4057 }
4058 }
4059
4060 /*
4061 * Extract properties that cannot be set PRIOR to the receipt of a dataset.
4062 * For example, refquota cannot be set until after the receipt of a dataset,
4063 * because in replication streams, an older/earlier snapshot may exceed the
4064 * refquota. We want to receive the older/earlier snapshot, but setting
4065 * refquota pre-receipt will set the dsl's ACTUAL quota, which will prevent
4066 * the older/earlier snapshot from being received (with EDQUOT).
4067 *
4068 * The ZFS test "zfs_receive_011_pos" demonstrates such a scenario.
4069 *
4070 * libzfs will need to be judicious handling errors encountered by props
4071 * extracted by this function.
4072 */
4073 static nvlist_t *
4074 extract_delay_props(nvlist_t *props)
4075 {
4076 nvlist_t *delayprops;
4077 nvpair_t *nvp, *tmp;
4078 static const zfs_prop_t delayable[] = { ZFS_PROP_REFQUOTA, 0 };
4079 int i;
4080
4081 VERIFY(nvlist_alloc(&delayprops, NV_UNIQUE_NAME, KM_SLEEP) == 0);
4082
4083 for (nvp = nvlist_next_nvpair(props, NULL); nvp != NULL;
4084 nvp = nvlist_next_nvpair(props, nvp)) {
4085 /*
4086 * strcmp() is safe because zfs_prop_to_name() always returns
4087 * a bounded string.
4088 */
4089 for (i = 0; delayable[i] != 0; i++) {
4090 if (strcmp(zfs_prop_to_name(delayable[i]),
4091 nvpair_name(nvp)) == 0) {
4092 break;
4093 }
4094 }
4095 if (delayable[i] != 0) {
4096 tmp = nvlist_prev_nvpair(props, nvp);
4097 VERIFY(nvlist_add_nvpair(delayprops, nvp) == 0);
4098 VERIFY(nvlist_remove_nvpair(props, nvp) == 0);
4099 nvp = tmp;
4100 }
4101 }
4102
4103 if (nvlist_empty(delayprops)) {
4104 nvlist_free(delayprops);
4105 delayprops = NULL;
4106 }
4107 return (delayprops);
4108 }
4109
4110 #ifdef DEBUG
4111 static boolean_t zfs_ioc_recv_inject_err;
4112 #endif
4113
4114 /*
4115 * inputs:
4116 * zc_name name of containing filesystem
4117 * zc_nvlist_src{_size} nvlist of properties to apply
4118 * zc_value name of snapshot to create
4119 * zc_string name of clone origin (if DRR_FLAG_CLONE)
4120 * zc_cookie file descriptor to recv from
4121 * zc_begin_record the BEGIN record of the stream (not byteswapped)
4122 * zc_guid force flag
4123 * zc_cleanup_fd cleanup-on-exit file descriptor
4124 * zc_action_handle handle for this guid/ds mapping (or zero on first call)
4125 *
4126 * outputs:
4127 * zc_cookie number of bytes read
4128 * zc_nvlist_dst{_size} error for each unapplied received property
4129 * zc_obj zprop_errflags_t
4130 * zc_action_handle handle for this guid/ds mapping
4131 */
4132 static int
4133 zfs_ioc_recv(zfs_cmd_t *zc)
4134 {
4135 file_t *fp;
4136 dmu_recv_cookie_t drc;
4137 boolean_t force = (boolean_t)zc->zc_guid;
4138 int fd;
4139 int error = 0;
4140 int props_error = 0;
4141 nvlist_t *errors;
4142 offset_t off;
4143 nvlist_t *props = NULL; /* sent properties */
4144 nvlist_t *origprops = NULL; /* existing properties */
4145 nvlist_t *delayprops = NULL; /* sent properties applied post-receive */
4146 char *origin = NULL;
4147 char *tosnap;
4148 char tofs[ZFS_MAXNAMELEN];
4149 boolean_t first_recvd_props = B_FALSE;
4150
4151 if (dataset_namecheck(zc->zc_value, NULL, NULL) != 0 ||
4152 strchr(zc->zc_value, '@') == NULL ||
4153 strchr(zc->zc_value, '%'))
4154 return (SET_ERROR(EINVAL));
4155
4156 (void) strcpy(tofs, zc->zc_value);
4157 tosnap = strchr(tofs, '@');
4158 *tosnap++ = '\0';
4159
4160 if (zc->zc_nvlist_src != NULL &&
4161 (error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
4162 zc->zc_iflags, &props)) != 0)
4163 return (error);
4164
4165 fd = zc->zc_cookie;
4166 fp = getf(fd);
4167 if (fp == NULL) {
4168 nvlist_free(props);
4169 return (SET_ERROR(EBADF));
4170 }
4171
4172 VERIFY(nvlist_alloc(&errors, NV_UNIQUE_NAME, KM_SLEEP) == 0);
4173
4174 if (zc->zc_string[0])
4175 origin = zc->zc_string;
4176
4177 error = dmu_recv_begin(tofs, tosnap,
4178 &zc->zc_begin_record, force, origin, &drc);
4179 if (error != 0)
4180 goto out;
4181
4182 /*
4183 * Set properties before we receive the stream so that they are applied
4184 * to the new data. Note that we must call dmu_recv_stream() if
4185 * dmu_recv_begin() succeeds.
4186 */
4187 if (props != NULL && !drc.drc_newfs) {
4188 if (spa_version(dsl_dataset_get_spa(drc.drc_ds)) >=
4189 SPA_VERSION_RECVD_PROPS &&
4190 !dsl_prop_get_hasrecvd(tofs))
4191 first_recvd_props = B_TRUE;
4192
4193 /*
4194 * If new received properties are supplied, they are to
4195 * completely replace the existing received properties, so stash
4196 * away the existing ones.
4197 */
4198 if (dsl_prop_get_received(tofs, &origprops) == 0) {
4199 nvlist_t *errlist = NULL;
4200 /*
4201 * Don't bother writing a property if its value won't
4202 * change (and avoid the unnecessary security checks).
4203 *
4204 * The first receive after SPA_VERSION_RECVD_PROPS is a
4205 * special case where we blow away all local properties
4206 * regardless.
4207 */
4208 if (!first_recvd_props)
4209 props_reduce(props, origprops);
4210 if (zfs_check_clearable(tofs, origprops, &errlist) != 0)
4211 (void) nvlist_merge(errors, errlist, 0);
4212 nvlist_free(errlist);
4213
4214 if (clear_received_props(tofs, origprops,
4215 first_recvd_props ? NULL : props) != 0)
4216 zc->zc_obj |= ZPROP_ERR_NOCLEAR;
4217 } else {
4218 zc->zc_obj |= ZPROP_ERR_NOCLEAR;
4219 }
4220 }
4221
4222 if (props != NULL) {
4223 props_error = dsl_prop_set_hasrecvd(tofs);
4224
4225 if (props_error == 0) {
4226 delayprops = extract_delay_props(props);
4227 (void) zfs_set_prop_nvlist(tofs, ZPROP_SRC_RECEIVED,
4228 props, errors);
4229 }
4230 }
4231
4232 off = fp->f_offset;
4233 error = dmu_recv_stream(&drc, fp->f_vnode, &off, zc->zc_cleanup_fd,
4234 &zc->zc_action_handle);
4235
4236 if (error == 0) {
4237 zfsvfs_t *zfsvfs = NULL;
4238
4239 if (getzfsvfs(tofs, &zfsvfs) == 0) {
4240 /* online recv */
4241 int end_err;
4242
4243 error = zfs_suspend_fs(zfsvfs);
4244 /*
4245 * If the suspend fails, then the recv_end will
4246 * likely also fail, and clean up after itself.
4247 */
4248 end_err = dmu_recv_end(&drc, zfsvfs);
4249 if (error == 0)
4250 error = zfs_resume_fs(zfsvfs, tofs);
4251 error = error ? error : end_err;
4252 VFS_RELE(zfsvfs->z_vfs);
4253 } else {
4254 error = dmu_recv_end(&drc, NULL);
4255 }
4256
4257 /* Set delayed properties now, after we're done receiving. */
4258 if (delayprops != NULL && error == 0) {
4259 (void) zfs_set_prop_nvlist(tofs, ZPROP_SRC_RECEIVED,
4260 delayprops, errors);
4261 }
4262 }
4263
4264 if (delayprops != NULL) {
4265 /*
4266 * Merge delayed props back in with initial props, in case
4267 * we're DEBUG and zfs_ioc_recv_inject_err is set (which means
4268 * we have to make sure clear_received_props() includes
4269 * the delayed properties).
4270 *
4271 * Since zfs_ioc_recv_inject_err is only in DEBUG kernels,
4272 * using ASSERT() will be just like a VERIFY.
4273 */
4274 ASSERT(nvlist_merge(props, delayprops, 0) == 0);
4275 nvlist_free(delayprops);
4276 }
4277
4278 /*
4279 * Now that all props, initial and delayed, are set, report the prop
4280 * errors to the caller.
4281 */
4282 if (zc->zc_nvlist_dst_size != 0 &&
4283 (nvlist_smush(errors, zc->zc_nvlist_dst_size) != 0 ||
4284 put_nvlist(zc, errors) != 0)) {
4285 /*
4286 * Caller made zc->zc_nvlist_dst less than the minimum expected
4287 * size or supplied an invalid address.
4288 */
4289 props_error = SET_ERROR(EINVAL);
4290 }
4291
4292 zc->zc_cookie = off - fp->f_offset;
4293 if (VOP_SEEK(fp->f_vnode, fp->f_offset, &off, NULL) == 0)
4294 fp->f_offset = off;
4295
4296 #ifdef DEBUG
4297 if (zfs_ioc_recv_inject_err) {
4298 zfs_ioc_recv_inject_err = B_FALSE;
4299 error = 1;
4300 }
4301 #endif
4302 /*
4303 * On error, restore the original props.
4304 */
4305 if (error != 0 && props != NULL && !drc.drc_newfs) {
4306 if (clear_received_props(tofs, props, NULL) != 0) {
4307 /*
4308 * We failed to clear the received properties.
4309 * Since we may have left a $recvd value on the
4310 * system, we can't clear the $hasrecvd flag.
4311 */
4312 zc->zc_obj |= ZPROP_ERR_NORESTORE;
4313 } else if (first_recvd_props) {
4314 dsl_prop_unset_hasrecvd(tofs);
4315 }
4316
4317 if (origprops == NULL && !drc.drc_newfs) {
4318 /* We failed to stash the original properties. */
4319 zc->zc_obj |= ZPROP_ERR_NORESTORE;
4320 }
4321
4322 /*
4323 * dsl_props_set() will not convert RECEIVED to LOCAL on or
4324 * after SPA_VERSION_RECVD_PROPS, so we need to specify LOCAL
4325 * explictly if we're restoring local properties cleared in the
4326 * first new-style receive.
4327 */
4328 if (origprops != NULL &&
4329 zfs_set_prop_nvlist(tofs, (first_recvd_props ?
4330 ZPROP_SRC_LOCAL : ZPROP_SRC_RECEIVED),
4331 origprops, NULL) != 0) {
4332 /*
4333 * We stashed the original properties but failed to
4334 * restore them.
4335 */
4336 zc->zc_obj |= ZPROP_ERR_NORESTORE;
4337 }
4338 }
4339 out:
4340 nvlist_free(props);
4341 nvlist_free(origprops);
4342 nvlist_free(errors);
4343 releasef(fd);
4344
4345 if (error == 0)
4346 error = props_error;
4347
4348 return (error);
4349 }
4350
4351 /*
4352 * inputs:
4353 * zc_name name of snapshot to send
4354 * zc_cookie file descriptor to send stream to
4355 * zc_obj fromorigin flag (mutually exclusive with zc_fromobj)
4356 * zc_sendobj objsetid of snapshot to send
4357 * zc_fromobj objsetid of incremental fromsnap (may be zero)
4358 * zc_guid if set, estimate size of stream only. zc_cookie is ignored.
4359 * output size in zc_objset_type.
4360 * zc_flags lzc_send_flags
4361 *
4362 * outputs:
4363 * zc_objset_type estimated size, if zc_guid is set
4364 */
4365 static int
4366 zfs_ioc_send(zfs_cmd_t *zc)
4367 {
4368 int error;
4369 offset_t off;
4370 boolean_t estimate = (zc->zc_guid != 0);
4371 boolean_t embedok = (zc->zc_flags & 0x1);
4372 boolean_t large_block_ok = (zc->zc_flags & 0x2);
4373
4374 if (zc->zc_obj != 0) {
4375 dsl_pool_t *dp;
4376 dsl_dataset_t *tosnap;
4377
4378 error = dsl_pool_hold(zc->zc_name, FTAG, &dp);
4379 if (error != 0)
4380 return (error);
4381
4382 error = dsl_dataset_hold_obj(dp, zc->zc_sendobj, FTAG, &tosnap);
4383 if (error != 0) {
4384 dsl_pool_rele(dp, FTAG);
4385 return (error);
4386 }
4387
4388 if (dsl_dir_is_clone(tosnap->ds_dir))
4389 zc->zc_fromobj =
4390 dsl_dir_phys(tosnap->ds_dir)->dd_origin_obj;
4391 dsl_dataset_rele(tosnap, FTAG);
4392 dsl_pool_rele(dp, FTAG);
4393 }
4394
4395 if (estimate) {
4396 dsl_pool_t *dp;
4397 dsl_dataset_t *tosnap;
4398 dsl_dataset_t *fromsnap = NULL;
4399
4400 error = dsl_pool_hold(zc->zc_name, FTAG, &dp);
4401 if (error != 0)
4402 return (error);
4403
4404 error = dsl_dataset_hold_obj(dp, zc->zc_sendobj, FTAG, &tosnap);
4405 if (error != 0) {
4406 dsl_pool_rele(dp, FTAG);
4407 return (error);
4408 }
4409
4410 if (zc->zc_fromobj != 0) {
4411 error = dsl_dataset_hold_obj(dp, zc->zc_fromobj,
4412 FTAG, &fromsnap);
4413 if (error != 0) {
4414 dsl_dataset_rele(tosnap, FTAG);
4415 dsl_pool_rele(dp, FTAG);
4416 return (error);
4417 }
4418 }
4419
4420 error = dmu_send_estimate(tosnap, fromsnap,
4421 &zc->zc_objset_type);
4422
4423 if (fromsnap != NULL)
4424 dsl_dataset_rele(fromsnap, FTAG);
4425 dsl_dataset_rele(tosnap, FTAG);
4426 dsl_pool_rele(dp, FTAG);
4427 } else {
4428 file_t *fp = getf(zc->zc_cookie);
4429 if (fp == NULL)
4430 return (SET_ERROR(EBADF));
4431
4432 off = fp->f_offset;
4433 error = dmu_send_obj(zc->zc_name, zc->zc_sendobj,
4434 zc->zc_fromobj, embedok, large_block_ok,
4435 zc->zc_cookie, fp->f_vnode, &off);
4436
4437 if (VOP_SEEK(fp->f_vnode, fp->f_offset, &off, NULL) == 0)
4438 fp->f_offset = off;
4439 releasef(zc->zc_cookie);
4440 }
4441 return (error);
4442 }
4443
4444 /*
4445 * inputs:
4446 * zc_name name of snapshot on which to report progress
4447 * zc_cookie file descriptor of send stream
4448 *
4449 * outputs:
4450 * zc_cookie number of bytes written in send stream thus far
4451 */
4452 static int
4453 zfs_ioc_send_progress(zfs_cmd_t *zc)
4454 {
4455 dsl_pool_t *dp;
4456 dsl_dataset_t *ds;
4457 dmu_sendarg_t *dsp = NULL;
4458 int error;
4459
4460 error = dsl_pool_hold(zc->zc_name, FTAG, &dp);
4461 if (error != 0)
4462 return (error);
4463
4464 error = dsl_dataset_hold(dp, zc->zc_name, FTAG, &ds);
4465 if (error != 0) {
4466 dsl_pool_rele(dp, FTAG);
4467 return (error);
4468 }
4469
4470 mutex_enter(&ds->ds_sendstream_lock);
4471
4472 /*
4473 * Iterate over all the send streams currently active on this dataset.
4474 * If there's one which matches the specified file descriptor _and_ the
4475 * stream was started by the current process, return the progress of
4476 * that stream.
4477 */
4478 for (dsp = list_head(&ds->ds_sendstreams); dsp != NULL;
4479 dsp = list_next(&ds->ds_sendstreams, dsp)) {
4480 if (dsp->dsa_outfd == zc->zc_cookie &&
4481 dsp->dsa_proc == curproc)
4482 break;
4483 }
4484
4485 if (dsp != NULL)
4486 zc->zc_cookie = *(dsp->dsa_off);
4487 else
4488 error = SET_ERROR(ENOENT);
4489
4490 mutex_exit(&ds->ds_sendstream_lock);
4491 dsl_dataset_rele(ds, FTAG);
4492 dsl_pool_rele(dp, FTAG);
4493 return (error);
4494 }
4495
4496 static int
4497 zfs_ioc_inject_fault(zfs_cmd_t *zc)
4498 {
4499 int id, error;
4500
4501 error = zio_inject_fault(zc->zc_name, (int)zc->zc_guid, &id,
4502 &zc->zc_inject_record);
4503
4504 if (error == 0)
4505 zc->zc_guid = (uint64_t)id;
4506
4507 return (error);
4508 }
4509
4510 static int
4511 zfs_ioc_clear_fault(zfs_cmd_t *zc)
4512 {
4513 return (zio_clear_fault((int)zc->zc_guid));
4514 }
4515
4516 static int
4517 zfs_ioc_inject_list_next(zfs_cmd_t *zc)
4518 {
4519 int id = (int)zc->zc_guid;
4520 int error;
4521
4522 error = zio_inject_list_next(&id, zc->zc_name, sizeof (zc->zc_name),
4523 &zc->zc_inject_record);
4524
4525 zc->zc_guid = id;
4526
4527 return (error);
4528 }
4529
4530 static int
4531 zfs_ioc_error_log(zfs_cmd_t *zc)
4532 {
4533 spa_t *spa;
4534 int error;
4535 size_t count = (size_t)zc->zc_nvlist_dst_size;
4536
4537 if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
4538 return (error);
4539
4540 error = spa_get_errlog(spa, (void *)(uintptr_t)zc->zc_nvlist_dst,
4541 &count);
4542 if (error == 0)
4543 zc->zc_nvlist_dst_size = count;
4544 else
4545 zc->zc_nvlist_dst_size = spa_get_errlog_size(spa);
4546
4547 spa_close(spa, FTAG);
4548
4549 return (error);
4550 }
4551
4552 static int
4553 zfs_ioc_clear(zfs_cmd_t *zc)
4554 {
4555 spa_t *spa;
4556 vdev_t *vd;
4557 int error;
4558
4559 /*
4560 * On zpool clear we also fix up missing slogs
4561 */
4562 mutex_enter(&spa_namespace_lock);
4563 spa = spa_lookup(zc->zc_name);
4564 if (spa == NULL) {
4565 mutex_exit(&spa_namespace_lock);
4566 return (SET_ERROR(EIO));
4567 }
4568 if (spa_get_log_state(spa) == SPA_LOG_MISSING) {
4569 /* we need to let spa_open/spa_load clear the chains */
4570 spa_set_log_state(spa, SPA_LOG_CLEAR);
4571 }
4572 spa->spa_last_open_failed = 0;
4573 mutex_exit(&spa_namespace_lock);
4574
4575 if (zc->zc_cookie & ZPOOL_NO_REWIND) {
4576 error = spa_open(zc->zc_name, &spa, FTAG);
4577 } else {
4578 nvlist_t *policy;
4579 nvlist_t *config = NULL;
4580
4581 if (zc->zc_nvlist_src == NULL)
4582 return (SET_ERROR(EINVAL));
4583
4584 if ((error = get_nvlist(zc->zc_nvlist_src,
4585 zc->zc_nvlist_src_size, zc->zc_iflags, &policy)) == 0) {
4586 error = spa_open_rewind(zc->zc_name, &spa, FTAG,
4587 policy, &config);
4588 if (config != NULL) {
4589 int err;
4590
4591 if ((err = put_nvlist(zc, config)) != 0)
4592 error = err;
4593 nvlist_free(config);
4594 }
4595 nvlist_free(policy);
4596 }
4597 }
4598
4599 if (error != 0)
4600 return (error);
4601
4602 spa_vdev_state_enter(spa, SCL_NONE);
4603
4604 if (zc->zc_guid == 0) {
4605 vd = NULL;
4606 } else {
4607 vd = spa_lookup_by_guid(spa, zc->zc_guid, B_TRUE);
4608 if (vd == NULL) {
4609 (void) spa_vdev_state_exit(spa, NULL, ENODEV);
4610 spa_close(spa, FTAG);
4611 return (SET_ERROR(ENODEV));
4612 }
4613 }
4614
4615 vdev_clear(spa, vd);
4616
4617 (void) spa_vdev_state_exit(spa, NULL, 0);
4618
4619 /*
4620 * Resume any suspended I/Os.
4621 */
4622 if (zio_resume(spa) != 0)
4623 error = SET_ERROR(EIO);
4624
4625 spa_close(spa, FTAG);
4626
4627 return (error);
4628 }
4629
4630 static int
4631 zfs_ioc_pool_reopen(zfs_cmd_t *zc)
4632 {
4633 spa_t *spa;
4634 int error;
4635
4636 error = spa_open(zc->zc_name, &spa, FTAG);
4637 if (error != 0)
4638 return (error);
4639
4640 spa_vdev_state_enter(spa, SCL_NONE);
4641
4642 /*
4643 * If a resilver is already in progress then set the
4644 * spa_scrub_reopen flag to B_TRUE so that we don't restart
4645 * the scan as a side effect of the reopen. Otherwise, let
4646 * vdev_open() decided if a resilver is required.
4647 */
4648 spa->spa_scrub_reopen = dsl_scan_resilvering(spa->spa_dsl_pool);
4649 vdev_reopen(spa->spa_root_vdev);
4650 spa->spa_scrub_reopen = B_FALSE;
4651
4652 (void) spa_vdev_state_exit(spa, NULL, 0);
4653 spa_close(spa, FTAG);
4654 return (0);
4655 }
4656 /*
4657 * inputs:
4658 * zc_name name of filesystem
4659 * zc_value name of origin snapshot
4660 *
4661 * outputs:
4662 * zc_string name of conflicting snapshot, if there is one
4663 */
4664 static int
4665 zfs_ioc_promote(zfs_cmd_t *zc)
4666 {
4667 char *cp;
4668
4669 /*
4670 * We don't need to unmount *all* the origin fs's snapshots, but
4671 * it's easier.
4672 */
4673 cp = strchr(zc->zc_value, '@');
4674 if (cp)
4675 *cp = '\0';
4676 (void) dmu_objset_find(zc->zc_value,
4677 zfs_unmount_snap_cb, NULL, DS_FIND_SNAPSHOTS);
4678 return (dsl_dataset_promote(zc->zc_name, zc->zc_string));
4679 }
4680
4681 /*
4682 * Retrieve a single {user|group}{used|quota}@... property.
4683 *
4684 * inputs:
4685 * zc_name name of filesystem
4686 * zc_objset_type zfs_userquota_prop_t
4687 * zc_value domain name (eg. "S-1-234-567-89")
4688 * zc_guid RID/UID/GID
4689 *
4690 * outputs:
4691 * zc_cookie property value
4692 */
4693 static int
4694 zfs_ioc_userspace_one(zfs_cmd_t *zc)
4695 {
4696 zfsvfs_t *zfsvfs;
4697 int error;
4698
4699 if (zc->zc_objset_type >= ZFS_NUM_USERQUOTA_PROPS)
4700 return (SET_ERROR(EINVAL));
4701
4702 error = zfsvfs_hold(zc->zc_name, FTAG, &zfsvfs, B_FALSE);
4703 if (error != 0)
4704 return (error);
4705
4706 error = zfs_userspace_one(zfsvfs,
4707 zc->zc_objset_type, zc->zc_value, zc->zc_guid, &zc->zc_cookie);
4708 zfsvfs_rele(zfsvfs, FTAG);
4709
4710 return (error);
4711 }
4712
4713 /*
4714 * inputs:
4715 * zc_name name of filesystem
4716 * zc_cookie zap cursor
4717 * zc_objset_type zfs_userquota_prop_t
4718 * zc_nvlist_dst[_size] buffer to fill (not really an nvlist)
4719 *
4720 * outputs:
4721 * zc_nvlist_dst[_size] data buffer (array of zfs_useracct_t)
4722 * zc_cookie zap cursor
4723 */
4724 static int
4725 zfs_ioc_userspace_many(zfs_cmd_t *zc)
4726 {
4727 zfsvfs_t *zfsvfs;
4728 int bufsize = zc->zc_nvlist_dst_size;
4729
4730 if (bufsize <= 0)
4731 return (SET_ERROR(ENOMEM));
4732
4733 int error = zfsvfs_hold(zc->zc_name, FTAG, &zfsvfs, B_FALSE);
4734 if (error != 0)
4735 return (error);
4736
4737 void *buf = kmem_alloc(bufsize, KM_SLEEP);
4738
4739 error = zfs_userspace_many(zfsvfs, zc->zc_objset_type, &zc->zc_cookie,
4740 buf, &zc->zc_nvlist_dst_size);
4741
4742 if (error == 0) {
4743 error = xcopyout(buf,
4744 (void *)(uintptr_t)zc->zc_nvlist_dst,
4745 zc->zc_nvlist_dst_size);
4746 }
4747 kmem_free(buf, bufsize);
4748 zfsvfs_rele(zfsvfs, FTAG);
4749
4750 return (error);
4751 }
4752
4753 /*
4754 * inputs:
4755 * zc_name name of filesystem
4756 *
4757 * outputs:
4758 * none
4759 */
4760 static int
4761 zfs_ioc_userspace_upgrade(zfs_cmd_t *zc)
4762 {
4763 objset_t *os;
4764 int error = 0;
4765 zfsvfs_t *zfsvfs;
4766
4767 if (getzfsvfs(zc->zc_name, &zfsvfs) == 0) {
4768 if (!dmu_objset_userused_enabled(zfsvfs->z_os)) {
4769 /*
4770 * If userused is not enabled, it may be because the
4771 * objset needs to be closed & reopened (to grow the
4772 * objset_phys_t). Suspend/resume the fs will do that.
4773 */
4774 error = zfs_suspend_fs(zfsvfs);
4775 if (error == 0) {
4776 dmu_objset_refresh_ownership(zfsvfs->z_os,
4777 zfsvfs);
4778 error = zfs_resume_fs(zfsvfs, zc->zc_name);
4779 }
4780 }
4781 if (error == 0)
4782 error = dmu_objset_userspace_upgrade(zfsvfs->z_os);
4783 VFS_RELE(zfsvfs->z_vfs);
4784 } else {
4785 /* XXX kind of reading contents without owning */
4786 error = dmu_objset_hold(zc->zc_name, FTAG, &os);
4787 if (error != 0)
4788 return (error);
4789
4790 error = dmu_objset_userspace_upgrade(os);
4791 dmu_objset_rele(os, FTAG);
4792 }
4793
4794 return (error);
4795 }
4796
4797 /*
4798 * We don't want to have a hard dependency
4799 * against some special symbols in sharefs
4800 * nfs, and smbsrv. Determine them if needed when
4801 * the first file system is shared.
4802 * Neither sharefs, nfs or smbsrv are unloadable modules.
4803 */
4804 int (*znfsexport_fs)(void *arg);
4805 int (*zshare_fs)(enum sharefs_sys_op, share_t *, uint32_t);
4806 int (*zsmbexport_fs)(void *arg, boolean_t add_share);
4807
4808 int zfs_nfsshare_inited;
4809 int zfs_smbshare_inited;
4810
4811 ddi_modhandle_t nfs_mod;
4812 ddi_modhandle_t sharefs_mod;
4813 ddi_modhandle_t smbsrv_mod;
4814 kmutex_t zfs_share_lock;
4815
4816 static int
4817 zfs_init_sharefs()
4818 {
4819 int error;
4820
4821 ASSERT(MUTEX_HELD(&zfs_share_lock));
4822 /* Both NFS and SMB shares also require sharetab support. */
4823 if (sharefs_mod == NULL && ((sharefs_mod =
4824 ddi_modopen("fs/sharefs",
4825 KRTLD_MODE_FIRST, &error)) == NULL)) {
4826 return (SET_ERROR(ENOSYS));
4827 }
4828 if (zshare_fs == NULL && ((zshare_fs =
4829 (int (*)(enum sharefs_sys_op, share_t *, uint32_t))
4830 ddi_modsym(sharefs_mod, "sharefs_impl", &error)) == NULL)) {
4831 return (SET_ERROR(ENOSYS));
4832 }
4833 return (0);
4834 }
4835
4836 static int
4837 zfs_ioc_share(zfs_cmd_t *zc)
4838 {
4839 int error;
4840 int opcode;
4841
4842 switch (zc->zc_share.z_sharetype) {
4843 case ZFS_SHARE_NFS:
4844 case ZFS_UNSHARE_NFS:
4845 if (zfs_nfsshare_inited == 0) {
4846 mutex_enter(&zfs_share_lock);
4847 if (nfs_mod == NULL && ((nfs_mod = ddi_modopen("fs/nfs",
4848 KRTLD_MODE_FIRST, &error)) == NULL)) {
4849 mutex_exit(&zfs_share_lock);
4850 return (SET_ERROR(ENOSYS));
4851 }
4852 if (znfsexport_fs == NULL &&
4853 ((znfsexport_fs = (int (*)(void *))
4854 ddi_modsym(nfs_mod,
4855 "nfs_export", &error)) == NULL)) {
4856 mutex_exit(&zfs_share_lock);
4857 return (SET_ERROR(ENOSYS));
4858 }
4859 error = zfs_init_sharefs();
4860 if (error != 0) {
4861 mutex_exit(&zfs_share_lock);
4862 return (SET_ERROR(ENOSYS));
4863 }
4864 zfs_nfsshare_inited = 1;
4865 mutex_exit(&zfs_share_lock);
4866 }
4867 break;
4868 case ZFS_SHARE_SMB:
4869 case ZFS_UNSHARE_SMB:
4870 if (zfs_smbshare_inited == 0) {
4871 mutex_enter(&zfs_share_lock);
4872 if (smbsrv_mod == NULL && ((smbsrv_mod =
4873 ddi_modopen("drv/smbsrv",
4874 KRTLD_MODE_FIRST, &error)) == NULL)) {
4875 mutex_exit(&zfs_share_lock);
4876 return (SET_ERROR(ENOSYS));
4877 }
4878 if (zsmbexport_fs == NULL && ((zsmbexport_fs =
4879 (int (*)(void *, boolean_t))ddi_modsym(smbsrv_mod,
4880 "smb_server_share", &error)) == NULL)) {
4881 mutex_exit(&zfs_share_lock);
4882 return (SET_ERROR(ENOSYS));
4883 }
4884 error = zfs_init_sharefs();
4885 if (error != 0) {
4886 mutex_exit(&zfs_share_lock);
4887 return (SET_ERROR(ENOSYS));
4888 }
4889 zfs_smbshare_inited = 1;
4890 mutex_exit(&zfs_share_lock);
4891 }
4892 break;
4893 default:
4894 return (SET_ERROR(EINVAL));
4895 }
4896
4897 switch (zc->zc_share.z_sharetype) {
4898 case ZFS_SHARE_NFS:
4899 case ZFS_UNSHARE_NFS:
4900 if (error =
4901 znfsexport_fs((void *)
4902 (uintptr_t)zc->zc_share.z_exportdata))
4903 return (error);
4904 break;
4905 case ZFS_SHARE_SMB:
4906 case ZFS_UNSHARE_SMB:
4907 if (error = zsmbexport_fs((void *)
4908 (uintptr_t)zc->zc_share.z_exportdata,
4909 zc->zc_share.z_sharetype == ZFS_SHARE_SMB ?
4910 B_TRUE: B_FALSE)) {
4911 return (error);
4912 }
4913 break;
4914 }
4915
4916 opcode = (zc->zc_share.z_sharetype == ZFS_SHARE_NFS ||
4917 zc->zc_share.z_sharetype == ZFS_SHARE_SMB) ?
4918 SHAREFS_ADD : SHAREFS_REMOVE;
4919
4920 /*
4921 * Add or remove share from sharetab
4922 */
4923 error = zshare_fs(opcode,
4924 (void *)(uintptr_t)zc->zc_share.z_sharedata,
4925 zc->zc_share.z_sharemax);
4926
4927 return (error);
4928
4929 }
4930
4931 ace_t full_access[] = {
4932 {(uid_t)-1, ACE_ALL_PERMS, ACE_EVERYONE, 0}
4933 };
4934
4935 /*
4936 * inputs:
4937 * zc_name name of containing filesystem
4938 * zc_obj object # beyond which we want next in-use object #
4939 *
4940 * outputs:
4941 * zc_obj next in-use object #
4942 */
4943 static int
4944 zfs_ioc_next_obj(zfs_cmd_t *zc)
4945 {
4946 objset_t *os = NULL;
4947 int error;
4948
4949 error = dmu_objset_hold(zc->zc_name, FTAG, &os);
4950 if (error != 0)
4951 return (error);
4952
4953 error = dmu_object_next(os, &zc->zc_obj, B_FALSE,
4954 dsl_dataset_phys(os->os_dsl_dataset)->ds_prev_snap_txg);
4955
4956 dmu_objset_rele(os, FTAG);
4957 return (error);
4958 }
4959
4960 /*
4961 * inputs:
4962 * zc_name name of filesystem
4963 * zc_value prefix name for snapshot
4964 * zc_cleanup_fd cleanup-on-exit file descriptor for calling process
4965 *
4966 * outputs:
4967 * zc_value short name of new snapshot
4968 */
4969 static int
4970 zfs_ioc_tmp_snapshot(zfs_cmd_t *zc)
4971 {
4972 char *snap_name;
4973 char *hold_name;
4974 int error;
4975 minor_t minor;
4976
4977 error = zfs_onexit_fd_hold(zc->zc_cleanup_fd, &minor);
4978 if (error != 0)
4979 return (error);
4980
4981 snap_name = kmem_asprintf("%s-%016llx", zc->zc_value,
4982 (u_longlong_t)ddi_get_lbolt64());
4983 hold_name = kmem_asprintf("%%%s", zc->zc_value);
4984
4985 error = dsl_dataset_snapshot_tmp(zc->zc_name, snap_name, minor,
4986 hold_name);
4987 if (error == 0)
4988 (void) strcpy(zc->zc_value, snap_name);
4989 strfree(snap_name);
4990 strfree(hold_name);
4991 zfs_onexit_fd_rele(zc->zc_cleanup_fd);
4992 return (error);
4993 }
4994
4995 /*
4996 * inputs:
4997 * zc_name name of "to" snapshot
4998 * zc_value name of "from" snapshot
4999 * zc_cookie file descriptor to write diff data on
5000 *
5001 * outputs:
5002 * dmu_diff_record_t's to the file descriptor
5003 */
5004 static int
5005 zfs_ioc_diff(zfs_cmd_t *zc)
5006 {
5007 file_t *fp;
5008 offset_t off;
5009 int error;
5010
5011 fp = getf(zc->zc_cookie);
5012 if (fp == NULL)
5013 return (SET_ERROR(EBADF));
5014
5015 off = fp->f_offset;
5016
5017 error = dmu_diff(zc->zc_name, zc->zc_value, fp->f_vnode, &off);
5018
5019 if (VOP_SEEK(fp->f_vnode, fp->f_offset, &off, NULL) == 0)
5020 fp->f_offset = off;
5021 releasef(zc->zc_cookie);
5022
5023 return (error);
5024 }
5025
5026 /*
5027 * Remove all ACL files in shares dir
5028 */
5029 static int
5030 zfs_smb_acl_purge(znode_t *dzp)
5031 {
5032 zap_cursor_t zc;
5033 zap_attribute_t zap;
5034 zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
5035 int error;
5036
5037 for (zap_cursor_init(&zc, zfsvfs->z_os, dzp->z_id);
5038 (error = zap_cursor_retrieve(&zc, &zap)) == 0;
5039 zap_cursor_advance(&zc)) {
5040 if ((error = VOP_REMOVE(ZTOV(dzp), zap.za_name, kcred,
5041 NULL, 0)) != 0)
5042 break;
5043 }
5044 zap_cursor_fini(&zc);
5045 return (error);
5046 }
5047
5048 static int
5049 zfs_ioc_smb_acl(zfs_cmd_t *zc)
5050 {
5051 vnode_t *vp;
5052 znode_t *dzp;
5053 vnode_t *resourcevp = NULL;
5054 znode_t *sharedir;
5055 zfsvfs_t *zfsvfs;
5056 nvlist_t *nvlist;
5057 char *src, *target;
5058 vattr_t vattr;
5059 vsecattr_t vsec;
5060 int error = 0;
5061
5062 if ((error = lookupname(zc->zc_value, UIO_SYSSPACE,
5063 NO_FOLLOW, NULL, &vp)) != 0)
5064 return (error);
5065
5066 /* Now make sure mntpnt and dataset are ZFS */
5067
5068 if (vp->v_vfsp->vfs_fstype != zfsfstype ||
5069 (strcmp((char *)refstr_value(vp->v_vfsp->vfs_resource),
5070 zc->zc_name) != 0)) {
5071 VN_RELE(vp);
5072 return (SET_ERROR(EINVAL));
5073 }
5074
5075 dzp = VTOZ(vp);
5076 zfsvfs = dzp->z_zfsvfs;
5077 ZFS_ENTER(zfsvfs);
5078
5079 /*
5080 * Create share dir if its missing.
5081 */
5082 mutex_enter(&zfsvfs->z_lock);
5083 if (zfsvfs->z_shares_dir == 0) {
5084 dmu_tx_t *tx;
5085
5086 tx = dmu_tx_create(zfsvfs->z_os);
5087 dmu_tx_hold_zap(tx, MASTER_NODE_OBJ, TRUE,
5088 ZFS_SHARES_DIR);
5089 dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, FALSE, NULL);
5090 error = dmu_tx_assign(tx, TXG_WAIT);
5091 if (error != 0) {
5092 dmu_tx_abort(tx);
5093 } else {
5094 error = zfs_create_share_dir(zfsvfs, tx);
5095 dmu_tx_commit(tx);
5096 }
5097 if (error != 0) {
5098 mutex_exit(&zfsvfs->z_lock);
5099 VN_RELE(vp);
5100 ZFS_EXIT(zfsvfs);
5101 return (error);
5102 }
5103 }
5104 mutex_exit(&zfsvfs->z_lock);
5105
5106 ASSERT(zfsvfs->z_shares_dir);
5107 if ((error = zfs_zget(zfsvfs, zfsvfs->z_shares_dir, &sharedir)) != 0) {
5108 VN_RELE(vp);
5109 ZFS_EXIT(zfsvfs);
5110 return (error);
5111 }
5112
5113 switch (zc->zc_cookie) {
5114 case ZFS_SMB_ACL_ADD:
5115 vattr.va_mask = AT_MODE|AT_UID|AT_GID|AT_TYPE;
5116 vattr.va_type = VREG;
5117 vattr.va_mode = S_IFREG|0777;
5118 vattr.va_uid = 0;
5119 vattr.va_gid = 0;
5120
5121 vsec.vsa_mask = VSA_ACE;
5122 vsec.vsa_aclentp = &full_access;
5123 vsec.vsa_aclentsz = sizeof (full_access);
5124 vsec.vsa_aclcnt = 1;
5125
5126 error = VOP_CREATE(ZTOV(sharedir), zc->zc_string,
5127 &vattr, EXCL, 0, &resourcevp, kcred, 0, NULL, &vsec);
5128 if (resourcevp)
5129 VN_RELE(resourcevp);
5130 break;
5131
5132 case ZFS_SMB_ACL_REMOVE:
5133 error = VOP_REMOVE(ZTOV(sharedir), zc->zc_string, kcred,
5134 NULL, 0);
5135 break;
5136
5137 case ZFS_SMB_ACL_RENAME:
5138 if ((error = get_nvlist(zc->zc_nvlist_src,
5139 zc->zc_nvlist_src_size, zc->zc_iflags, &nvlist)) != 0) {
5140 VN_RELE(vp);
5141 VN_RELE(ZTOV(sharedir));
5142 ZFS_EXIT(zfsvfs);
5143 return (error);
5144 }
5145 if (nvlist_lookup_string(nvlist, ZFS_SMB_ACL_SRC, &src) ||
5146 nvlist_lookup_string(nvlist, ZFS_SMB_ACL_TARGET,
5147 &target)) {
5148 VN_RELE(vp);
5149 VN_RELE(ZTOV(sharedir));
5150 ZFS_EXIT(zfsvfs);
5151 nvlist_free(nvlist);
5152 return (error);
5153 }
5154 error = VOP_RENAME(ZTOV(sharedir), src, ZTOV(sharedir), target,
5155 kcred, NULL, 0);
5156 nvlist_free(nvlist);
5157 break;
5158
5159 case ZFS_SMB_ACL_PURGE:
5160 error = zfs_smb_acl_purge(sharedir);
5161 break;
5162
5163 default:
5164 error = SET_ERROR(EINVAL);
5165 break;
5166 }
5167
5168 VN_RELE(vp);
5169 VN_RELE(ZTOV(sharedir));
5170
5171 ZFS_EXIT(zfsvfs);
5172
5173 return (error);
5174 }
5175
5176 /*
5177 * innvl: {
5178 * "holds" -> { snapname -> holdname (string), ... }
5179 * (optional) "cleanup_fd" -> fd (int32)
5180 * }
5181 *
5182 * outnvl: {
5183 * snapname -> error value (int32)
5184 * ...
5185 * }
5186 */
5187 /* ARGSUSED */
5188 static int
5189 zfs_ioc_hold(const char *pool, nvlist_t *args, nvlist_t *errlist)
5190 {
5191 nvlist_t *holds;
5192 int cleanup_fd = -1;
5193 int error;
5194 minor_t minor = 0;
5195
5196 error = nvlist_lookup_nvlist(args, "holds", &holds);
5197 if (error != 0)
5198 return (SET_ERROR(EINVAL));
5199
5200 if (nvlist_lookup_int32(args, "cleanup_fd", &cleanup_fd) == 0) {
5201 error = zfs_onexit_fd_hold(cleanup_fd, &minor);
5202 if (error != 0)
5203 return (error);
5204 }
5205
5206 error = dsl_dataset_user_hold(holds, minor, errlist);
5207 if (minor != 0)
5208 zfs_onexit_fd_rele(cleanup_fd);
5209 return (error);
5210 }
5211
5212 /*
5213 * innvl is not used.
5214 *
5215 * outnvl: {
5216 * holdname -> time added (uint64 seconds since epoch)
5217 * ...
5218 * }
5219 */
5220 /* ARGSUSED */
5221 static int
5222 zfs_ioc_get_holds(const char *snapname, nvlist_t *args, nvlist_t *outnvl)
5223 {
5224 return (dsl_dataset_get_holds(snapname, outnvl));
5225 }
5226
5227 /*
5228 * innvl: {
5229 * snapname -> { holdname, ... }
5230 * ...
5231 * }
5232 *
5233 * outnvl: {
5234 * snapname -> error value (int32)
5235 * ...
5236 * }
5237 */
5238 /* ARGSUSED */
5239 static int
5240 zfs_ioc_release(const char *pool, nvlist_t *holds, nvlist_t *errlist)
5241 {
5242 return (dsl_dataset_user_release(holds, errlist));
5243 }
5244
5245 /*
5246 * inputs:
5247 * zc_name name of new filesystem or snapshot
5248 * zc_value full name of old snapshot
5249 *
5250 * outputs:
5251 * zc_cookie space in bytes
5252 * zc_objset_type compressed space in bytes
5253 * zc_perm_action uncompressed space in bytes
5254 */
5255 static int
5256 zfs_ioc_space_written(zfs_cmd_t *zc)
5257 {
5258 int error;
5259 dsl_pool_t *dp;
5260 dsl_dataset_t *new, *old;
5261
5262 error = dsl_pool_hold(zc->zc_name, FTAG, &dp);
5263 if (error != 0)
5264 return (error);
5265 error = dsl_dataset_hold(dp, zc->zc_name, FTAG, &new);
5266 if (error != 0) {
5267 dsl_pool_rele(dp, FTAG);
5268 return (error);
5269 }
5270 error = dsl_dataset_hold(dp, zc->zc_value, FTAG, &old);
5271 if (error != 0) {
5272 dsl_dataset_rele(new, FTAG);
5273 dsl_pool_rele(dp, FTAG);
5274 return (error);
5275 }
5276
5277 error = dsl_dataset_space_written(old, new, &zc->zc_cookie,
5278 &zc->zc_objset_type, &zc->zc_perm_action);
5279 dsl_dataset_rele(old, FTAG);
5280 dsl_dataset_rele(new, FTAG);
5281 dsl_pool_rele(dp, FTAG);
5282 return (error);
5283 }
5284
5285 /*
5286 * innvl: {
5287 * "firstsnap" -> snapshot name
5288 * }
5289 *
5290 * outnvl: {
5291 * "used" -> space in bytes
5292 * "compressed" -> compressed space in bytes
5293 * "uncompressed" -> uncompressed space in bytes
5294 * }
5295 */
5296 static int
5297 zfs_ioc_space_snaps(const char *lastsnap, nvlist_t *innvl, nvlist_t *outnvl)
5298 {
5299 int error;
5300 dsl_pool_t *dp;
5301 dsl_dataset_t *new, *old;
5302 char *firstsnap;
5303 uint64_t used, comp, uncomp;
5304
5305 if (nvlist_lookup_string(innvl, "firstsnap", &firstsnap) != 0)
5306 return (SET_ERROR(EINVAL));
5307
5308 error = dsl_pool_hold(lastsnap, FTAG, &dp);
5309 if (error != 0)
5310 return (error);
5311
5312 error = dsl_dataset_hold(dp, lastsnap, FTAG, &new);
5313 if (error != 0) {
5314 dsl_pool_rele(dp, FTAG);
5315 return (error);
5316 }
5317 error = dsl_dataset_hold(dp, firstsnap, FTAG, &old);
5318 if (error != 0) {
5319 dsl_dataset_rele(new, FTAG);
5320 dsl_pool_rele(dp, FTAG);
5321 return (error);
5322 }
5323
5324 error = dsl_dataset_space_wouldfree(old, new, &used, &comp, &uncomp);
5325 dsl_dataset_rele(old, FTAG);
5326 dsl_dataset_rele(new, FTAG);
5327 dsl_pool_rele(dp, FTAG);
5328 fnvlist_add_uint64(outnvl, "used", used);
5329 fnvlist_add_uint64(outnvl, "compressed", comp);
5330 fnvlist_add_uint64(outnvl, "uncompressed", uncomp);
5331 return (error);
5332 }
5333
5334 /*
5335 * innvl: {
5336 * "fd" -> file descriptor to write stream to (int32)
5337 * (optional) "fromsnap" -> full snap name to send an incremental from
5338 * (optional) "largeblockok" -> (value ignored)
5339 * indicates that blocks > 128KB are permitted
5340 * (optional) "embedok" -> (value ignored)
5341 * presence indicates DRR_WRITE_EMBEDDED records are permitted
5342 * }
5343 *
5344 * outnvl is unused
5345 */
5346 /* ARGSUSED */
5347 static int
5348 zfs_ioc_send_new(const char *snapname, nvlist_t *innvl, nvlist_t *outnvl)
5349 {
5350 int error;
5351 offset_t off;
5352 char *fromname = NULL;
5353 int fd;
5354 boolean_t largeblockok;
5355 boolean_t embedok;
5356
5357 error = nvlist_lookup_int32(innvl, "fd", &fd);
5358 if (error != 0)
5359 return (SET_ERROR(EINVAL));
5360
5361 (void) nvlist_lookup_string(innvl, "fromsnap", &fromname);
5362
5363 largeblockok = nvlist_exists(innvl, "largeblockok");
5364 embedok = nvlist_exists(innvl, "embedok");
5365
5366 file_t *fp = getf(fd);
5367 if (fp == NULL)
5368 return (SET_ERROR(EBADF));
5369
5370 off = fp->f_offset;
5371 error = dmu_send(snapname, fromname, embedok, largeblockok,
5372 fd, fp->f_vnode, &off);
5373
5374 if (VOP_SEEK(fp->f_vnode, fp->f_offset, &off, NULL) == 0)
5375 fp->f_offset = off;
5376 releasef(fd);
5377 return (error);
5378 }
5379
5380 /*
5381 * Determine approximately how large a zfs send stream will be -- the number
5382 * of bytes that will be written to the fd supplied to zfs_ioc_send_new().
5383 *
5384 * innvl: {
5385 * (optional) "from" -> full snap or bookmark name to send an incremental
5386 * from
5387 * }
5388 *
5389 * outnvl: {
5390 * "space" -> bytes of space (uint64)
5391 * }
5392 */
5393 static int
5394 zfs_ioc_send_space(const char *snapname, nvlist_t *innvl, nvlist_t *outnvl)
5395 {
5396 dsl_pool_t *dp;
5397 dsl_dataset_t *tosnap;
5398 int error;
5399 char *fromname;
5400 uint64_t space;
5401
5402 error = dsl_pool_hold(snapname, FTAG, &dp);
5403 if (error != 0)
5404 return (error);
5405
5406 error = dsl_dataset_hold(dp, snapname, FTAG, &tosnap);
5407 if (error != 0) {
5408 dsl_pool_rele(dp, FTAG);
5409 return (error);
5410 }
5411
5412 error = nvlist_lookup_string(innvl, "from", &fromname);
5413 if (error == 0) {
5414 if (strchr(fromname, '@') != NULL) {
5415 /*
5416 * If from is a snapshot, hold it and use the more
5417 * efficient dmu_send_estimate to estimate send space
5418 * size using deadlists.
5419 */
5420 dsl_dataset_t *fromsnap;
5421 error = dsl_dataset_hold(dp, fromname, FTAG, &fromsnap);
5422 if (error != 0)
5423 goto out;
5424 error = dmu_send_estimate(tosnap, fromsnap, &space);
5425 dsl_dataset_rele(fromsnap, FTAG);
5426 } else if (strchr(fromname, '#') != NULL) {
5427 /*
5428 * If from is a bookmark, fetch the creation TXG of the
5429 * snapshot it was created from and use that to find
5430 * blocks that were born after it.
5431 */
5432 zfs_bookmark_phys_t frombm;
5433
5434 error = dsl_bookmark_lookup(dp, fromname, tosnap,
5435 &frombm);
5436 if (error != 0)
5437 goto out;
5438 error = dmu_send_estimate_from_txg(tosnap,
5439 frombm.zbm_creation_txg, &space);
5440 } else {
5441 /*
5442 * from is not properly formatted as a snapshot or
5443 * bookmark
5444 */
5445 error = SET_ERROR(EINVAL);
5446 goto out;
5447 }
5448 } else {
5449 // If estimating the size of a full send, use dmu_send_estimate
5450 error = dmu_send_estimate(tosnap, NULL, &space);
5451 }
5452
5453 fnvlist_add_uint64(outnvl, "space", space);
5454
5455 out:
5456 dsl_dataset_rele(tosnap, FTAG);
5457 dsl_pool_rele(dp, FTAG);
5458 return (error);
5459 }
5460
5461 static zfs_ioc_vec_t zfs_ioc_vec[ZFS_IOC_LAST - ZFS_IOC_FIRST];
5462
5463 static void
5464 zfs_ioctl_register_legacy(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func,
5465 zfs_secpolicy_func_t *secpolicy, zfs_ioc_namecheck_t namecheck,
5466 boolean_t log_history, zfs_ioc_poolcheck_t pool_check)
5467 {
5468 zfs_ioc_vec_t *vec = &zfs_ioc_vec[ioc - ZFS_IOC_FIRST];
5469
5470 ASSERT3U(ioc, >=, ZFS_IOC_FIRST);
5471 ASSERT3U(ioc, <, ZFS_IOC_LAST);
5472 ASSERT3P(vec->zvec_legacy_func, ==, NULL);
5473 ASSERT3P(vec->zvec_func, ==, NULL);
5474
5475 vec->zvec_legacy_func = func;
5476 vec->zvec_secpolicy = secpolicy;
5477 vec->zvec_namecheck = namecheck;
5478 vec->zvec_allow_log = log_history;
5479 vec->zvec_pool_check = pool_check;
5480 }
5481
5482 /*
5483 * See the block comment at the beginning of this file for details on
5484 * each argument to this function.
5485 */
5486 static void
5487 zfs_ioctl_register(const char *name, zfs_ioc_t ioc, zfs_ioc_func_t *func,
5488 zfs_secpolicy_func_t *secpolicy, zfs_ioc_namecheck_t namecheck,
5489 zfs_ioc_poolcheck_t pool_check, boolean_t smush_outnvlist,
5490 boolean_t allow_log)
5491 {
5492 zfs_ioc_vec_t *vec = &zfs_ioc_vec[ioc - ZFS_IOC_FIRST];
5493
5494 ASSERT3U(ioc, >=, ZFS_IOC_FIRST);
5495 ASSERT3U(ioc, <, ZFS_IOC_LAST);
5496 ASSERT3P(vec->zvec_legacy_func, ==, NULL);
5497 ASSERT3P(vec->zvec_func, ==, NULL);
5498
5499 /* if we are logging, the name must be valid */
5500 ASSERT(!allow_log || namecheck != NO_NAME);
5501
5502 vec->zvec_name = name;
5503 vec->zvec_func = func;
5504 vec->zvec_secpolicy = secpolicy;
5505 vec->zvec_namecheck = namecheck;
5506 vec->zvec_pool_check = pool_check;
5507 vec->zvec_smush_outnvlist = smush_outnvlist;
5508 vec->zvec_allow_log = allow_log;
5509 }
5510
5511 static void
5512 zfs_ioctl_register_pool(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func,
5513 zfs_secpolicy_func_t *secpolicy, boolean_t log_history,
5514 zfs_ioc_poolcheck_t pool_check)
5515 {
5516 zfs_ioctl_register_legacy(ioc, func, secpolicy,
5517 POOL_NAME, log_history, pool_check);
5518 }
5519
5520 static void
5521 zfs_ioctl_register_dataset_nolog(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func,
5522 zfs_secpolicy_func_t *secpolicy, zfs_ioc_poolcheck_t pool_check)
5523 {
5524 zfs_ioctl_register_legacy(ioc, func, secpolicy,
5525 DATASET_NAME, B_FALSE, pool_check);
5526 }
5527
5528 static void
5529 zfs_ioctl_register_pool_modify(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func)
5530 {
5531 zfs_ioctl_register_legacy(ioc, func, zfs_secpolicy_config,
5532 POOL_NAME, B_TRUE, POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY);
5533 }
5534
5535 static void
5536 zfs_ioctl_register_pool_meta(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func,
5537 zfs_secpolicy_func_t *secpolicy)
5538 {
5539 zfs_ioctl_register_legacy(ioc, func, secpolicy,
5540 NO_NAME, B_FALSE, POOL_CHECK_NONE);
5541 }
5542
5543 static void
5544 zfs_ioctl_register_dataset_read_secpolicy(zfs_ioc_t ioc,
5545 zfs_ioc_legacy_func_t *func, zfs_secpolicy_func_t *secpolicy)
5546 {
5547 zfs_ioctl_register_legacy(ioc, func, secpolicy,
5548 DATASET_NAME, B_FALSE, POOL_CHECK_SUSPENDED);
5549 }
5550
5551 static void
5552 zfs_ioctl_register_dataset_read(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func)
5553 {
5554 zfs_ioctl_register_dataset_read_secpolicy(ioc, func,
5555 zfs_secpolicy_read);
5556 }
5557
5558 static void
5559 zfs_ioctl_register_dataset_modify(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func,
5560 zfs_secpolicy_func_t *secpolicy)
5561 {
5562 zfs_ioctl_register_legacy(ioc, func, secpolicy,
5563 DATASET_NAME, B_TRUE, POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY);
5564 }
5565
5566 static void
5567 zfs_ioctl_init(void)
5568 {
5569 zfs_ioctl_register("snapshot", ZFS_IOC_SNAPSHOT,
5570 zfs_ioc_snapshot, zfs_secpolicy_snapshot, POOL_NAME,
5571 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE);
5572
5573 zfs_ioctl_register("log_history", ZFS_IOC_LOG_HISTORY,
5574 zfs_ioc_log_history, zfs_secpolicy_log_history, NO_NAME,
5575 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_FALSE, B_FALSE);
5576
5577 zfs_ioctl_register("space_snaps", ZFS_IOC_SPACE_SNAPS,
5578 zfs_ioc_space_snaps, zfs_secpolicy_read, DATASET_NAME,
5579 POOL_CHECK_SUSPENDED, B_FALSE, B_FALSE);
5580
5581 zfs_ioctl_register("send", ZFS_IOC_SEND_NEW,
5582 zfs_ioc_send_new, zfs_secpolicy_send_new, DATASET_NAME,
5583 POOL_CHECK_SUSPENDED, B_FALSE, B_FALSE);
5584
5585 zfs_ioctl_register("send_space", ZFS_IOC_SEND_SPACE,
5586 zfs_ioc_send_space, zfs_secpolicy_read, DATASET_NAME,
5587 POOL_CHECK_SUSPENDED, B_FALSE, B_FALSE);
5588
5589 zfs_ioctl_register("create", ZFS_IOC_CREATE,
5590 zfs_ioc_create, zfs_secpolicy_create_clone, DATASET_NAME,
5591 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE);
5592
5593 zfs_ioctl_register("clone", ZFS_IOC_CLONE,
5594 zfs_ioc_clone, zfs_secpolicy_create_clone, DATASET_NAME,
5595 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE);
5596
5597 zfs_ioctl_register("destroy_snaps", ZFS_IOC_DESTROY_SNAPS,
5598 zfs_ioc_destroy_snaps, zfs_secpolicy_destroy_snaps, POOL_NAME,
5599 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE);
5600
5601 zfs_ioctl_register("hold", ZFS_IOC_HOLD,
5602 zfs_ioc_hold, zfs_secpolicy_hold, POOL_NAME,
5603 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE);
5604 zfs_ioctl_register("release", ZFS_IOC_RELEASE,
5605 zfs_ioc_release, zfs_secpolicy_release, POOL_NAME,
5606 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE);
5607
5608 zfs_ioctl_register("get_holds", ZFS_IOC_GET_HOLDS,
5609 zfs_ioc_get_holds, zfs_secpolicy_read, DATASET_NAME,
5610 POOL_CHECK_SUSPENDED, B_FALSE, B_FALSE);
5611
5612 zfs_ioctl_register("rollback", ZFS_IOC_ROLLBACK,
5613 zfs_ioc_rollback, zfs_secpolicy_rollback, DATASET_NAME,
5614 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_FALSE, B_TRUE);
5615
5616 zfs_ioctl_register("bookmark", ZFS_IOC_BOOKMARK,
5617 zfs_ioc_bookmark, zfs_secpolicy_bookmark, POOL_NAME,
5618 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE);
5619
5620 zfs_ioctl_register("get_bookmarks", ZFS_IOC_GET_BOOKMARKS,
5621 zfs_ioc_get_bookmarks, zfs_secpolicy_read, DATASET_NAME,
5622 POOL_CHECK_SUSPENDED, B_FALSE, B_FALSE);
5623
5624 zfs_ioctl_register("destroy_bookmarks", ZFS_IOC_DESTROY_BOOKMARKS,
5625 zfs_ioc_destroy_bookmarks, zfs_secpolicy_destroy_bookmarks,
5626 POOL_NAME,
5627 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE);
5628
5629 /* IOCTLS that use the legacy function signature */
5630
5631 zfs_ioctl_register_legacy(ZFS_IOC_POOL_FREEZE, zfs_ioc_pool_freeze,
5632 zfs_secpolicy_config, NO_NAME, B_FALSE, POOL_CHECK_READONLY);
5633
5634 zfs_ioctl_register_pool(ZFS_IOC_POOL_CREATE, zfs_ioc_pool_create,
5635 zfs_secpolicy_config, B_TRUE, POOL_CHECK_NONE);
5636 zfs_ioctl_register_pool_modify(ZFS_IOC_POOL_SCAN,
5637 zfs_ioc_pool_scan);
5638 zfs_ioctl_register_pool_modify(ZFS_IOC_POOL_UPGRADE,
5639 zfs_ioc_pool_upgrade);
5640 zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_ADD,
5641 zfs_ioc_vdev_add);
5642 zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_REMOVE,
5643 zfs_ioc_vdev_remove);
5644 zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_SET_STATE,
5645 zfs_ioc_vdev_set_state);
5646 zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_ATTACH,
5647 zfs_ioc_vdev_attach);
5648 zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_DETACH,
5649 zfs_ioc_vdev_detach);
5650 zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_SETPATH,
5651 zfs_ioc_vdev_setpath);
5652 zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_SETFRU,
5653 zfs_ioc_vdev_setfru);
5654 zfs_ioctl_register_pool_modify(ZFS_IOC_POOL_SET_PROPS,
5655 zfs_ioc_pool_set_props);
5656 zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_SPLIT,
5657 zfs_ioc_vdev_split);
5658 zfs_ioctl_register_pool_modify(ZFS_IOC_POOL_REGUID,
5659 zfs_ioc_pool_reguid);
5660
5661 zfs_ioctl_register_pool_meta(ZFS_IOC_POOL_CONFIGS,
5662 zfs_ioc_pool_configs, zfs_secpolicy_none);
5663 zfs_ioctl_register_pool_meta(ZFS_IOC_POOL_TRYIMPORT,
5664 zfs_ioc_pool_tryimport, zfs_secpolicy_config);
5665 zfs_ioctl_register_pool_meta(ZFS_IOC_INJECT_FAULT,
5666 zfs_ioc_inject_fault, zfs_secpolicy_inject);
5667 zfs_ioctl_register_pool_meta(ZFS_IOC_CLEAR_FAULT,
5668 zfs_ioc_clear_fault, zfs_secpolicy_inject);
5669 zfs_ioctl_register_pool_meta(ZFS_IOC_INJECT_LIST_NEXT,
5670 zfs_ioc_inject_list_next, zfs_secpolicy_inject);
5671
5672 /*
5673 * pool destroy, and export don't log the history as part of
5674 * zfsdev_ioctl, but rather zfs_ioc_pool_export
5675 * does the logging of those commands.
5676 */
5677 zfs_ioctl_register_pool(ZFS_IOC_POOL_DESTROY, zfs_ioc_pool_destroy,
5678 zfs_secpolicy_config, B_FALSE, POOL_CHECK_NONE);
5679 zfs_ioctl_register_pool(ZFS_IOC_POOL_EXPORT, zfs_ioc_pool_export,
5680 zfs_secpolicy_config, B_FALSE, POOL_CHECK_NONE);
5681
5682 zfs_ioctl_register_pool(ZFS_IOC_POOL_STATS, zfs_ioc_pool_stats,
5683 zfs_secpolicy_read, B_FALSE, POOL_CHECK_NONE);
5684 zfs_ioctl_register_pool(ZFS_IOC_POOL_GET_PROPS, zfs_ioc_pool_get_props,
5685 zfs_secpolicy_read, B_FALSE, POOL_CHECK_NONE);
5686
5687 zfs_ioctl_register_pool(ZFS_IOC_ERROR_LOG, zfs_ioc_error_log,
5688 zfs_secpolicy_inject, B_FALSE, POOL_CHECK_SUSPENDED);
5689 zfs_ioctl_register_pool(ZFS_IOC_DSOBJ_TO_DSNAME,
5690 zfs_ioc_dsobj_to_dsname,
5691 zfs_secpolicy_diff, B_FALSE, POOL_CHECK_SUSPENDED);
5692 zfs_ioctl_register_pool(ZFS_IOC_POOL_GET_HISTORY,
5693 zfs_ioc_pool_get_history,
5694 zfs_secpolicy_config, B_FALSE, POOL_CHECK_SUSPENDED);
5695
5696 zfs_ioctl_register_pool(ZFS_IOC_POOL_IMPORT, zfs_ioc_pool_import,
5697 zfs_secpolicy_config, B_TRUE, POOL_CHECK_NONE);
5698
5699 zfs_ioctl_register_pool(ZFS_IOC_CLEAR, zfs_ioc_clear,
5700 zfs_secpolicy_config, B_TRUE, POOL_CHECK_NONE);
5701 zfs_ioctl_register_pool(ZFS_IOC_POOL_REOPEN, zfs_ioc_pool_reopen,
5702 zfs_secpolicy_config, B_TRUE, POOL_CHECK_SUSPENDED);
5703
5704 zfs_ioctl_register_dataset_read(ZFS_IOC_SPACE_WRITTEN,
5705 zfs_ioc_space_written);
5706 zfs_ioctl_register_dataset_read(ZFS_IOC_OBJSET_RECVD_PROPS,
5707 zfs_ioc_objset_recvd_props);
5708 zfs_ioctl_register_dataset_read(ZFS_IOC_NEXT_OBJ,
5709 zfs_ioc_next_obj);
5710 zfs_ioctl_register_dataset_read(ZFS_IOC_GET_FSACL,
5711 zfs_ioc_get_fsacl);
5712 zfs_ioctl_register_dataset_read(ZFS_IOC_OBJSET_STATS,
5713 zfs_ioc_objset_stats);
5714 zfs_ioctl_register_dataset_read(ZFS_IOC_OBJSET_ZPLPROPS,
5715 zfs_ioc_objset_zplprops);
5716 zfs_ioctl_register_dataset_read(ZFS_IOC_DATASET_LIST_NEXT,
5717 zfs_ioc_dataset_list_next);
5718 zfs_ioctl_register_dataset_read(ZFS_IOC_SNAPSHOT_LIST_NEXT,
5719 zfs_ioc_snapshot_list_next);
5720 zfs_ioctl_register_dataset_read(ZFS_IOC_SEND_PROGRESS,
5721 zfs_ioc_send_progress);
5722
5723 zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_DIFF,
5724 zfs_ioc_diff, zfs_secpolicy_diff);
5725 zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_OBJ_TO_STATS,
5726 zfs_ioc_obj_to_stats, zfs_secpolicy_diff);
5727 zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_OBJ_TO_PATH,
5728 zfs_ioc_obj_to_path, zfs_secpolicy_diff);
5729 zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_USERSPACE_ONE,
5730 zfs_ioc_userspace_one, zfs_secpolicy_userspace_one);
5731 zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_USERSPACE_MANY,
5732 zfs_ioc_userspace_many, zfs_secpolicy_userspace_many);
5733 zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_SEND,
5734 zfs_ioc_send, zfs_secpolicy_send);
5735
5736 zfs_ioctl_register_dataset_modify(ZFS_IOC_SET_PROP, zfs_ioc_set_prop,
5737 zfs_secpolicy_none);
5738 zfs_ioctl_register_dataset_modify(ZFS_IOC_DESTROY, zfs_ioc_destroy,
5739 zfs_secpolicy_destroy);
5740 zfs_ioctl_register_dataset_modify(ZFS_IOC_RENAME, zfs_ioc_rename,
5741 zfs_secpolicy_rename);
5742 zfs_ioctl_register_dataset_modify(ZFS_IOC_RECV, zfs_ioc_recv,
5743 zfs_secpolicy_recv);
5744 zfs_ioctl_register_dataset_modify(ZFS_IOC_PROMOTE, zfs_ioc_promote,
5745 zfs_secpolicy_promote);
5746 zfs_ioctl_register_dataset_modify(ZFS_IOC_INHERIT_PROP,
5747 zfs_ioc_inherit_prop, zfs_secpolicy_inherit_prop);
5748 zfs_ioctl_register_dataset_modify(ZFS_IOC_SET_FSACL, zfs_ioc_set_fsacl,
5749 zfs_secpolicy_set_fsacl);
5750
5751 zfs_ioctl_register_dataset_nolog(ZFS_IOC_SHARE, zfs_ioc_share,
5752 zfs_secpolicy_share, POOL_CHECK_NONE);
5753 zfs_ioctl_register_dataset_nolog(ZFS_IOC_SMB_ACL, zfs_ioc_smb_acl,
5754 zfs_secpolicy_smb_acl, POOL_CHECK_NONE);
5755 zfs_ioctl_register_dataset_nolog(ZFS_IOC_USERSPACE_UPGRADE,
5756 zfs_ioc_userspace_upgrade, zfs_secpolicy_userspace_upgrade,
5757 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY);
5758 zfs_ioctl_register_dataset_nolog(ZFS_IOC_TMP_SNAPSHOT,
5759 zfs_ioc_tmp_snapshot, zfs_secpolicy_tmp_snapshot,
5760 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY);
5761 }
5762
5763 int
5764 pool_status_check(const char *name, zfs_ioc_namecheck_t type,
5765 zfs_ioc_poolcheck_t check)
5766 {
5767 spa_t *spa;
5768 int error;
5769
5770 ASSERT(type == POOL_NAME || type == DATASET_NAME);
5771
5772 if (check & POOL_CHECK_NONE)
5773 return (0);
5774
5775 error = spa_open(name, &spa, FTAG);
5776 if (error == 0) {
5777 if ((check & POOL_CHECK_SUSPENDED) && spa_suspended(spa))
5778 error = SET_ERROR(EAGAIN);
5779 else if ((check & POOL_CHECK_READONLY) && !spa_writeable(spa))
5780 error = SET_ERROR(EROFS);
5781 spa_close(spa, FTAG);
5782 }
5783 return (error);
5784 }
5785
5786 /*
5787 * Find a free minor number.
5788 */
5789 minor_t
5790 zfsdev_minor_alloc(void)
5791 {
5792 static minor_t last_minor;
5793 minor_t m;
5794
5795 ASSERT(MUTEX_HELD(&zfsdev_state_lock));
5796
5797 for (m = last_minor + 1; m != last_minor; m++) {
5798 if (m > ZFSDEV_MAX_MINOR)
5799 m = 1;
5800 if (ddi_get_soft_state(zfsdev_state, m) == NULL) {
5801 last_minor = m;
5802 return (m);
5803 }
5804 }
5805
5806 return (0);
5807 }
5808
5809 static int
5810 zfs_ctldev_init(dev_t *devp)
5811 {
5812 minor_t minor;
5813 zfs_soft_state_t *zs;
5814
5815 ASSERT(MUTEX_HELD(&zfsdev_state_lock));
5816 ASSERT(getminor(*devp) == 0);
5817
5818 minor = zfsdev_minor_alloc();
5819 if (minor == 0)
5820 return (SET_ERROR(ENXIO));
5821
5822 if (ddi_soft_state_zalloc(zfsdev_state, minor) != DDI_SUCCESS)
5823 return (SET_ERROR(EAGAIN));
5824
5825 *devp = makedevice(getemajor(*devp), minor);
5826
5827 zs = ddi_get_soft_state(zfsdev_state, minor);
5828 zs->zss_type = ZSST_CTLDEV;
5829 zfs_onexit_init((zfs_onexit_t **)&zs->zss_data);
5830
5831 return (0);
5832 }
5833
5834 static void
5835 zfs_ctldev_destroy(zfs_onexit_t *zo, minor_t minor)
5836 {
5837 ASSERT(MUTEX_HELD(&zfsdev_state_lock));
5838
5839 zfs_onexit_destroy(zo);
5840 ddi_soft_state_free(zfsdev_state, minor);
5841 }
5842
5843 void *
5844 zfsdev_get_soft_state(minor_t minor, enum zfs_soft_state_type which)
5845 {
5846 zfs_soft_state_t *zp;
5847
5848 zp = ddi_get_soft_state(zfsdev_state, minor);
5849 if (zp == NULL || zp->zss_type != which)
5850 return (NULL);
5851
5852 return (zp->zss_data);
5853 }
5854
5855 static int
5856 zfsdev_open(dev_t *devp, int flag, int otyp, cred_t *cr)
5857 {
5858 int error = 0;
5859
5860 if (getminor(*devp) != 0)
5861 return (zvol_open(devp, flag, otyp, cr));
5862
5863 /* This is the control device. Allocate a new minor if requested. */
5864 if (flag & FEXCL) {
5865 mutex_enter(&zfsdev_state_lock);
5866 error = zfs_ctldev_init(devp);
5867 mutex_exit(&zfsdev_state_lock);
5868 }
5869
5870 return (error);
5871 }
5872
5873 static int
5874 zfsdev_close(dev_t dev, int flag, int otyp, cred_t *cr)
5875 {
5876 zfs_onexit_t *zo;
5877 minor_t minor = getminor(dev);
5878
5879 if (minor == 0)
5880 return (0);
5881
5882 mutex_enter(&zfsdev_state_lock);
5883 zo = zfsdev_get_soft_state(minor, ZSST_CTLDEV);
5884 if (zo == NULL) {
5885 mutex_exit(&zfsdev_state_lock);
5886 return (zvol_close(dev, flag, otyp, cr));
5887 }
5888 zfs_ctldev_destroy(zo, minor);
5889 mutex_exit(&zfsdev_state_lock);
5890
5891 return (0);
5892 }
5893
5894 static int
5895 zfsdev_ioctl(dev_t dev, int cmd, intptr_t arg, int flag, cred_t *cr, int *rvalp)
5896 {
5897 zfs_cmd_t *zc;
5898 uint_t vecnum;
5899 int error, rc, len;
5900 minor_t minor = getminor(dev);
5901 const zfs_ioc_vec_t *vec;
5902 char *saved_poolname = NULL;
5903 nvlist_t *innvl = NULL;
5904
5905 if (minor != 0 &&
5906 zfsdev_get_soft_state(minor, ZSST_CTLDEV) == NULL)
5907 return (zvol_ioctl(dev, cmd, arg, flag, cr, rvalp));
5908
5909 vecnum = cmd - ZFS_IOC_FIRST;
5910 ASSERT3U(getmajor(dev), ==, ddi_driver_major(zfs_dip));
5911
5912 if (vecnum >= sizeof (zfs_ioc_vec) / sizeof (zfs_ioc_vec[0]))
5913 return (SET_ERROR(EINVAL));
5914 vec = &zfs_ioc_vec[vecnum];
5915
5916 zc = kmem_zalloc(sizeof (zfs_cmd_t), KM_SLEEP);
5917
5918 error = ddi_copyin((void *)arg, zc, sizeof (zfs_cmd_t), flag);
5919 if (error != 0) {
5920 error = SET_ERROR(EFAULT);
5921 goto out;
5922 }
5923
5924 zc->zc_iflags = flag & FKIOCTL;
5925 if (zc->zc_nvlist_src_size != 0) {
5926 error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
5927 zc->zc_iflags, &innvl);
5928 if (error != 0)
5929 goto out;
5930 }
5931
5932 /*
5933 * Ensure that all pool/dataset names are valid before we pass down to
5934 * the lower layers.
5935 */
5936 zc->zc_name[sizeof (zc->zc_name) - 1] = '\0';
5937 switch (vec->zvec_namecheck) {
5938 case POOL_NAME:
5939 if (pool_namecheck(zc->zc_name, NULL, NULL) != 0)
5940 error = SET_ERROR(EINVAL);
5941 else
5942 error = pool_status_check(zc->zc_name,
5943 vec->zvec_namecheck, vec->zvec_pool_check);
5944 break;
5945
5946 case DATASET_NAME:
5947 if (dataset_namecheck(zc->zc_name, NULL, NULL) != 0)
5948 error = SET_ERROR(EINVAL);
5949 else
5950 error = pool_status_check(zc->zc_name,
5951 vec->zvec_namecheck, vec->zvec_pool_check);
5952 break;
5953
5954 case NO_NAME:
5955 break;
5956 }
5957
5958
5959 if (error == 0 && !(flag & FKIOCTL))
5960 error = vec->zvec_secpolicy(zc, innvl, cr);
5961
5962 if (error != 0)
5963 goto out;
5964
5965 /* legacy ioctls can modify zc_name */
5966 len = strcspn(zc->zc_name, "/@#") + 1;
5967 saved_poolname = kmem_alloc(len, KM_SLEEP);
5968 (void) strlcpy(saved_poolname, zc->zc_name, len);
5969
5970 if (vec->zvec_func != NULL) {
5971 nvlist_t *outnvl;
5972 int puterror = 0;
5973 spa_t *spa;
5974 nvlist_t *lognv = NULL;
5975
5976 ASSERT(vec->zvec_legacy_func == NULL);
5977
5978 /*
5979 * Add the innvl to the lognv before calling the func,
5980 * in case the func changes the innvl.
5981 */
5982 if (vec->zvec_allow_log) {
5983 lognv = fnvlist_alloc();
5984 fnvlist_add_string(lognv, ZPOOL_HIST_IOCTL,
5985 vec->zvec_name);
5986 if (!nvlist_empty(innvl)) {
5987 fnvlist_add_nvlist(lognv, ZPOOL_HIST_INPUT_NVL,
5988 innvl);
5989 }
5990 }
5991
5992 outnvl = fnvlist_alloc();
5993 error = vec->zvec_func(zc->zc_name, innvl, outnvl);
5994
5995 if (error == 0 && vec->zvec_allow_log &&
5996 spa_open(zc->zc_name, &spa, FTAG) == 0) {
5997 if (!nvlist_empty(outnvl)) {
5998 fnvlist_add_nvlist(lognv, ZPOOL_HIST_OUTPUT_NVL,
5999 outnvl);
6000 }
6001 (void) spa_history_log_nvl(spa, lognv);
6002 spa_close(spa, FTAG);
6003 }
6004 fnvlist_free(lognv);
6005
6006 if (!nvlist_empty(outnvl) || zc->zc_nvlist_dst_size != 0) {
6007 int smusherror = 0;
6008 if (vec->zvec_smush_outnvlist) {
6009 smusherror = nvlist_smush(outnvl,
6010 zc->zc_nvlist_dst_size);
6011 }
6012 if (smusherror == 0)
6013 puterror = put_nvlist(zc, outnvl);
6014 }
6015
6016 if (puterror != 0)
6017 error = puterror;
6018
6019 nvlist_free(outnvl);
6020 } else {
6021 error = vec->zvec_legacy_func(zc);
6022 }
6023
6024 out:
6025 nvlist_free(innvl);
6026 rc = ddi_copyout(zc, (void *)arg, sizeof (zfs_cmd_t), flag);
6027 if (error == 0 && rc != 0)
6028 error = SET_ERROR(EFAULT);
6029 if (error == 0 && vec->zvec_allow_log) {
6030 char *s = tsd_get(zfs_allow_log_key);
6031 if (s != NULL)
6032 strfree(s);
6033 (void) tsd_set(zfs_allow_log_key, saved_poolname);
6034 } else {
6035 if (saved_poolname != NULL)
6036 strfree(saved_poolname);
6037 }
6038
6039 kmem_free(zc, sizeof (zfs_cmd_t));
6040 return (error);
6041 }
6042
6043 static int
6044 zfs_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
6045 {
6046 if (cmd != DDI_ATTACH)
6047 return (DDI_FAILURE);
6048
6049 if (ddi_create_minor_node(dip, "zfs", S_IFCHR, 0,
6050 DDI_PSEUDO, 0) == DDI_FAILURE)
6051 return (DDI_FAILURE);
6052
6053 zfs_dip = dip;
6054
6055 ddi_report_dev(dip);
6056
6057 return (DDI_SUCCESS);
6058 }
6059
6060 static int
6061 zfs_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
6062 {
6063 if (spa_busy() || zfs_busy() || zvol_busy())
6064 return (DDI_FAILURE);
6065
6066 if (cmd != DDI_DETACH)
6067 return (DDI_FAILURE);
6068
6069 zfs_dip = NULL;
6070
6071 ddi_prop_remove_all(dip);
6072 ddi_remove_minor_node(dip, NULL);
6073
6074 return (DDI_SUCCESS);
6075 }
6076
6077 /*ARGSUSED*/
6078 static int
6079 zfs_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
6080 {
6081 switch (infocmd) {
6082 case DDI_INFO_DEVT2DEVINFO:
6083 *result = zfs_dip;
6084 return (DDI_SUCCESS);
6085
6086 case DDI_INFO_DEVT2INSTANCE:
6087 *result = (void *)0;
6088 return (DDI_SUCCESS);
6089 }
6090
6091 return (DDI_FAILURE);
6092 }
6093
6094 /*
6095 * OK, so this is a little weird.
6096 *
6097 * /dev/zfs is the control node, i.e. minor 0.
6098 * /dev/zvol/[r]dsk/pool/dataset are the zvols, minor > 0.
6099 *
6100 * /dev/zfs has basically nothing to do except serve up ioctls,
6101 * so most of the standard driver entry points are in zvol.c.
6102 */
6103 static struct cb_ops zfs_cb_ops = {
6104 zfsdev_open, /* open */
6105 zfsdev_close, /* close */
6106 zvol_strategy, /* strategy */
6107 nodev, /* print */
6108 zvol_dump, /* dump */
6109 zvol_read, /* read */
6110 zvol_write, /* write */
6111 zfsdev_ioctl, /* ioctl */
6112 nodev, /* devmap */
6113 nodev, /* mmap */
6114 nodev, /* segmap */
6115 nochpoll, /* poll */
6116 ddi_prop_op, /* prop_op */
6117 NULL, /* streamtab */
6118 D_NEW | D_MP | D_64BIT, /* Driver compatibility flag */
6119 CB_REV, /* version */
6120 nodev, /* async read */
6121 nodev, /* async write */
6122 };
6123
6124 static struct dev_ops zfs_dev_ops = {
6125 DEVO_REV, /* version */
6126 0, /* refcnt */
6127 zfs_info, /* info */
6128 nulldev, /* identify */
6129 nulldev, /* probe */
6130 zfs_attach, /* attach */
6131 zfs_detach, /* detach */
6132 nodev, /* reset */
6133 &zfs_cb_ops, /* driver operations */
6134 NULL, /* no bus operations */
6135 NULL, /* power */
6136 ddi_quiesce_not_needed, /* quiesce */
6137 };
6138
6139 static struct modldrv zfs_modldrv = {
6140 &mod_driverops,
6141 "ZFS storage pool",
6142 &zfs_dev_ops
6143 };
6144
6145 static struct modlinkage modlinkage = {
6146 MODREV_1,
6147 (void *)&zfs_modlfs,
6148 (void *)&zfs_modldrv,
6149 NULL
6150 };
6151
6152 static void
6153 zfs_allow_log_destroy(void *arg)
6154 {
6155 char *poolname = arg;
6156 strfree(poolname);
6157 }
6158
6159 int
6160 _init(void)
6161 {
6162 int error;
6163
6164 spa_init(FREAD | FWRITE);
6165 zfs_init();
6166 zvol_init();
6167 zfs_ioctl_init();
6168
6169 if ((error = mod_install(&modlinkage)) != 0) {
6170 zvol_fini();
6171 zfs_fini();
6172 spa_fini();
6173 return (error);
6174 }
6175
6176 tsd_create(&zfs_fsyncer_key, NULL);
6177 tsd_create(&rrw_tsd_key, rrw_tsd_destroy);
6178 tsd_create(&zfs_allow_log_key, zfs_allow_log_destroy);
6179
6180 error = ldi_ident_from_mod(&modlinkage, &zfs_li);
6181 ASSERT(error == 0);
6182 mutex_init(&zfs_share_lock, NULL, MUTEX_DEFAULT, NULL);
6183
6184 return (0);
6185 }
6186
6187 int
6188 _fini(void)
6189 {
6190 int error;
6191
6192 if (spa_busy() || zfs_busy() || zvol_busy() || zio_injection_enabled)
6193 return (SET_ERROR(EBUSY));
6194
6195 if ((error = mod_remove(&modlinkage)) != 0)
6196 return (error);
6197
6198 zvol_fini();
6199 zfs_fini();
6200 spa_fini();
6201 if (zfs_nfsshare_inited)
6202 (void) ddi_modclose(nfs_mod);
6203 if (zfs_smbshare_inited)
6204 (void) ddi_modclose(smbsrv_mod);
6205 if (zfs_nfsshare_inited || zfs_smbshare_inited)
6206 (void) ddi_modclose(sharefs_mod);
6207
6208 tsd_destroy(&zfs_fsyncer_key);
6209 ldi_ident_release(zfs_li);
6210 zfs_li = NULL;
6211 mutex_destroy(&zfs_share_lock);
6212
6213 return (error);
6214 }
6215
6216 int
6217 _info(struct modinfo *modinfop)
6218 {
6219 return (mod_info(&modlinkage, modinfop));
6220 }