]> git.proxmox.com Git - mirror_zfs.git/blob - module/zfs/zfs_ioctl.c
projects / mirror_zfs.git / blob
? search:


49ee5526520e2ad1263327e13bc08ea37fa5729e
[mirror_zfs.git] / module / zfs / zfs_ioctl.c
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 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #include <sys/types.h>
27 #include <sys/param.h>
28 #include <sys/errno.h>
29 #include <sys/uio.h>
30 #include <sys/buf.h>
31 #include <sys/modctl.h>
32 #include <sys/open.h>
33 #include <sys/file.h>
34 #include <sys/kmem.h>
35 #include <sys/conf.h>
36 #include <sys/cmn_err.h>
37 #include <sys/stat.h>
38 #include <sys/zfs_ioctl.h>
39 #include <sys/zfs_znode.h>
40 #include <sys/zap.h>
41 #include <sys/spa.h>
42 #include <sys/spa_impl.h>
43 #include <sys/vdev.h>
44 #include <sys/vdev_impl.h>
45 #include <sys/dmu.h>
46 #include <sys/dsl_dir.h>
47 #include <sys/dsl_dataset.h>
48 #include <sys/dsl_prop.h>
49 #include <sys/dsl_deleg.h>
50 #include <sys/dmu_objset.h>
51 #include <sys/ddi.h>
52 #include <sys/sunddi.h>
53 #include <sys/sunldi.h>
54 #include <sys/policy.h>
55 #include <sys/zone.h>
56 #include <sys/nvpair.h>
57 #include <sys/pathname.h>
58 #include <sys/mount.h>
59 #include <sys/sdt.h>
60 #include <sys/fs/zfs.h>
61 #include <sys/zfs_ctldir.h>
62 #include <sys/zfs_dir.h>
63 #include <sys/zvol.h>
64 #include <sharefs/share.h>
65 #include <sys/dmu_objset.h>
66
67 #include "zfs_namecheck.h"
68 #include "zfs_prop.h"
69 #include "zfs_deleg.h"
70
71 extern struct modlfs zfs_modlfs;
72
73 extern void zfs_init(void);
74 extern void zfs_fini(void);
75
76 ldi_ident_t zfs_li = NULL;
77 dev_info_t *zfs_dip;
78
79 typedef int zfs_ioc_func_t(zfs_cmd_t *);
80 typedef int zfs_secpolicy_func_t(zfs_cmd_t *, cred_t *);
81
82 typedef struct zfs_ioc_vec {
83 zfs_ioc_func_t *zvec_func;
84 zfs_secpolicy_func_t *zvec_secpolicy;
85 enum {
86 NO_NAME,
87 POOL_NAME,
88 DATASET_NAME
89 } zvec_namecheck;
90 boolean_t zvec_his_log;
91 } zfs_ioc_vec_t;
92
93 static void clear_props(char *dataset, nvlist_t *props);
94 static int zfs_fill_zplprops_root(uint64_t, nvlist_t *, nvlist_t *,
95 boolean_t *);
96 int zfs_set_prop_nvlist(const char *, nvlist_t *);
97
98 /* _NOTE(PRINTFLIKE(4)) - this is printf-like, but lint is too whiney */
99 void
100 __dprintf(const char *file, const char *func, int line, const char *fmt, ...)
101 {
102 const char *newfile;
103 char buf[256];
104 va_list adx;
105
106 /*
107 * Get rid of annoying "../common/" prefix to filename.
108 */
109 newfile = strrchr(file, '/');
110 if (newfile != NULL) {
111 newfile = newfile + 1; /* Get rid of leading / */
112 } else {
113 newfile = file;
114 }
115
116 va_start(adx, fmt);
117 (void) vsnprintf(buf, sizeof (buf), fmt, adx);
118 va_end(adx);
119
120 /*
121 * To get this data, use the zfs-dprintf probe as so:
122 * dtrace -q -n 'zfs-dprintf \
123 * /stringof(arg0) == "dbuf.c"/ \
124 * {printf("%s: %s", stringof(arg1), stringof(arg3))}'
125 * arg0 = file name
126 * arg1 = function name
127 * arg2 = line number
128 * arg3 = message
129 */
130 DTRACE_PROBE4(zfs__dprintf,
131 char *, newfile, char *, func, int, line, char *, buf);
132 }
133
134 static void
135 history_str_free(char *buf)
136 {
137 kmem_free(buf, HIS_MAX_RECORD_LEN);
138 }
139
140 static char *
141 history_str_get(zfs_cmd_t *zc)
142 {
143 char *buf;
144
145 if (zc->zc_history == NULL)
146 return (NULL);
147
148 buf = kmem_alloc(HIS_MAX_RECORD_LEN, KM_SLEEP);
149 if (copyinstr((void *)(uintptr_t)zc->zc_history,
150 buf, HIS_MAX_RECORD_LEN, NULL) != 0) {
151 history_str_free(buf);
152 return (NULL);
153 }
154
155 buf[HIS_MAX_RECORD_LEN -1] = '\0';
156
157 return (buf);
158 }
159
160 /*
161 * Check to see if the named dataset is currently defined as bootable
162 */
163 static boolean_t
164 zfs_is_bootfs(const char *name)
165 {
166 spa_t *spa;
167 boolean_t ret = B_FALSE;
168
169 if (spa_open(name, &spa, FTAG) == 0) {
170 if (spa->spa_bootfs) {
171 objset_t *os;
172
173 if (dmu_objset_open(name, DMU_OST_ZFS,
174 DS_MODE_USER | DS_MODE_READONLY, &os) == 0) {
175 ret = (dmu_objset_id(os) == spa->spa_bootfs);
176 dmu_objset_close(os);
177 }
178 }
179 spa_close(spa, FTAG);
180 }
181 return (ret);
182 }
183
184 /*
185 * zfs_earlier_version
186 *
187 * Return non-zero if the spa version is less than requested version.
188 */
189 static int
190 zfs_earlier_version(const char *name, int version)
191 {
192 spa_t *spa;
193
194 if (spa_open(name, &spa, FTAG) == 0) {
195 if (spa_version(spa) < version) {
196 spa_close(spa, FTAG);
197 return (1);
198 }
199 spa_close(spa, FTAG);
200 }
201 return (0);
202 }
203
204 /*
205 * zpl_earlier_version
206 *
207 * Return TRUE if the ZPL version is less than requested version.
208 */
209 static boolean_t
210 zpl_earlier_version(const char *name, int version)
211 {
212 objset_t *os;
213 boolean_t rc = B_TRUE;
214
215 if (dmu_objset_open(name, DMU_OST_ANY,
216 DS_MODE_USER | DS_MODE_READONLY, &os) == 0) {
217 uint64_t zplversion;
218
219 if (zfs_get_zplprop(os, ZFS_PROP_VERSION, &zplversion) == 0)
220 rc = zplversion < version;
221 dmu_objset_close(os);
222 }
223 return (rc);
224 }
225
226 static void
227 zfs_log_history(zfs_cmd_t *zc)
228 {
229 spa_t *spa;
230 char *buf;
231
232 if ((buf = history_str_get(zc)) == NULL)
233 return;
234
235 if (spa_open(zc->zc_name, &spa, FTAG) == 0) {
236 if (spa_version(spa) >= SPA_VERSION_ZPOOL_HISTORY)
237 (void) spa_history_log(spa, buf, LOG_CMD_NORMAL);
238 spa_close(spa, FTAG);
239 }
240 history_str_free(buf);
241 }
242
243 /*
244 * Policy for top-level read operations (list pools). Requires no privileges,
245 * and can be used in the local zone, as there is no associated dataset.
246 */
247 /* ARGSUSED */
248 static int
249 zfs_secpolicy_none(zfs_cmd_t *zc, cred_t *cr)
250 {
251 return (0);
252 }
253
254 /*
255 * Policy for dataset read operations (list children, get statistics). Requires
256 * no privileges, but must be visible in the local zone.
257 */
258 /* ARGSUSED */
259 static int
260 zfs_secpolicy_read(zfs_cmd_t *zc, cred_t *cr)
261 {
262 if (INGLOBALZONE(curproc) ||
263 zone_dataset_visible(zc->zc_name, NULL))
264 return (0);
265
266 return (ENOENT);
267 }
268
269 static int
270 zfs_dozonecheck(const char *dataset, cred_t *cr)
271 {
272 uint64_t zoned;
273 int writable = 1;
274
275 /*
276 * The dataset must be visible by this zone -- check this first
277 * so they don't see EPERM on something they shouldn't know about.
278 */
279 if (!INGLOBALZONE(curproc) &&
280 !zone_dataset_visible(dataset, &writable))
281 return (ENOENT);
282
283 if (dsl_prop_get_integer(dataset, "zoned", &zoned, NULL))
284 return (ENOENT);
285
286 if (INGLOBALZONE(curproc)) {
287 /*
288 * If the fs is zoned, only root can access it from the
289 * global zone.
290 */
291 if (secpolicy_zfs(cr) && zoned)
292 return (EPERM);
293 } else {
294 /*
295 * If we are in a local zone, the 'zoned' property must be set.
296 */
297 if (!zoned)
298 return (EPERM);
299
300 /* must be writable by this zone */
301 if (!writable)
302 return (EPERM);
303 }
304 return (0);
305 }
306
307 int
308 zfs_secpolicy_write_perms(const char *name, const char *perm, cred_t *cr)
309 {
310 int error;
311
312 error = zfs_dozonecheck(name, cr);
313 if (error == 0) {
314 error = secpolicy_zfs(cr);
315 if (error)
316 error = dsl_deleg_access(name, perm, cr);
317 }
318 return (error);
319 }
320
321 static int
322 zfs_secpolicy_setprop(const char *name, zfs_prop_t prop, cred_t *cr)
323 {
324 /*
325 * Check permissions for special properties.
326 */
327 switch (prop) {
328 case ZFS_PROP_ZONED:
329 /*
330 * Disallow setting of 'zoned' from within a local zone.
331 */
332 if (!INGLOBALZONE(curproc))
333 return (EPERM);
334 break;
335
336 case ZFS_PROP_QUOTA:
337 if (!INGLOBALZONE(curproc)) {
338 uint64_t zoned;
339 char setpoint[MAXNAMELEN];
340 /*
341 * Unprivileged users are allowed to modify the
342 * quota on things *under* (ie. contained by)
343 * the thing they own.
344 */
345 if (dsl_prop_get_integer(name, "zoned", &zoned,
346 setpoint))
347 return (EPERM);
348 if (!zoned || strlen(name) <= strlen(setpoint))
349 return (EPERM);
350 }
351 break;
352 }
353
354 return (zfs_secpolicy_write_perms(name, zfs_prop_to_name(prop), cr));
355 }
356
357 int
358 zfs_secpolicy_fsacl(zfs_cmd_t *zc, cred_t *cr)
359 {
360 int error;
361
362 error = zfs_dozonecheck(zc->zc_name, cr);
363 if (error)
364 return (error);
365
366 /*
367 * permission to set permissions will be evaluated later in
368 * dsl_deleg_can_allow()
369 */
370 return (0);
371 }
372
373 int
374 zfs_secpolicy_rollback(zfs_cmd_t *zc, cred_t *cr)
375 {
376 int error;
377 error = zfs_secpolicy_write_perms(zc->zc_name,
378 ZFS_DELEG_PERM_ROLLBACK, cr);
379 if (error == 0)
380 error = zfs_secpolicy_write_perms(zc->zc_name,
381 ZFS_DELEG_PERM_MOUNT, cr);
382 return (error);
383 }
384
385 int
386 zfs_secpolicy_send(zfs_cmd_t *zc, cred_t *cr)
387 {
388 return (zfs_secpolicy_write_perms(zc->zc_name,
389 ZFS_DELEG_PERM_SEND, cr));
390 }
391
392 int
393 zfs_secpolicy_share(zfs_cmd_t *zc, cred_t *cr)
394 {
395 if (!INGLOBALZONE(curproc))
396 return (EPERM);
397
398 if (secpolicy_nfs(cr) == 0) {
399 return (0);
400 } else {
401 vnode_t *vp;
402 int error;
403
404 if ((error = lookupname(zc->zc_value, UIO_SYSSPACE,
405 NO_FOLLOW, NULL, &vp)) != 0)
406 return (error);
407
408 /* Now make sure mntpnt and dataset are ZFS */
409
410 if (vp->v_vfsp->vfs_fstype != zfsfstype ||
411 (strcmp((char *)refstr_value(vp->v_vfsp->vfs_resource),
412 zc->zc_name) != 0)) {
413 VN_RELE(vp);
414 return (EPERM);
415 }
416
417 VN_RELE(vp);
418 return (dsl_deleg_access(zc->zc_name,
419 ZFS_DELEG_PERM_SHARE, cr));
420 }
421 }
422
423 static int
424 zfs_get_parent(const char *datasetname, char *parent, int parentsize)
425 {
426 char *cp;
427
428 /*
429 * Remove the @bla or /bla from the end of the name to get the parent.
430 */
431 (void) strncpy(parent, datasetname, parentsize);
432 cp = strrchr(parent, '@');
433 if (cp != NULL) {
434 cp[0] = '\0';
435 } else {
436 cp = strrchr(parent, '/');
437 if (cp == NULL)
438 return (ENOENT);
439 cp[0] = '\0';
440 }
441
442 return (0);
443 }
444
445 int
446 zfs_secpolicy_destroy_perms(const char *name, cred_t *cr)
447 {
448 int error;
449
450 if ((error = zfs_secpolicy_write_perms(name,
451 ZFS_DELEG_PERM_MOUNT, cr)) != 0)
452 return (error);
453
454 return (zfs_secpolicy_write_perms(name, ZFS_DELEG_PERM_DESTROY, cr));
455 }
456
457 static int
458 zfs_secpolicy_destroy(zfs_cmd_t *zc, cred_t *cr)
459 {
460 return (zfs_secpolicy_destroy_perms(zc->zc_name, cr));
461 }
462
463 /*
464 * Must have sys_config privilege to check the iscsi permission
465 */
466 /* ARGSUSED */
467 static int
468 zfs_secpolicy_iscsi(zfs_cmd_t *zc, cred_t *cr)
469 {
470 return (secpolicy_zfs(cr));
471 }
472
473 int
474 zfs_secpolicy_rename_perms(const char *from, const char *to, cred_t *cr)
475 {
476 char parentname[MAXNAMELEN];
477 int error;
478
479 if ((error = zfs_secpolicy_write_perms(from,
480 ZFS_DELEG_PERM_RENAME, cr)) != 0)
481 return (error);
482
483 if ((error = zfs_secpolicy_write_perms(from,
484 ZFS_DELEG_PERM_MOUNT, cr)) != 0)
485 return (error);
486
487 if ((error = zfs_get_parent(to, parentname,
488 sizeof (parentname))) != 0)
489 return (error);
490
491 if ((error = zfs_secpolicy_write_perms(parentname,
492 ZFS_DELEG_PERM_CREATE, cr)) != 0)
493 return (error);
494
495 if ((error = zfs_secpolicy_write_perms(parentname,
496 ZFS_DELEG_PERM_MOUNT, cr)) != 0)
497 return (error);
498
499 return (error);
500 }
501
502 static int
503 zfs_secpolicy_rename(zfs_cmd_t *zc, cred_t *cr)
504 {
505 return (zfs_secpolicy_rename_perms(zc->zc_name, zc->zc_value, cr));
506 }
507
508 static int
509 zfs_secpolicy_promote(zfs_cmd_t *zc, cred_t *cr)
510 {
511 char parentname[MAXNAMELEN];
512 objset_t *clone;
513 int error;
514
515 error = zfs_secpolicy_write_perms(zc->zc_name,
516 ZFS_DELEG_PERM_PROMOTE, cr);
517 if (error)
518 return (error);
519
520 error = dmu_objset_open(zc->zc_name, DMU_OST_ANY,
521 DS_MODE_USER | DS_MODE_READONLY, &clone);
522
523 if (error == 0) {
524 dsl_dataset_t *pclone = NULL;
525 dsl_dir_t *dd;
526 dd = clone->os->os_dsl_dataset->ds_dir;
527
528 rw_enter(&dd->dd_pool->dp_config_rwlock, RW_READER);
529 error = dsl_dataset_hold_obj(dd->dd_pool,
530 dd->dd_phys->dd_origin_obj, FTAG, &pclone);
531 rw_exit(&dd->dd_pool->dp_config_rwlock);
532 if (error) {
533 dmu_objset_close(clone);
534 return (error);
535 }
536
537 error = zfs_secpolicy_write_perms(zc->zc_name,
538 ZFS_DELEG_PERM_MOUNT, cr);
539
540 dsl_dataset_name(pclone, parentname);
541 dmu_objset_close(clone);
542 dsl_dataset_rele(pclone, FTAG);
543 if (error == 0)
544 error = zfs_secpolicy_write_perms(parentname,
545 ZFS_DELEG_PERM_PROMOTE, cr);
546 }
547 return (error);
548 }
549
550 static int
551 zfs_secpolicy_receive(zfs_cmd_t *zc, cred_t *cr)
552 {
553 int error;
554
555 if ((error = zfs_secpolicy_write_perms(zc->zc_name,
556 ZFS_DELEG_PERM_RECEIVE, cr)) != 0)
557 return (error);
558
559 if ((error = zfs_secpolicy_write_perms(zc->zc_name,
560 ZFS_DELEG_PERM_MOUNT, cr)) != 0)
561 return (error);
562
563 return (zfs_secpolicy_write_perms(zc->zc_name,
564 ZFS_DELEG_PERM_CREATE, cr));
565 }
566
567 int
568 zfs_secpolicy_snapshot_perms(const char *name, cred_t *cr)
569 {
570 int error;
571
572 if ((error = zfs_secpolicy_write_perms(name,
573 ZFS_DELEG_PERM_SNAPSHOT, cr)) != 0)
574 return (error);
575
576 error = zfs_secpolicy_write_perms(name,
577 ZFS_DELEG_PERM_MOUNT, cr);
578
579 return (error);
580 }
581
582 static int
583 zfs_secpolicy_snapshot(zfs_cmd_t *zc, cred_t *cr)
584 {
585
586 return (zfs_secpolicy_snapshot_perms(zc->zc_name, cr));
587 }
588
589 static int
590 zfs_secpolicy_create(zfs_cmd_t *zc, cred_t *cr)
591 {
592 char parentname[MAXNAMELEN];
593 int error;
594
595 if ((error = zfs_get_parent(zc->zc_name, parentname,
596 sizeof (parentname))) != 0)
597 return (error);
598
599 if (zc->zc_value[0] != '\0') {
600 if ((error = zfs_secpolicy_write_perms(zc->zc_value,
601 ZFS_DELEG_PERM_CLONE, cr)) != 0)
602 return (error);
603 }
604
605 if ((error = zfs_secpolicy_write_perms(parentname,
606 ZFS_DELEG_PERM_CREATE, cr)) != 0)
607 return (error);
608
609 error = zfs_secpolicy_write_perms(parentname,
610 ZFS_DELEG_PERM_MOUNT, cr);
611
612 return (error);
613 }
614
615 static int
616 zfs_secpolicy_umount(zfs_cmd_t *zc, cred_t *cr)
617 {
618 int error;
619
620 error = secpolicy_fs_unmount(cr, NULL);
621 if (error) {
622 error = dsl_deleg_access(zc->zc_name, ZFS_DELEG_PERM_MOUNT, cr);
623 }
624 return (error);
625 }
626
627 /*
628 * Policy for pool operations - create/destroy pools, add vdevs, etc. Requires
629 * SYS_CONFIG privilege, which is not available in a local zone.
630 */
631 /* ARGSUSED */
632 static int
633 zfs_secpolicy_config(zfs_cmd_t *zc, cred_t *cr)
634 {
635 if (secpolicy_sys_config(cr, B_FALSE) != 0)
636 return (EPERM);
637
638 return (0);
639 }
640
641 /*
642 * Just like zfs_secpolicy_config, except that we will check for
643 * mount permission on the dataset for permission to create/remove
644 * the minor nodes.
645 */
646 static int
647 zfs_secpolicy_minor(zfs_cmd_t *zc, cred_t *cr)
648 {
649 if (secpolicy_sys_config(cr, B_FALSE) != 0) {
650 return (dsl_deleg_access(zc->zc_name,
651 ZFS_DELEG_PERM_MOUNT, cr));
652 }
653
654 return (0);
655 }
656
657 /*
658 * Policy for fault injection. Requires all privileges.
659 */
660 /* ARGSUSED */
661 static int
662 zfs_secpolicy_inject(zfs_cmd_t *zc, cred_t *cr)
663 {
664 return (secpolicy_zinject(cr));
665 }
666
667 static int
668 zfs_secpolicy_inherit(zfs_cmd_t *zc, cred_t *cr)
669 {
670 zfs_prop_t prop = zfs_name_to_prop(zc->zc_value);
671
672 if (prop == ZPROP_INVAL) {
673 if (!zfs_prop_user(zc->zc_value))
674 return (EINVAL);
675 return (zfs_secpolicy_write_perms(zc->zc_name,
676 ZFS_DELEG_PERM_USERPROP, cr));
677 } else {
678 if (!zfs_prop_inheritable(prop))
679 return (EINVAL);
680 return (zfs_secpolicy_setprop(zc->zc_name, prop, cr));
681 }
682 }
683
684 /*
685 * Returns the nvlist as specified by the user in the zfs_cmd_t.
686 */
687 static int
688 get_nvlist(uint64_t nvl, uint64_t size, nvlist_t **nvp)
689 {
690 char *packed;
691 int error;
692 nvlist_t *list = NULL;
693
694 /*
695 * Read in and unpack the user-supplied nvlist.
696 */
697 if (size == 0)
698 return (EINVAL);
699
700 packed = kmem_alloc(size, KM_SLEEP);
701
702 if ((error = xcopyin((void *)(uintptr_t)nvl, packed, size)) != 0) {
703 kmem_free(packed, size);
704 return (error);
705 }
706
707 if ((error = nvlist_unpack(packed, size, &list, 0)) != 0) {
708 kmem_free(packed, size);
709 return (error);
710 }
711
712 kmem_free(packed, size);
713
714 *nvp = list;
715 return (0);
716 }
717
718 static int
719 put_nvlist(zfs_cmd_t *zc, nvlist_t *nvl)
720 {
721 char *packed = NULL;
722 size_t size;
723 int error;
724
725 VERIFY(nvlist_size(nvl, &size, NV_ENCODE_NATIVE) == 0);
726
727 if (size > zc->zc_nvlist_dst_size) {
728 error = ENOMEM;
729 } else {
730 packed = kmem_alloc(size, KM_SLEEP);
731 VERIFY(nvlist_pack(nvl, &packed, &size, NV_ENCODE_NATIVE,
732 KM_SLEEP) == 0);
733 error = xcopyout(packed, (void *)(uintptr_t)zc->zc_nvlist_dst,
734 size);
735 kmem_free(packed, size);
736 }
737
738 zc->zc_nvlist_dst_size = size;
739 return (error);
740 }
741
742 static int
743 zfs_ioc_pool_create(zfs_cmd_t *zc)
744 {
745 int error;
746 nvlist_t *config, *props = NULL;
747 nvlist_t *rootprops = NULL;
748 nvlist_t *zplprops = NULL;
749 char *buf;
750
751 if (error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size,
752 &config))
753 return (error);
754
755 if (zc->zc_nvlist_src_size != 0 && (error =
756 get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size, &props))) {
757 nvlist_free(config);
758 return (error);
759 }
760
761 if (props) {
762 nvlist_t *nvl = NULL;
763 uint64_t version = SPA_VERSION;
764
765 (void) nvlist_lookup_uint64(props,
766 zpool_prop_to_name(ZPOOL_PROP_VERSION), &version);
767 if (version < SPA_VERSION_INITIAL || version > SPA_VERSION) {
768 error = EINVAL;
769 goto pool_props_bad;
770 }
771 (void) nvlist_lookup_nvlist(props, ZPOOL_ROOTFS_PROPS, &nvl);
772 if (nvl) {
773 error = nvlist_dup(nvl, &rootprops, KM_SLEEP);
774 if (error != 0) {
775 nvlist_free(config);
776 nvlist_free(props);
777 return (error);
778 }
779 (void) nvlist_remove_all(props, ZPOOL_ROOTFS_PROPS);
780 }
781 VERIFY(nvlist_alloc(&zplprops, NV_UNIQUE_NAME, KM_SLEEP) == 0);
782 error = zfs_fill_zplprops_root(version, rootprops,
783 zplprops, NULL);
784 if (error)
785 goto pool_props_bad;
786 }
787
788 buf = history_str_get(zc);
789
790 error = spa_create(zc->zc_name, config, props, buf, zplprops);
791
792 /*
793 * Set the remaining root properties
794 */
795 if (!error &&
796 (error = zfs_set_prop_nvlist(zc->zc_name, rootprops)) != 0)
797 (void) spa_destroy(zc->zc_name);
798
799 if (buf != NULL)
800 history_str_free(buf);
801
802 pool_props_bad:
803 nvlist_free(rootprops);
804 nvlist_free(zplprops);
805 nvlist_free(config);
806 nvlist_free(props);
807
808 return (error);
809 }
810
811 static int
812 zfs_ioc_pool_destroy(zfs_cmd_t *zc)
813 {
814 int error;
815 zfs_log_history(zc);
816 error = spa_destroy(zc->zc_name);
817 return (error);
818 }
819
820 static int
821 zfs_ioc_pool_import(zfs_cmd_t *zc)
822 {
823 int error;
824 nvlist_t *config, *props = NULL;
825 uint64_t guid;
826
827 if ((error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size,
828 &config)) != 0)
829 return (error);
830
831 if (zc->zc_nvlist_src_size != 0 && (error =
832 get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size, &props))) {
833 nvlist_free(config);
834 return (error);
835 }
836
837 if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, &guid) != 0 ||
838 guid != zc->zc_guid)
839 error = EINVAL;
840 else if (zc->zc_cookie)
841 error = spa_import_faulted(zc->zc_name, config,
842 props);
843 else
844 error = spa_import(zc->zc_name, config, props);
845
846 nvlist_free(config);
847
848 if (props)
849 nvlist_free(props);
850
851 return (error);
852 }
853
854 static int
855 zfs_ioc_pool_export(zfs_cmd_t *zc)
856 {
857 int error;
858 boolean_t force = (boolean_t)zc->zc_cookie;
859 boolean_t hardforce = (boolean_t)zc->zc_guid;
860
861 zfs_log_history(zc);
862 error = spa_export(zc->zc_name, NULL, force, hardforce);
863 return (error);
864 }
865
866 static int
867 zfs_ioc_pool_configs(zfs_cmd_t *zc)
868 {
869 nvlist_t *configs;
870 int error;
871
872 if ((configs = spa_all_configs(&zc->zc_cookie)) == NULL)
873 return (EEXIST);
874
875 error = put_nvlist(zc, configs);
876
877 nvlist_free(configs);
878
879 return (error);
880 }
881
882 static int
883 zfs_ioc_pool_stats(zfs_cmd_t *zc)
884 {
885 nvlist_t *config;
886 int error;
887 int ret = 0;
888
889 error = spa_get_stats(zc->zc_name, &config, zc->zc_value,
890 sizeof (zc->zc_value));
891
892 if (config != NULL) {
893 ret = put_nvlist(zc, config);
894 nvlist_free(config);
895
896 /*
897 * The config may be present even if 'error' is non-zero.
898 * In this case we return success, and preserve the real errno
899 * in 'zc_cookie'.
900 */
901 zc->zc_cookie = error;
902 } else {
903 ret = error;
904 }
905
906 return (ret);
907 }
908
909 /*
910 * Try to import the given pool, returning pool stats as appropriate so that
911 * user land knows which devices are available and overall pool health.
912 */
913 static int
914 zfs_ioc_pool_tryimport(zfs_cmd_t *zc)
915 {
916 nvlist_t *tryconfig, *config;
917 int error;
918
919 if ((error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size,
920 &tryconfig)) != 0)
921 return (error);
922
923 config = spa_tryimport(tryconfig);
924
925 nvlist_free(tryconfig);
926
927 if (config == NULL)
928 return (EINVAL);
929
930 error = put_nvlist(zc, config);
931 nvlist_free(config);
932
933 return (error);
934 }
935
936 static int
937 zfs_ioc_pool_scrub(zfs_cmd_t *zc)
938 {
939 spa_t *spa;
940 int error;
941
942 if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
943 return (error);
944
945 error = spa_scrub(spa, zc->zc_cookie);
946
947 spa_close(spa, FTAG);
948
949 return (error);
950 }
951
952 static int
953 zfs_ioc_pool_freeze(zfs_cmd_t *zc)
954 {
955 spa_t *spa;
956 int error;
957
958 error = spa_open(zc->zc_name, &spa, FTAG);
959 if (error == 0) {
960 spa_freeze(spa);
961 spa_close(spa, FTAG);
962 }
963 return (error);
964 }
965
966 static int
967 zfs_ioc_pool_upgrade(zfs_cmd_t *zc)
968 {
969 spa_t *spa;
970 int error;
971
972 if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
973 return (error);
974
975 if (zc->zc_cookie < spa_version(spa) || zc->zc_cookie > SPA_VERSION) {
976 spa_close(spa, FTAG);
977 return (EINVAL);
978 }
979
980 spa_upgrade(spa, zc->zc_cookie);
981 spa_close(spa, FTAG);
982
983 return (error);
984 }
985
986 static int
987 zfs_ioc_pool_get_history(zfs_cmd_t *zc)
988 {
989 spa_t *spa;
990 char *hist_buf;
991 uint64_t size;
992 int error;
993
994 if ((size = zc->zc_history_len) == 0)
995 return (EINVAL);
996
997 if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
998 return (error);
999
1000 if (spa_version(spa) < SPA_VERSION_ZPOOL_HISTORY) {
1001 spa_close(spa, FTAG);
1002 return (ENOTSUP);
1003 }
1004
1005 hist_buf = kmem_alloc(size, KM_SLEEP);
1006 if ((error = spa_history_get(spa, &zc->zc_history_offset,
1007 &zc->zc_history_len, hist_buf)) == 0) {
1008 error = xcopyout(hist_buf,
1009 (char *)(uintptr_t)zc->zc_history,
1010 zc->zc_history_len);
1011 }
1012
1013 spa_close(spa, FTAG);
1014 kmem_free(hist_buf, size);
1015 return (error);
1016 }
1017
1018 static int
1019 zfs_ioc_dsobj_to_dsname(zfs_cmd_t *zc)
1020 {
1021 int error;
1022
1023 if (error = dsl_dsobj_to_dsname(zc->zc_name, zc->zc_obj, zc->zc_value))
1024 return (error);
1025
1026 return (0);
1027 }
1028
1029 static int
1030 zfs_ioc_obj_to_path(zfs_cmd_t *zc)
1031 {
1032 objset_t *osp;
1033 int error;
1034
1035 if ((error = dmu_objset_open(zc->zc_name, DMU_OST_ZFS,
1036 DS_MODE_USER | DS_MODE_READONLY, &osp)) != 0)
1037 return (error);
1038 error = zfs_obj_to_path(osp, zc->zc_obj, zc->zc_value,
1039 sizeof (zc->zc_value));
1040 dmu_objset_close(osp);
1041
1042 return (error);
1043 }
1044
1045 static int
1046 zfs_ioc_vdev_add(zfs_cmd_t *zc)
1047 {
1048 spa_t *spa;
1049 int error;
1050 nvlist_t *config, **l2cache, **spares;
1051 uint_t nl2cache = 0, nspares = 0;
1052
1053 error = spa_open(zc->zc_name, &spa, FTAG);
1054 if (error != 0)
1055 return (error);
1056
1057 error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size,
1058 &config);
1059 (void) nvlist_lookup_nvlist_array(config, ZPOOL_CONFIG_L2CACHE,
1060 &l2cache, &nl2cache);
1061
1062 (void) nvlist_lookup_nvlist_array(config, ZPOOL_CONFIG_SPARES,
1063 &spares, &nspares);
1064
1065 /*
1066 * A root pool with concatenated devices is not supported.
1067 * Thus, can not add a device to a root pool.
1068 *
1069 * Intent log device can not be added to a rootpool because
1070 * during mountroot, zil is replayed, a seperated log device
1071 * can not be accessed during the mountroot time.
1072 *
1073 * l2cache and spare devices are ok to be added to a rootpool.
1074 */
1075 if (spa->spa_bootfs != 0 && nl2cache == 0 && nspares == 0) {
1076 spa_close(spa, FTAG);
1077 return (EDOM);
1078 }
1079
1080 if (error == 0) {
1081 error = spa_vdev_add(spa, config);
1082 nvlist_free(config);
1083 }
1084 spa_close(spa, FTAG);
1085 return (error);
1086 }
1087
1088 static int
1089 zfs_ioc_vdev_remove(zfs_cmd_t *zc)
1090 {
1091 spa_t *spa;
1092 int error;
1093
1094 error = spa_open(zc->zc_name, &spa, FTAG);
1095 if (error != 0)
1096 return (error);
1097 error = spa_vdev_remove(spa, zc->zc_guid, B_FALSE);
1098 spa_close(spa, FTAG);
1099 return (error);
1100 }
1101
1102 static int
1103 zfs_ioc_vdev_set_state(zfs_cmd_t *zc)
1104 {
1105 spa_t *spa;
1106 int error;
1107 vdev_state_t newstate = VDEV_STATE_UNKNOWN;
1108
1109 if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
1110 return (error);
1111 switch (zc->zc_cookie) {
1112 case VDEV_STATE_ONLINE:
1113 error = vdev_online(spa, zc->zc_guid, zc->zc_obj, &newstate);
1114 break;
1115
1116 case VDEV_STATE_OFFLINE:
1117 error = vdev_offline(spa, zc->zc_guid, zc->zc_obj);
1118 break;
1119
1120 case VDEV_STATE_FAULTED:
1121 error = vdev_fault(spa, zc->zc_guid);
1122 break;
1123
1124 case VDEV_STATE_DEGRADED:
1125 error = vdev_degrade(spa, zc->zc_guid);
1126 break;
1127
1128 default:
1129 error = EINVAL;
1130 }
1131 zc->zc_cookie = newstate;
1132 spa_close(spa, FTAG);
1133 return (error);
1134 }
1135
1136 static int
1137 zfs_ioc_vdev_attach(zfs_cmd_t *zc)
1138 {
1139 spa_t *spa;
1140 int replacing = zc->zc_cookie;
1141 nvlist_t *config;
1142 int error;
1143
1144 if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
1145 return (error);
1146
1147 if ((error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size,
1148 &config)) == 0) {
1149 error = spa_vdev_attach(spa, zc->zc_guid, config, replacing);
1150 nvlist_free(config);
1151 }
1152
1153 spa_close(spa, FTAG);
1154 return (error);
1155 }
1156
1157 static int
1158 zfs_ioc_vdev_detach(zfs_cmd_t *zc)
1159 {
1160 spa_t *spa;
1161 int error;
1162
1163 if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
1164 return (error);
1165
1166 error = spa_vdev_detach(spa, zc->zc_guid, 0, B_FALSE);
1167
1168 spa_close(spa, FTAG);
1169 return (error);
1170 }
1171
1172 static int
1173 zfs_ioc_vdev_setpath(zfs_cmd_t *zc)
1174 {
1175 spa_t *spa;
1176 char *path = zc->zc_value;
1177 uint64_t guid = zc->zc_guid;
1178 int error;
1179
1180 error = spa_open(zc->zc_name, &spa, FTAG);
1181 if (error != 0)
1182 return (error);
1183
1184 error = spa_vdev_setpath(spa, guid, path);
1185 spa_close(spa, FTAG);
1186 return (error);
1187 }
1188
1189 /*
1190 * inputs:
1191 * zc_name name of filesystem
1192 * zc_nvlist_dst_size size of buffer for property nvlist
1193 *
1194 * outputs:
1195 * zc_objset_stats stats
1196 * zc_nvlist_dst property nvlist
1197 * zc_nvlist_dst_size size of property nvlist
1198 */
1199 static int
1200 zfs_ioc_objset_stats(zfs_cmd_t *zc)
1201 {
1202 objset_t *os = NULL;
1203 int error;
1204 nvlist_t *nv;
1205
1206 if (error = dmu_objset_open(zc->zc_name,
1207 DMU_OST_ANY, DS_MODE_USER | DS_MODE_READONLY, &os))
1208 return (error);
1209
1210 dmu_objset_fast_stat(os, &zc->zc_objset_stats);
1211
1212 if (zc->zc_nvlist_dst != 0 &&
1213 (error = dsl_prop_get_all(os, &nv, FALSE)) == 0) {
1214 dmu_objset_stats(os, nv);
1215 /*
1216 * NB: zvol_get_stats() will read the objset contents,
1217 * which we aren't supposed to do with a
1218 * DS_MODE_USER hold, because it could be
1219 * inconsistent. So this is a bit of a workaround...
1220 */
1221 if (!zc->zc_objset_stats.dds_inconsistent) {
1222 if (dmu_objset_type(os) == DMU_OST_ZVOL)
1223 VERIFY(zvol_get_stats(os, nv) == 0);
1224 }
1225 error = put_nvlist(zc, nv);
1226 nvlist_free(nv);
1227 }
1228
1229 dmu_objset_close(os);
1230 return (error);
1231 }
1232
1233 static int
1234 nvl_add_zplprop(objset_t *os, nvlist_t *props, zfs_prop_t prop)
1235 {
1236 uint64_t value;
1237 int error;
1238
1239 /*
1240 * zfs_get_zplprop() will either find a value or give us
1241 * the default value (if there is one).
1242 */
1243 if ((error = zfs_get_zplprop(os, prop, &value)) != 0)
1244 return (error);
1245 VERIFY(nvlist_add_uint64(props, zfs_prop_to_name(prop), value) == 0);
1246 return (0);
1247 }
1248
1249 /*
1250 * inputs:
1251 * zc_name name of filesystem
1252 * zc_nvlist_dst_size size of buffer for zpl property nvlist
1253 *
1254 * outputs:
1255 * zc_nvlist_dst zpl property nvlist
1256 * zc_nvlist_dst_size size of zpl property nvlist
1257 */
1258 static int
1259 zfs_ioc_objset_zplprops(zfs_cmd_t *zc)
1260 {
1261 objset_t *os;
1262 int err;
1263
1264 if (err = dmu_objset_open(zc->zc_name,
1265 DMU_OST_ANY, DS_MODE_USER | DS_MODE_READONLY, &os))
1266 return (err);
1267
1268 dmu_objset_fast_stat(os, &zc->zc_objset_stats);
1269
1270 /*
1271 * NB: nvl_add_zplprop() will read the objset contents,
1272 * which we aren't supposed to do with a DS_MODE_USER
1273 * hold, because it could be inconsistent.
1274 */
1275 if (zc->zc_nvlist_dst != NULL &&
1276 !zc->zc_objset_stats.dds_inconsistent &&
1277 dmu_objset_type(os) == DMU_OST_ZFS) {
1278 nvlist_t *nv;
1279
1280 VERIFY(nvlist_alloc(&nv, NV_UNIQUE_NAME, KM_SLEEP) == 0);
1281 if ((err = nvl_add_zplprop(os, nv, ZFS_PROP_VERSION)) == 0 &&
1282 (err = nvl_add_zplprop(os, nv, ZFS_PROP_NORMALIZE)) == 0 &&
1283 (err = nvl_add_zplprop(os, nv, ZFS_PROP_UTF8ONLY)) == 0 &&
1284 (err = nvl_add_zplprop(os, nv, ZFS_PROP_CASE)) == 0)
1285 err = put_nvlist(zc, nv);
1286 nvlist_free(nv);
1287 } else {
1288 err = ENOENT;
1289 }
1290 dmu_objset_close(os);
1291 return (err);
1292 }
1293
1294 /*
1295 * inputs:
1296 * zc_name name of filesystem
1297 * zc_cookie zap cursor
1298 * zc_nvlist_dst_size size of buffer for property nvlist
1299 *
1300 * outputs:
1301 * zc_name name of next filesystem
1302 * zc_objset_stats stats
1303 * zc_nvlist_dst property nvlist
1304 * zc_nvlist_dst_size size of property nvlist
1305 */
1306 static int
1307 zfs_ioc_dataset_list_next(zfs_cmd_t *zc)
1308 {
1309 objset_t *os;
1310 int error;
1311 char *p;
1312
1313 if (error = dmu_objset_open(zc->zc_name,
1314 DMU_OST_ANY, DS_MODE_USER | DS_MODE_READONLY, &os)) {
1315 if (error == ENOENT)
1316 error = ESRCH;
1317 return (error);
1318 }
1319
1320 p = strrchr(zc->zc_name, '/');
1321 if (p == NULL || p[1] != '\0')
1322 (void) strlcat(zc->zc_name, "/", sizeof (zc->zc_name));
1323 p = zc->zc_name + strlen(zc->zc_name);
1324
1325 do {
1326 error = dmu_dir_list_next(os,
1327 sizeof (zc->zc_name) - (p - zc->zc_name), p,
1328 NULL, &zc->zc_cookie);
1329 if (error == ENOENT)
1330 error = ESRCH;
1331 } while (error == 0 && !INGLOBALZONE(curproc) &&
1332 !zone_dataset_visible(zc->zc_name, NULL));
1333 dmu_objset_close(os);
1334
1335 /*
1336 * If it's a hidden dataset (ie. with a '$' in its name), don't
1337 * try to get stats for it. Userland will skip over it.
1338 */
1339 if (error == 0 && strchr(zc->zc_name, '$') == NULL)
1340 error = zfs_ioc_objset_stats(zc); /* fill in the stats */
1341
1342 return (error);
1343 }
1344
1345 /*
1346 * inputs:
1347 * zc_name name of filesystem
1348 * zc_cookie zap cursor
1349 * zc_nvlist_dst_size size of buffer for property nvlist
1350 *
1351 * outputs:
1352 * zc_name name of next snapshot
1353 * zc_objset_stats stats
1354 * zc_nvlist_dst property nvlist
1355 * zc_nvlist_dst_size size of property nvlist
1356 */
1357 static int
1358 zfs_ioc_snapshot_list_next(zfs_cmd_t *zc)
1359 {
1360 objset_t *os;
1361 int error;
1362
1363 error = dmu_objset_open(zc->zc_name,
1364 DMU_OST_ANY, DS_MODE_USER | DS_MODE_READONLY, &os);
1365 if (error)
1366 return (error == ENOENT ? ESRCH : error);
1367
1368 /*
1369 * A dataset name of maximum length cannot have any snapshots,
1370 * so exit immediately.
1371 */
1372 if (strlcat(zc->zc_name, "@", sizeof (zc->zc_name)) >= MAXNAMELEN) {
1373 dmu_objset_close(os);
1374 return (ESRCH);
1375 }
1376
1377 error = dmu_snapshot_list_next(os,
1378 sizeof (zc->zc_name) - strlen(zc->zc_name),
1379 zc->zc_name + strlen(zc->zc_name), NULL, &zc->zc_cookie, NULL);
1380 dmu_objset_close(os);
1381 if (error == 0)
1382 error = zfs_ioc_objset_stats(zc); /* fill in the stats */
1383 else if (error == ENOENT)
1384 error = ESRCH;
1385
1386 /* if we failed, undo the @ that we tacked on to zc_name */
1387 if (error)
1388 *strchr(zc->zc_name, '@') = '\0';
1389 return (error);
1390 }
1391
1392 int
1393 zfs_set_prop_nvlist(const char *name, nvlist_t *nvl)
1394 {
1395 nvpair_t *elem;
1396 int error;
1397 uint64_t intval;
1398 char *strval;
1399
1400 /*
1401 * First validate permission to set all of the properties
1402 */
1403 elem = NULL;
1404 while ((elem = nvlist_next_nvpair(nvl, elem)) != NULL) {
1405 const char *propname = nvpair_name(elem);
1406 zfs_prop_t prop = zfs_name_to_prop(propname);
1407
1408 if (prop == ZPROP_INVAL) {
1409 /*
1410 * If this is a user-defined property, it must be a
1411 * string, and there is no further validation to do.
1412 */
1413 if (!zfs_prop_user(propname) ||
1414 nvpair_type(elem) != DATA_TYPE_STRING)
1415 return (EINVAL);
1416
1417 if (error = zfs_secpolicy_write_perms(name,
1418 ZFS_DELEG_PERM_USERPROP, CRED()))
1419 return (error);
1420 continue;
1421 }
1422
1423 if ((error = zfs_secpolicy_setprop(name, prop, CRED())) != 0)
1424 return (error);
1425
1426 /*
1427 * Check that this value is valid for this pool version
1428 */
1429 switch (prop) {
1430 case ZFS_PROP_COMPRESSION:
1431 /*
1432 * If the user specified gzip compression, make sure
1433 * the SPA supports it. We ignore any errors here since
1434 * we'll catch them later.
1435 */
1436 if (nvpair_type(elem) == DATA_TYPE_UINT64 &&
1437 nvpair_value_uint64(elem, &intval) == 0) {
1438 if (intval >= ZIO_COMPRESS_GZIP_1 &&
1439 intval <= ZIO_COMPRESS_GZIP_9 &&
1440 zfs_earlier_version(name,
1441 SPA_VERSION_GZIP_COMPRESSION))
1442 return (ENOTSUP);
1443
1444 /*
1445 * If this is a bootable dataset then
1446 * verify that the compression algorithm
1447 * is supported for booting. We must return
1448 * something other than ENOTSUP since it
1449 * implies a downrev pool version.
1450 */
1451 if (zfs_is_bootfs(name) &&
1452 !BOOTFS_COMPRESS_VALID(intval))
1453 return (ERANGE);
1454 }
1455 break;
1456
1457 case ZFS_PROP_COPIES:
1458 if (zfs_earlier_version(name,
1459 SPA_VERSION_DITTO_BLOCKS))
1460 return (ENOTSUP);
1461 break;
1462
1463 case ZFS_PROP_SHARESMB:
1464 if (zpl_earlier_version(name, ZPL_VERSION_FUID))
1465 return (ENOTSUP);
1466 break;
1467
1468 case ZFS_PROP_ACLINHERIT:
1469 if (nvpair_type(elem) == DATA_TYPE_UINT64 &&
1470 nvpair_value_uint64(elem, &intval) == 0)
1471 if (intval == ZFS_ACL_PASSTHROUGH_X &&
1472 zfs_earlier_version(name,
1473 SPA_VERSION_PASSTHROUGH_X))
1474 return (ENOTSUP);
1475 }
1476 }
1477
1478 elem = NULL;
1479 while ((elem = nvlist_next_nvpair(nvl, elem)) != NULL) {
1480 const char *propname = nvpair_name(elem);
1481 zfs_prop_t prop = zfs_name_to_prop(propname);
1482
1483 if (prop == ZPROP_INVAL) {
1484 VERIFY(nvpair_value_string(elem, &strval) == 0);
1485 error = dsl_prop_set(name, propname, 1,
1486 strlen(strval) + 1, strval);
1487 if (error == 0)
1488 continue;
1489 else
1490 return (error);
1491 }
1492
1493 switch (prop) {
1494 case ZFS_PROP_QUOTA:
1495 if ((error = nvpair_value_uint64(elem, &intval)) != 0 ||
1496 (error = dsl_dir_set_quota(name, intval)) != 0)
1497 return (error);
1498 break;
1499
1500 case ZFS_PROP_REFQUOTA:
1501 if ((error = nvpair_value_uint64(elem, &intval)) != 0 ||
1502 (error = dsl_dataset_set_quota(name, intval)) != 0)
1503 return (error);
1504 break;
1505
1506 case ZFS_PROP_RESERVATION:
1507 if ((error = nvpair_value_uint64(elem, &intval)) != 0 ||
1508 (error = dsl_dir_set_reservation(name,
1509 intval)) != 0)
1510 return (error);
1511 break;
1512
1513 case ZFS_PROP_REFRESERVATION:
1514 if ((error = nvpair_value_uint64(elem, &intval)) != 0 ||
1515 (error = dsl_dataset_set_reservation(name,
1516 intval)) != 0)
1517 return (error);
1518 break;
1519
1520 case ZFS_PROP_VOLSIZE:
1521 if ((error = nvpair_value_uint64(elem, &intval)) != 0 ||
1522 (error = zvol_set_volsize(name,
1523 ddi_driver_major(zfs_dip), intval)) != 0)
1524 return (error);
1525 break;
1526
1527 case ZFS_PROP_VOLBLOCKSIZE:
1528 if ((error = nvpair_value_uint64(elem, &intval)) != 0 ||
1529 (error = zvol_set_volblocksize(name, intval)) != 0)
1530 return (error);
1531 break;
1532
1533 case ZFS_PROP_VERSION:
1534 if ((error = nvpair_value_uint64(elem, &intval)) != 0 ||
1535 (error = zfs_set_version(name, intval)) != 0)
1536 return (error);
1537 break;
1538
1539 default:
1540 if (nvpair_type(elem) == DATA_TYPE_STRING) {
1541 if (zfs_prop_get_type(prop) !=
1542 PROP_TYPE_STRING)
1543 return (EINVAL);
1544 VERIFY(nvpair_value_string(elem, &strval) == 0);
1545 if ((error = dsl_prop_set(name,
1546 nvpair_name(elem), 1, strlen(strval) + 1,
1547 strval)) != 0)
1548 return (error);
1549 } else if (nvpair_type(elem) == DATA_TYPE_UINT64) {
1550 const char *unused;
1551
1552 VERIFY(nvpair_value_uint64(elem, &intval) == 0);
1553
1554 switch (zfs_prop_get_type(prop)) {
1555 case PROP_TYPE_NUMBER:
1556 break;
1557 case PROP_TYPE_STRING:
1558 return (EINVAL);
1559 case PROP_TYPE_INDEX:
1560 if (zfs_prop_index_to_string(prop,
1561 intval, &unused) != 0)
1562 return (EINVAL);
1563 break;
1564 default:
1565 cmn_err(CE_PANIC,
1566 "unknown property type");
1567 break;
1568 }
1569
1570 if ((error = dsl_prop_set(name, propname,
1571 8, 1, &intval)) != 0)
1572 return (error);
1573 } else {
1574 return (EINVAL);
1575 }
1576 break;
1577 }
1578 }
1579
1580 return (0);
1581 }
1582
1583 /*
1584 * inputs:
1585 * zc_name name of filesystem
1586 * zc_value name of property to inherit
1587 * zc_nvlist_src{_size} nvlist of properties to apply
1588 * zc_cookie clear existing local props?
1589 *
1590 * outputs: none
1591 */
1592 static int
1593 zfs_ioc_set_prop(zfs_cmd_t *zc)
1594 {
1595 nvlist_t *nvl;
1596 int error;
1597
1598 if ((error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
1599 &nvl)) != 0)
1600 return (error);
1601
1602 if (zc->zc_cookie) {
1603 nvlist_t *origprops;
1604 objset_t *os;
1605
1606 if (dmu_objset_open(zc->zc_name, DMU_OST_ANY,
1607 DS_MODE_USER | DS_MODE_READONLY, &os) == 0) {
1608 if (dsl_prop_get_all(os, &origprops, TRUE) == 0) {
1609 clear_props(zc->zc_name, origprops);
1610 nvlist_free(origprops);
1611 }
1612 dmu_objset_close(os);
1613 }
1614
1615 }
1616
1617 error = zfs_set_prop_nvlist(zc->zc_name, nvl);
1618
1619 nvlist_free(nvl);
1620 return (error);
1621 }
1622
1623 /*
1624 * inputs:
1625 * zc_name name of filesystem
1626 * zc_value name of property to inherit
1627 *
1628 * outputs: none
1629 */
1630 static int
1631 zfs_ioc_inherit_prop(zfs_cmd_t *zc)
1632 {
1633 /* the property name has been validated by zfs_secpolicy_inherit() */
1634 return (dsl_prop_set(zc->zc_name, zc->zc_value, 0, 0, NULL));
1635 }
1636
1637 static int
1638 zfs_ioc_pool_set_props(zfs_cmd_t *zc)
1639 {
1640 nvlist_t *props;
1641 spa_t *spa;
1642 int error;
1643
1644 if ((error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
1645 &props)))
1646 return (error);
1647
1648 if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0) {
1649 nvlist_free(props);
1650 return (error);
1651 }
1652
1653 error = spa_prop_set(spa, props);
1654
1655 nvlist_free(props);
1656 spa_close(spa, FTAG);
1657
1658 return (error);
1659 }
1660
1661 static int
1662 zfs_ioc_pool_get_props(zfs_cmd_t *zc)
1663 {
1664 spa_t *spa;
1665 int error;
1666 nvlist_t *nvp = NULL;
1667
1668 if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
1669 return (error);
1670
1671 error = spa_prop_get(spa, &nvp);
1672
1673 if (error == 0 && zc->zc_nvlist_dst != NULL)
1674 error = put_nvlist(zc, nvp);
1675 else
1676 error = EFAULT;
1677
1678 spa_close(spa, FTAG);
1679
1680 if (nvp)
1681 nvlist_free(nvp);
1682 return (error);
1683 }
1684
1685 static int
1686 zfs_ioc_iscsi_perm_check(zfs_cmd_t *zc)
1687 {
1688 nvlist_t *nvp;
1689 int error;
1690 uint32_t uid;
1691 uint32_t gid;
1692 uint32_t *groups;
1693 uint_t group_cnt;
1694 cred_t *usercred;
1695
1696 if ((error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
1697 &nvp)) != 0) {
1698 return (error);
1699 }
1700
1701 if ((error = nvlist_lookup_uint32(nvp,
1702 ZFS_DELEG_PERM_UID, &uid)) != 0) {
1703 nvlist_free(nvp);
1704 return (EPERM);
1705 }
1706
1707 if ((error = nvlist_lookup_uint32(nvp,
1708 ZFS_DELEG_PERM_GID, &gid)) != 0) {
1709 nvlist_free(nvp);
1710 return (EPERM);
1711 }
1712
1713 if ((error = nvlist_lookup_uint32_array(nvp, ZFS_DELEG_PERM_GROUPS,
1714 &groups, &group_cnt)) != 0) {
1715 nvlist_free(nvp);
1716 return (EPERM);
1717 }
1718 usercred = cralloc();
1719 if ((crsetugid(usercred, uid, gid) != 0) ||
1720 (crsetgroups(usercred, group_cnt, (gid_t *)groups) != 0)) {
1721 nvlist_free(nvp);
1722 crfree(usercred);
1723 return (EPERM);
1724 }
1725 nvlist_free(nvp);
1726 error = dsl_deleg_access(zc->zc_name,
1727 zfs_prop_to_name(ZFS_PROP_SHAREISCSI), usercred);
1728 crfree(usercred);
1729 return (error);
1730 }
1731
1732 /*
1733 * inputs:
1734 * zc_name name of filesystem
1735 * zc_nvlist_src{_size} nvlist of delegated permissions
1736 * zc_perm_action allow/unallow flag
1737 *
1738 * outputs: none
1739 */
1740 static int
1741 zfs_ioc_set_fsacl(zfs_cmd_t *zc)
1742 {
1743 int error;
1744 nvlist_t *fsaclnv = NULL;
1745
1746 if ((error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
1747 &fsaclnv)) != 0)
1748 return (error);
1749
1750 /*
1751 * Verify nvlist is constructed correctly
1752 */
1753 if ((error = zfs_deleg_verify_nvlist(fsaclnv)) != 0) {
1754 nvlist_free(fsaclnv);
1755 return (EINVAL);
1756 }
1757
1758 /*
1759 * If we don't have PRIV_SYS_MOUNT, then validate
1760 * that user is allowed to hand out each permission in
1761 * the nvlist(s)
1762 */
1763
1764 error = secpolicy_zfs(CRED());
1765 if (error) {
1766 if (zc->zc_perm_action == B_FALSE) {
1767 error = dsl_deleg_can_allow(zc->zc_name,
1768 fsaclnv, CRED());
1769 } else {
1770 error = dsl_deleg_can_unallow(zc->zc_name,
1771 fsaclnv, CRED());
1772 }
1773 }
1774
1775 if (error == 0)
1776 error = dsl_deleg_set(zc->zc_name, fsaclnv, zc->zc_perm_action);
1777
1778 nvlist_free(fsaclnv);
1779 return (error);
1780 }
1781
1782 /*
1783 * inputs:
1784 * zc_name name of filesystem
1785 *
1786 * outputs:
1787 * zc_nvlist_src{_size} nvlist of delegated permissions
1788 */
1789 static int
1790 zfs_ioc_get_fsacl(zfs_cmd_t *zc)
1791 {
1792 nvlist_t *nvp;
1793 int error;
1794
1795 if ((error = dsl_deleg_get(zc->zc_name, &nvp)) == 0) {
1796 error = put_nvlist(zc, nvp);
1797 nvlist_free(nvp);
1798 }
1799
1800 return (error);
1801 }
1802
1803 /*
1804 * inputs:
1805 * zc_name name of volume
1806 *
1807 * outputs: none
1808 */
1809 static int
1810 zfs_ioc_create_minor(zfs_cmd_t *zc)
1811 {
1812 return (zvol_create_minor(zc->zc_name, ddi_driver_major(zfs_dip)));
1813 }
1814
1815 /*
1816 * inputs:
1817 * zc_name name of volume
1818 *
1819 * outputs: none
1820 */
1821 static int
1822 zfs_ioc_remove_minor(zfs_cmd_t *zc)
1823 {
1824 return (zvol_remove_minor(zc->zc_name));
1825 }
1826
1827 /*
1828 * Search the vfs list for a specified resource. Returns a pointer to it
1829 * or NULL if no suitable entry is found. The caller of this routine
1830 * is responsible for releasing the returned vfs pointer.
1831 */
1832 static vfs_t *
1833 zfs_get_vfs(const char *resource)
1834 {
1835 struct vfs *vfsp;
1836 struct vfs *vfs_found = NULL;
1837
1838 vfs_list_read_lock();
1839 vfsp = rootvfs;
1840 do {
1841 if (strcmp(refstr_value(vfsp->vfs_resource), resource) == 0) {
1842 VFS_HOLD(vfsp);
1843 vfs_found = vfsp;
1844 break;
1845 }
1846 vfsp = vfsp->vfs_next;
1847 } while (vfsp != rootvfs);
1848 vfs_list_unlock();
1849 return (vfs_found);
1850 }
1851
1852 /* ARGSUSED */
1853 static void
1854 zfs_create_cb(objset_t *os, void *arg, cred_t *cr, dmu_tx_t *tx)
1855 {
1856 zfs_creat_t *zct = arg;
1857
1858 zfs_create_fs(os, cr, zct->zct_zplprops, tx);
1859 }
1860
1861 #define ZFS_PROP_UNDEFINED ((uint64_t)-1)
1862
1863 /*
1864 * inputs:
1865 * createprops list of properties requested by creator
1866 * default_zplver zpl version to use if unspecified in createprops
1867 * fuids_ok fuids allowed in this version of the spa?
1868 * os parent objset pointer (NULL if root fs)
1869 *
1870 * outputs:
1871 * zplprops values for the zplprops we attach to the master node object
1872 * is_ci true if requested file system will be purely case-insensitive
1873 *
1874 * Determine the settings for utf8only, normalization and
1875 * casesensitivity. Specific values may have been requested by the
1876 * creator and/or we can inherit values from the parent dataset. If
1877 * the file system is of too early a vintage, a creator can not
1878 * request settings for these properties, even if the requested
1879 * setting is the default value. We don't actually want to create dsl
1880 * properties for these, so remove them from the source nvlist after
1881 * processing.
1882 */
1883 static int
1884 zfs_fill_zplprops_impl(objset_t *os, uint64_t default_zplver,
1885 boolean_t fuids_ok, nvlist_t *createprops, nvlist_t *zplprops,
1886 boolean_t *is_ci)
1887 {
1888 uint64_t zplver = default_zplver;
1889 uint64_t sense = ZFS_PROP_UNDEFINED;
1890 uint64_t norm = ZFS_PROP_UNDEFINED;
1891 uint64_t u8 = ZFS_PROP_UNDEFINED;
1892
1893 ASSERT(zplprops != NULL);
1894
1895 /*
1896 * Pull out creator prop choices, if any.
1897 */
1898 if (createprops) {
1899 (void) nvlist_lookup_uint64(createprops,
1900 zfs_prop_to_name(ZFS_PROP_VERSION), &zplver);
1901 (void) nvlist_lookup_uint64(createprops,
1902 zfs_prop_to_name(ZFS_PROP_NORMALIZE), &norm);
1903 (void) nvlist_remove_all(createprops,
1904 zfs_prop_to_name(ZFS_PROP_NORMALIZE));
1905 (void) nvlist_lookup_uint64(createprops,
1906 zfs_prop_to_name(ZFS_PROP_UTF8ONLY), &u8);
1907 (void) nvlist_remove_all(createprops,
1908 zfs_prop_to_name(ZFS_PROP_UTF8ONLY));
1909 (void) nvlist_lookup_uint64(createprops,
1910 zfs_prop_to_name(ZFS_PROP_CASE), &sense);
1911 (void) nvlist_remove_all(createprops,
1912 zfs_prop_to_name(ZFS_PROP_CASE));
1913 }
1914
1915 /*
1916 * If the zpl version requested is whacky or the file system
1917 * or pool is version is too "young" to support normalization
1918 * and the creator tried to set a value for one of the props,
1919 * error out.
1920 */
1921 if ((zplver < ZPL_VERSION_INITIAL || zplver > ZPL_VERSION) ||
1922 (zplver >= ZPL_VERSION_FUID && !fuids_ok) ||
1923 (zplver < ZPL_VERSION_NORMALIZATION &&
1924 (norm != ZFS_PROP_UNDEFINED || u8 != ZFS_PROP_UNDEFINED ||
1925 sense != ZFS_PROP_UNDEFINED)))
1926 return (ENOTSUP);
1927
1928 /*
1929 * Put the version in the zplprops
1930 */
1931 VERIFY(nvlist_add_uint64(zplprops,
1932 zfs_prop_to_name(ZFS_PROP_VERSION), zplver) == 0);
1933
1934 if (norm == ZFS_PROP_UNDEFINED)
1935 VERIFY(zfs_get_zplprop(os, ZFS_PROP_NORMALIZE, &norm) == 0);
1936 VERIFY(nvlist_add_uint64(zplprops,
1937 zfs_prop_to_name(ZFS_PROP_NORMALIZE), norm) == 0);
1938
1939 /*
1940 * If we're normalizing, names must always be valid UTF-8 strings.
1941 */
1942 if (norm)
1943 u8 = 1;
1944 if (u8 == ZFS_PROP_UNDEFINED)
1945 VERIFY(zfs_get_zplprop(os, ZFS_PROP_UTF8ONLY, &u8) == 0);
1946 VERIFY(nvlist_add_uint64(zplprops,
1947 zfs_prop_to_name(ZFS_PROP_UTF8ONLY), u8) == 0);
1948
1949 if (sense == ZFS_PROP_UNDEFINED)
1950 VERIFY(zfs_get_zplprop(os, ZFS_PROP_CASE, &sense) == 0);
1951 VERIFY(nvlist_add_uint64(zplprops,
1952 zfs_prop_to_name(ZFS_PROP_CASE), sense) == 0);
1953
1954 if (is_ci)
1955 *is_ci = (sense == ZFS_CASE_INSENSITIVE);
1956
1957 return (0);
1958 }
1959
1960 static int
1961 zfs_fill_zplprops(const char *dataset, nvlist_t *createprops,
1962 nvlist_t *zplprops, boolean_t *is_ci)
1963 {
1964 boolean_t fuids_ok = B_TRUE;
1965 uint64_t zplver = ZPL_VERSION;
1966 objset_t *os = NULL;
1967 char parentname[MAXNAMELEN];
1968 char *cp;
1969 int error;
1970
1971 (void) strlcpy(parentname, dataset, sizeof (parentname));
1972 cp = strrchr(parentname, '/');
1973 ASSERT(cp != NULL);
1974 cp[0] = '\0';
1975
1976 if (zfs_earlier_version(dataset, SPA_VERSION_FUID)) {
1977 zplver = ZPL_VERSION_FUID - 1;
1978 fuids_ok = B_FALSE;
1979 }
1980
1981 /*
1982 * Open parent object set so we can inherit zplprop values.
1983 */
1984 if ((error = dmu_objset_open(parentname, DMU_OST_ANY,
1985 DS_MODE_USER | DS_MODE_READONLY, &os)) != 0)
1986 return (error);
1987
1988 error = zfs_fill_zplprops_impl(os, zplver, fuids_ok, createprops,
1989 zplprops, is_ci);
1990 dmu_objset_close(os);
1991 return (error);
1992 }
1993
1994 static int
1995 zfs_fill_zplprops_root(uint64_t spa_vers, nvlist_t *createprops,
1996 nvlist_t *zplprops, boolean_t *is_ci)
1997 {
1998 boolean_t fuids_ok = B_TRUE;
1999 uint64_t zplver = ZPL_VERSION;
2000 int error;
2001
2002 if (spa_vers < SPA_VERSION_FUID) {
2003 zplver = ZPL_VERSION_FUID - 1;
2004 fuids_ok = B_FALSE;
2005 }
2006
2007 error = zfs_fill_zplprops_impl(NULL, zplver, fuids_ok, createprops,
2008 zplprops, is_ci);
2009 return (error);
2010 }
2011
2012 /*
2013 * inputs:
2014 * zc_objset_type type of objset to create (fs vs zvol)
2015 * zc_name name of new objset
2016 * zc_value name of snapshot to clone from (may be empty)
2017 * zc_nvlist_src{_size} nvlist of properties to apply
2018 *
2019 * outputs: none
2020 */
2021 static int
2022 zfs_ioc_create(zfs_cmd_t *zc)
2023 {
2024 objset_t *clone;
2025 int error = 0;
2026 zfs_creat_t zct;
2027 nvlist_t *nvprops = NULL;
2028 void (*cbfunc)(objset_t *os, void *arg, cred_t *cr, dmu_tx_t *tx);
2029 dmu_objset_type_t type = zc->zc_objset_type;
2030
2031 switch (type) {
2032
2033 case DMU_OST_ZFS:
2034 cbfunc = zfs_create_cb;
2035 break;
2036
2037 case DMU_OST_ZVOL:
2038 cbfunc = zvol_create_cb;
2039 break;
2040
2041 default:
2042 cbfunc = NULL;
2043 break;
2044 }
2045 if (strchr(zc->zc_name, '@') ||
2046 strchr(zc->zc_name, '%'))
2047 return (EINVAL);
2048
2049 if (zc->zc_nvlist_src != NULL &&
2050 (error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
2051 &nvprops)) != 0)
2052 return (error);
2053
2054 zct.zct_zplprops = NULL;
2055 zct.zct_props = nvprops;
2056
2057 if (zc->zc_value[0] != '\0') {
2058 /*
2059 * We're creating a clone of an existing snapshot.
2060 */
2061 zc->zc_value[sizeof (zc->zc_value) - 1] = '\0';
2062 if (dataset_namecheck(zc->zc_value, NULL, NULL) != 0) {
2063 nvlist_free(nvprops);
2064 return (EINVAL);
2065 }
2066
2067 error = dmu_objset_open(zc->zc_value, type,
2068 DS_MODE_USER | DS_MODE_READONLY, &clone);
2069 if (error) {
2070 nvlist_free(nvprops);
2071 return (error);
2072 }
2073
2074 error = dmu_objset_create(zc->zc_name, type, clone, 0,
2075 NULL, NULL);
2076 if (error) {
2077 dmu_objset_close(clone);
2078 nvlist_free(nvprops);
2079 return (error);
2080 }
2081 dmu_objset_close(clone);
2082 } else {
2083 boolean_t is_insensitive = B_FALSE;
2084
2085 if (cbfunc == NULL) {
2086 nvlist_free(nvprops);
2087 return (EINVAL);
2088 }
2089
2090 if (type == DMU_OST_ZVOL) {
2091 uint64_t volsize, volblocksize;
2092
2093 if (nvprops == NULL ||
2094 nvlist_lookup_uint64(nvprops,
2095 zfs_prop_to_name(ZFS_PROP_VOLSIZE),
2096 &volsize) != 0) {
2097 nvlist_free(nvprops);
2098 return (EINVAL);
2099 }
2100
2101 if ((error = nvlist_lookup_uint64(nvprops,
2102 zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE),
2103 &volblocksize)) != 0 && error != ENOENT) {
2104 nvlist_free(nvprops);
2105 return (EINVAL);
2106 }
2107
2108 if (error != 0)
2109 volblocksize = zfs_prop_default_numeric(
2110 ZFS_PROP_VOLBLOCKSIZE);
2111
2112 if ((error = zvol_check_volblocksize(
2113 volblocksize)) != 0 ||
2114 (error = zvol_check_volsize(volsize,
2115 volblocksize)) != 0) {
2116 nvlist_free(nvprops);
2117 return (error);
2118 }
2119 } else if (type == DMU_OST_ZFS) {
2120 int error;
2121
2122 /*
2123 * We have to have normalization and
2124 * case-folding flags correct when we do the
2125 * file system creation, so go figure them out
2126 * now.
2127 */
2128 VERIFY(nvlist_alloc(&zct.zct_zplprops,
2129 NV_UNIQUE_NAME, KM_SLEEP) == 0);
2130 error = zfs_fill_zplprops(zc->zc_name, nvprops,
2131 zct.zct_zplprops, &is_insensitive);
2132 if (error != 0) {
2133 nvlist_free(nvprops);
2134 nvlist_free(zct.zct_zplprops);
2135 return (error);
2136 }
2137 }
2138 error = dmu_objset_create(zc->zc_name, type, NULL,
2139 is_insensitive ? DS_FLAG_CI_DATASET : 0, cbfunc, &zct);
2140 nvlist_free(zct.zct_zplprops);
2141 }
2142
2143 /*
2144 * It would be nice to do this atomically.
2145 */
2146 if (error == 0) {
2147 if ((error = zfs_set_prop_nvlist(zc->zc_name, nvprops)) != 0)
2148 (void) dmu_objset_destroy(zc->zc_name);
2149 }
2150 nvlist_free(nvprops);
2151 return (error);
2152 }
2153
2154 struct snap_prop_arg {
2155 nvlist_t *nvprops;
2156 const char *snapname;
2157 };
2158
2159 static int
2160 set_snap_props(char *name, void *arg)
2161 {
2162 struct snap_prop_arg *snpa = arg;
2163 int len = strlen(name) + strlen(snpa->snapname) + 2;
2164 char *buf = kmem_alloc(len, KM_SLEEP);
2165 int err;
2166
2167 (void) snprintf(buf, len, "%s@%s", name, snpa->snapname);
2168 err = zfs_set_prop_nvlist(buf, snpa->nvprops);
2169 if (err)
2170 (void) dmu_objset_destroy(buf);
2171 kmem_free(buf, len);
2172 return (err);
2173 }
2174
2175 /*
2176 * inputs:
2177 * zc_name name of filesystem
2178 * zc_value short name of snapshot
2179 * zc_cookie recursive flag
2180 *
2181 * outputs: none
2182 */
2183 static int
2184 zfs_ioc_snapshot(zfs_cmd_t *zc)
2185 {
2186 nvlist_t *nvprops = NULL;
2187 int error;
2188 boolean_t recursive = zc->zc_cookie;
2189
2190 if (snapshot_namecheck(zc->zc_value, NULL, NULL) != 0)
2191 return (EINVAL);
2192
2193 if (zc->zc_nvlist_src != NULL &&
2194 (error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
2195 &nvprops)) != 0)
2196 return (error);
2197
2198 error = dmu_objset_snapshot(zc->zc_name, zc->zc_value, recursive);
2199
2200 /*
2201 * It would be nice to do this atomically.
2202 */
2203 if (error == 0) {
2204 struct snap_prop_arg snpa;
2205 snpa.nvprops = nvprops;
2206 snpa.snapname = zc->zc_value;
2207 if (recursive) {
2208 error = dmu_objset_find(zc->zc_name,
2209 set_snap_props, &snpa, DS_FIND_CHILDREN);
2210 if (error) {
2211 (void) dmu_snapshots_destroy(zc->zc_name,
2212 zc->zc_value);
2213 }
2214 } else {
2215 error = set_snap_props(zc->zc_name, &snpa);
2216 }
2217 }
2218 nvlist_free(nvprops);
2219 return (error);
2220 }
2221
2222 int
2223 zfs_unmount_snap(char *name, void *arg)
2224 {
2225 vfs_t *vfsp = NULL;
2226
2227 if (arg) {
2228 char *snapname = arg;
2229 int len = strlen(name) + strlen(snapname) + 2;
2230 char *buf = kmem_alloc(len, KM_SLEEP);
2231
2232 (void) strcpy(buf, name);
2233 (void) strcat(buf, "@");
2234 (void) strcat(buf, snapname);
2235 vfsp = zfs_get_vfs(buf);
2236 kmem_free(buf, len);
2237 } else if (strchr(name, '@')) {
2238 vfsp = zfs_get_vfs(name);
2239 }
2240
2241 if (vfsp) {
2242 /*
2243 * Always force the unmount for snapshots.
2244 */
2245 int flag = MS_FORCE;
2246 int err;
2247
2248 if ((err = vn_vfswlock(vfsp->vfs_vnodecovered)) != 0) {
2249 VFS_RELE(vfsp);
2250 return (err);
2251 }
2252 VFS_RELE(vfsp);
2253 if ((err = dounmount(vfsp, flag, kcred)) != 0)
2254 return (err);
2255 }
2256 return (0);
2257 }
2258
2259 /*
2260 * inputs:
2261 * zc_name name of filesystem
2262 * zc_value short name of snapshot
2263 *
2264 * outputs: none
2265 */
2266 static int
2267 zfs_ioc_destroy_snaps(zfs_cmd_t *zc)
2268 {
2269 int err;
2270
2271 if (snapshot_namecheck(zc->zc_value, NULL, NULL) != 0)
2272 return (EINVAL);
2273 err = dmu_objset_find(zc->zc_name,
2274 zfs_unmount_snap, zc->zc_value, DS_FIND_CHILDREN);
2275 if (err)
2276 return (err);
2277 return (dmu_snapshots_destroy(zc->zc_name, zc->zc_value));
2278 }
2279
2280 /*
2281 * inputs:
2282 * zc_name name of dataset to destroy
2283 * zc_objset_type type of objset
2284 *
2285 * outputs: none
2286 */
2287 static int
2288 zfs_ioc_destroy(zfs_cmd_t *zc)
2289 {
2290 if (strchr(zc->zc_name, '@') && zc->zc_objset_type == DMU_OST_ZFS) {
2291 int err = zfs_unmount_snap(zc->zc_name, NULL);
2292 if (err)
2293 return (err);
2294 }
2295
2296 return (dmu_objset_destroy(zc->zc_name));
2297 }
2298
2299 /*
2300 * inputs:
2301 * zc_name name of dataset to rollback (to most recent snapshot)
2302 *
2303 * outputs: none
2304 */
2305 static int
2306 zfs_ioc_rollback(zfs_cmd_t *zc)
2307 {
2308 objset_t *os;
2309 int error;
2310 zfsvfs_t *zfsvfs = NULL;
2311
2312 /*
2313 * Get the zfsvfs for the receiving objset. There
2314 * won't be one if we're operating on a zvol, if the
2315 * objset doesn't exist yet, or is not mounted.
2316 */
2317 error = dmu_objset_open(zc->zc_name, DMU_OST_ANY, DS_MODE_USER, &os);
2318 if (error)
2319 return (error);
2320
2321 if (dmu_objset_type(os) == DMU_OST_ZFS) {
2322 mutex_enter(&os->os->os_user_ptr_lock);
2323 zfsvfs = dmu_objset_get_user(os);
2324 if (zfsvfs != NULL)
2325 VFS_HOLD(zfsvfs->z_vfs);
2326 mutex_exit(&os->os->os_user_ptr_lock);
2327 }
2328
2329 if (zfsvfs != NULL) {
2330 char *osname;
2331 int mode;
2332
2333 osname = kmem_alloc(MAXNAMELEN, KM_SLEEP);
2334 error = zfs_suspend_fs(zfsvfs, osname, &mode);
2335 if (error == 0) {
2336 int resume_err;
2337
2338 ASSERT(strcmp(osname, zc->zc_name) == 0);
2339 error = dmu_objset_rollback(os);
2340 resume_err = zfs_resume_fs(zfsvfs, osname, mode);
2341 error = error ? error : resume_err;
2342 } else {
2343 dmu_objset_close(os);
2344 }
2345 kmem_free(osname, MAXNAMELEN);
2346 VFS_RELE(zfsvfs->z_vfs);
2347 } else {
2348 error = dmu_objset_rollback(os);
2349 }
2350 /* Note, the dmu_objset_rollback() releases the objset for us. */
2351
2352 return (error);
2353 }
2354
2355 /*
2356 * inputs:
2357 * zc_name old name of dataset
2358 * zc_value new name of dataset
2359 * zc_cookie recursive flag (only valid for snapshots)
2360 *
2361 * outputs: none
2362 */
2363 static int
2364 zfs_ioc_rename(zfs_cmd_t *zc)
2365 {
2366 boolean_t recursive = zc->zc_cookie & 1;
2367
2368 zc->zc_value[sizeof (zc->zc_value) - 1] = '\0';
2369 if (dataset_namecheck(zc->zc_value, NULL, NULL) != 0 ||
2370 strchr(zc->zc_value, '%'))
2371 return (EINVAL);
2372
2373 /*
2374 * Unmount snapshot unless we're doing a recursive rename,
2375 * in which case the dataset code figures out which snapshots
2376 * to unmount.
2377 */
2378 if (!recursive && strchr(zc->zc_name, '@') != NULL &&
2379 zc->zc_objset_type == DMU_OST_ZFS) {
2380 int err = zfs_unmount_snap(zc->zc_name, NULL);
2381 if (err)
2382 return (err);
2383 }
2384 return (dmu_objset_rename(zc->zc_name, zc->zc_value, recursive));
2385 }
2386
2387 static void
2388 clear_props(char *dataset, nvlist_t *props)
2389 {
2390 zfs_cmd_t *zc;
2391 nvpair_t *prop;
2392
2393 if (props == NULL)
2394 return;
2395 zc = kmem_alloc(sizeof (zfs_cmd_t), KM_SLEEP);
2396 (void) strcpy(zc->zc_name, dataset);
2397 for (prop = nvlist_next_nvpair(props, NULL); prop;
2398 prop = nvlist_next_nvpair(props, prop)) {
2399 (void) strcpy(zc->zc_value, nvpair_name(prop));
2400 if (zfs_secpolicy_inherit(zc, CRED()) == 0)
2401 (void) zfs_ioc_inherit_prop(zc);
2402 }
2403 kmem_free(zc, sizeof (zfs_cmd_t));
2404 }
2405
2406 /*
2407 * inputs:
2408 * zc_name name of containing filesystem
2409 * zc_nvlist_src{_size} nvlist of properties to apply
2410 * zc_value name of snapshot to create
2411 * zc_string name of clone origin (if DRR_FLAG_CLONE)
2412 * zc_cookie file descriptor to recv from
2413 * zc_begin_record the BEGIN record of the stream (not byteswapped)
2414 * zc_guid force flag
2415 *
2416 * outputs:
2417 * zc_cookie number of bytes read
2418 */
2419 static int
2420 zfs_ioc_recv(zfs_cmd_t *zc)
2421 {
2422 file_t *fp;
2423 objset_t *os;
2424 dmu_recv_cookie_t drc;
2425 zfsvfs_t *zfsvfs = NULL;
2426 boolean_t force = (boolean_t)zc->zc_guid;
2427 int error, fd;
2428 offset_t off;
2429 nvlist_t *props = NULL;
2430 nvlist_t *origprops = NULL;
2431 objset_t *origin = NULL;
2432 char *tosnap;
2433 char tofs[ZFS_MAXNAMELEN];
2434
2435 if (dataset_namecheck(zc->zc_value, NULL, NULL) != 0 ||
2436 strchr(zc->zc_value, '@') == NULL ||
2437 strchr(zc->zc_value, '%'))
2438 return (EINVAL);
2439
2440 (void) strcpy(tofs, zc->zc_value);
2441 tosnap = strchr(tofs, '@');
2442 *tosnap = '\0';
2443 tosnap++;
2444
2445 if (zc->zc_nvlist_src != NULL &&
2446 (error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
2447 &props)) != 0)
2448 return (error);
2449
2450 fd = zc->zc_cookie;
2451 fp = getf(fd);
2452 if (fp == NULL) {
2453 nvlist_free(props);
2454 return (EBADF);
2455 }
2456
2457 if (dmu_objset_open(tofs, DMU_OST_ANY,
2458 DS_MODE_USER | DS_MODE_READONLY, &os) == 0) {
2459 /*
2460 * Try to get the zfsvfs for the receiving objset.
2461 * There won't be one if we're operating on a zvol,
2462 * if the objset doesn't exist yet, or is not mounted.
2463 */
2464 mutex_enter(&os->os->os_user_ptr_lock);
2465 if (zfsvfs = dmu_objset_get_user(os)) {
2466 if (!mutex_tryenter(&zfsvfs->z_online_recv_lock)) {
2467 mutex_exit(&os->os->os_user_ptr_lock);
2468 dmu_objset_close(os);
2469 zfsvfs = NULL;
2470 error = EBUSY;
2471 goto out;
2472 }
2473 VFS_HOLD(zfsvfs->z_vfs);
2474 }
2475 mutex_exit(&os->os->os_user_ptr_lock);
2476
2477 /*
2478 * If new properties are supplied, they are to completely
2479 * replace the existing ones, so stash away the existing ones.
2480 */
2481 if (props)
2482 (void) dsl_prop_get_all(os, &origprops, TRUE);
2483
2484 dmu_objset_close(os);
2485 }
2486
2487 if (zc->zc_string[0]) {
2488 error = dmu_objset_open(zc->zc_string, DMU_OST_ANY,
2489 DS_MODE_USER | DS_MODE_READONLY, &origin);
2490 if (error)
2491 goto out;
2492 }
2493
2494 error = dmu_recv_begin(tofs, tosnap, &zc->zc_begin_record,
2495 force, origin, zfsvfs != NULL, &drc);
2496 if (origin)
2497 dmu_objset_close(origin);
2498 if (error)
2499 goto out;
2500
2501 /*
2502 * Reset properties. We do this before we receive the stream
2503 * so that the properties are applied to the new data.
2504 */
2505 if (props) {
2506 clear_props(tofs, origprops);
2507 /*
2508 * XXX - Note, this is all-or-nothing; should be best-effort.
2509 */
2510 (void) zfs_set_prop_nvlist(tofs, props);
2511 }
2512
2513 off = fp->f_offset;
2514 error = dmu_recv_stream(&drc, fp->f_vnode, &off);
2515
2516 if (error == 0 && zfsvfs) {
2517 char *osname;
2518 int mode;
2519
2520 /* online recv */
2521 osname = kmem_alloc(MAXNAMELEN, KM_SLEEP);
2522 error = zfs_suspend_fs(zfsvfs, osname, &mode);
2523 if (error == 0) {
2524 int resume_err;
2525
2526 error = dmu_recv_end(&drc);
2527 resume_err = zfs_resume_fs(zfsvfs, osname, mode);
2528 error = error ? error : resume_err;
2529 } else {
2530 dmu_recv_abort_cleanup(&drc);
2531 }
2532 kmem_free(osname, MAXNAMELEN);
2533 } else if (error == 0) {
2534 error = dmu_recv_end(&drc);
2535 }
2536
2537 zc->zc_cookie = off - fp->f_offset;
2538 if (VOP_SEEK(fp->f_vnode, fp->f_offset, &off, NULL) == 0)
2539 fp->f_offset = off;
2540
2541 /*
2542 * On error, restore the original props.
2543 */
2544 if (error && props) {
2545 clear_props(tofs, props);
2546 (void) zfs_set_prop_nvlist(tofs, origprops);
2547 }
2548 out:
2549 if (zfsvfs) {
2550 mutex_exit(&zfsvfs->z_online_recv_lock);
2551 VFS_RELE(zfsvfs->z_vfs);
2552 }
2553 nvlist_free(props);
2554 nvlist_free(origprops);
2555 releasef(fd);
2556 return (error);
2557 }
2558
2559 /*
2560 * inputs:
2561 * zc_name name of snapshot to send
2562 * zc_value short name of incremental fromsnap (may be empty)
2563 * zc_cookie file descriptor to send stream to
2564 * zc_obj fromorigin flag (mutually exclusive with zc_value)
2565 *
2566 * outputs: none
2567 */
2568 static int
2569 zfs_ioc_send(zfs_cmd_t *zc)
2570 {
2571 objset_t *fromsnap = NULL;
2572 objset_t *tosnap;
2573 file_t *fp;
2574 int error;
2575 offset_t off;
2576
2577 error = dmu_objset_open(zc->zc_name, DMU_OST_ANY,
2578 DS_MODE_USER | DS_MODE_READONLY, &tosnap);
2579 if (error)
2580 return (error);
2581
2582 if (zc->zc_value[0] != '\0') {
2583 char *buf;
2584 char *cp;
2585
2586 buf = kmem_alloc(MAXPATHLEN, KM_SLEEP);
2587 (void) strncpy(buf, zc->zc_name, MAXPATHLEN);
2588 cp = strchr(buf, '@');
2589 if (cp)
2590 *(cp+1) = 0;
2591 (void) strncat(buf, zc->zc_value, MAXPATHLEN);
2592 error = dmu_objset_open(buf, DMU_OST_ANY,
2593 DS_MODE_USER | DS_MODE_READONLY, &fromsnap);
2594 kmem_free(buf, MAXPATHLEN);
2595 if (error) {
2596 dmu_objset_close(tosnap);
2597 return (error);
2598 }
2599 }
2600
2601 fp = getf(zc->zc_cookie);
2602 if (fp == NULL) {
2603 dmu_objset_close(tosnap);
2604 if (fromsnap)
2605 dmu_objset_close(fromsnap);
2606 return (EBADF);
2607 }
2608
2609 off = fp->f_offset;
2610 error = dmu_sendbackup(tosnap, fromsnap, zc->zc_obj, fp->f_vnode, &off);
2611
2612 if (VOP_SEEK(fp->f_vnode, fp->f_offset, &off, NULL) == 0)
2613 fp->f_offset = off;
2614 releasef(zc->zc_cookie);
2615 if (fromsnap)
2616 dmu_objset_close(fromsnap);
2617 dmu_objset_close(tosnap);
2618 return (error);
2619 }
2620
2621 static int
2622 zfs_ioc_inject_fault(zfs_cmd_t *zc)
2623 {
2624 int id, error;
2625
2626 error = zio_inject_fault(zc->zc_name, (int)zc->zc_guid, &id,
2627 &zc->zc_inject_record);
2628
2629 if (error == 0)
2630 zc->zc_guid = (uint64_t)id;
2631
2632 return (error);
2633 }
2634
2635 static int
2636 zfs_ioc_clear_fault(zfs_cmd_t *zc)
2637 {
2638 return (zio_clear_fault((int)zc->zc_guid));
2639 }
2640
2641 static int
2642 zfs_ioc_inject_list_next(zfs_cmd_t *zc)
2643 {
2644 int id = (int)zc->zc_guid;
2645 int error;
2646
2647 error = zio_inject_list_next(&id, zc->zc_name, sizeof (zc->zc_name),
2648 &zc->zc_inject_record);
2649
2650 zc->zc_guid = id;
2651
2652 return (error);
2653 }
2654
2655 static int
2656 zfs_ioc_error_log(zfs_cmd_t *zc)
2657 {
2658 spa_t *spa;
2659 int error;
2660 size_t count = (size_t)zc->zc_nvlist_dst_size;
2661
2662 if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
2663 return (error);
2664
2665 error = spa_get_errlog(spa, (void *)(uintptr_t)zc->zc_nvlist_dst,
2666 &count);
2667 if (error == 0)
2668 zc->zc_nvlist_dst_size = count;
2669 else
2670 zc->zc_nvlist_dst_size = spa_get_errlog_size(spa);
2671
2672 spa_close(spa, FTAG);
2673
2674 return (error);
2675 }
2676
2677 static int
2678 zfs_ioc_clear(zfs_cmd_t *zc)
2679 {
2680 spa_t *spa;
2681 vdev_t *vd;
2682 int error;
2683
2684 /*
2685 * On zpool clear we also fix up missing slogs
2686 */
2687 mutex_enter(&spa_namespace_lock);
2688 spa = spa_lookup(zc->zc_name);
2689 if (spa == NULL) {
2690 mutex_exit(&spa_namespace_lock);
2691 return (EIO);
2692 }
2693 if (spa->spa_log_state == SPA_LOG_MISSING) {
2694 /* we need to let spa_open/spa_load clear the chains */
2695 spa->spa_log_state = SPA_LOG_CLEAR;
2696 }
2697 mutex_exit(&spa_namespace_lock);
2698
2699 if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
2700 return (error);
2701
2702 spa_vdev_state_enter(spa);
2703
2704 if (zc->zc_guid == 0) {
2705 vd = NULL;
2706 } else {
2707 vd = spa_lookup_by_guid(spa, zc->zc_guid, B_TRUE);
2708 if (vd == NULL) {
2709 (void) spa_vdev_state_exit(spa, NULL, ENODEV);
2710 spa_close(spa, FTAG);
2711 return (ENODEV);
2712 }
2713 }
2714
2715 vdev_clear(spa, vd);
2716
2717 (void) spa_vdev_state_exit(spa, NULL, 0);
2718
2719 /*
2720 * Resume any suspended I/Os.
2721 */
2722 zio_resume(spa);
2723
2724 spa_close(spa, FTAG);
2725
2726 return (0);
2727 }
2728
2729 /*
2730 * inputs:
2731 * zc_name name of filesystem
2732 * zc_value name of origin snapshot
2733 *
2734 * outputs: none
2735 */
2736 static int
2737 zfs_ioc_promote(zfs_cmd_t *zc)
2738 {
2739 char *cp;
2740
2741 /*
2742 * We don't need to unmount *all* the origin fs's snapshots, but
2743 * it's easier.
2744 */
2745 cp = strchr(zc->zc_value, '@');
2746 if (cp)
2747 *cp = '\0';
2748 (void) dmu_objset_find(zc->zc_value,
2749 zfs_unmount_snap, NULL, DS_FIND_SNAPSHOTS);
2750 return (dsl_dataset_promote(zc->zc_name));
2751 }
2752
2753 /*
2754 * We don't want to have a hard dependency
2755 * against some special symbols in sharefs
2756 * nfs, and smbsrv. Determine them if needed when
2757 * the first file system is shared.
2758 * Neither sharefs, nfs or smbsrv are unloadable modules.
2759 */
2760 int (*znfsexport_fs)(void *arg);
2761 int (*zshare_fs)(enum sharefs_sys_op, share_t *, uint32_t);
2762 int (*zsmbexport_fs)(void *arg, boolean_t add_share);
2763
2764 int zfs_nfsshare_inited;
2765 int zfs_smbshare_inited;
2766
2767 ddi_modhandle_t nfs_mod;
2768 ddi_modhandle_t sharefs_mod;
2769 ddi_modhandle_t smbsrv_mod;
2770 kmutex_t zfs_share_lock;
2771
2772 static int
2773 zfs_init_sharefs()
2774 {
2775 int error;
2776
2777 ASSERT(MUTEX_HELD(&zfs_share_lock));
2778 /* Both NFS and SMB shares also require sharetab support. */
2779 if (sharefs_mod == NULL && ((sharefs_mod =
2780 ddi_modopen("fs/sharefs",
2781 KRTLD_MODE_FIRST, &error)) == NULL)) {
2782 return (ENOSYS);
2783 }
2784 if (zshare_fs == NULL && ((zshare_fs =
2785 (int (*)(enum sharefs_sys_op, share_t *, uint32_t))
2786 ddi_modsym(sharefs_mod, "sharefs_impl", &error)) == NULL)) {
2787 return (ENOSYS);
2788 }
2789 return (0);
2790 }
2791
2792 static int
2793 zfs_ioc_share(zfs_cmd_t *zc)
2794 {
2795 int error;
2796 int opcode;
2797
2798 switch (zc->zc_share.z_sharetype) {
2799 case ZFS_SHARE_NFS:
2800 case ZFS_UNSHARE_NFS:
2801 if (zfs_nfsshare_inited == 0) {
2802 mutex_enter(&zfs_share_lock);
2803 if (nfs_mod == NULL && ((nfs_mod = ddi_modopen("fs/nfs",
2804 KRTLD_MODE_FIRST, &error)) == NULL)) {
2805 mutex_exit(&zfs_share_lock);
2806 return (ENOSYS);
2807 }
2808 if (znfsexport_fs == NULL &&
2809 ((znfsexport_fs = (int (*)(void *))
2810 ddi_modsym(nfs_mod,
2811 "nfs_export", &error)) == NULL)) {
2812 mutex_exit(&zfs_share_lock);
2813 return (ENOSYS);
2814 }
2815 error = zfs_init_sharefs();
2816 if (error) {
2817 mutex_exit(&zfs_share_lock);
2818 return (ENOSYS);
2819 }
2820 zfs_nfsshare_inited = 1;
2821 mutex_exit(&zfs_share_lock);
2822 }
2823 break;
2824 case ZFS_SHARE_SMB:
2825 case ZFS_UNSHARE_SMB:
2826 if (zfs_smbshare_inited == 0) {
2827 mutex_enter(&zfs_share_lock);
2828 if (smbsrv_mod == NULL && ((smbsrv_mod =
2829 ddi_modopen("drv/smbsrv",
2830 KRTLD_MODE_FIRST, &error)) == NULL)) {
2831 mutex_exit(&zfs_share_lock);
2832 return (ENOSYS);
2833 }
2834 if (zsmbexport_fs == NULL && ((zsmbexport_fs =
2835 (int (*)(void *, boolean_t))ddi_modsym(smbsrv_mod,
2836 "smb_server_share", &error)) == NULL)) {
2837 mutex_exit(&zfs_share_lock);
2838 return (ENOSYS);
2839 }
2840 error = zfs_init_sharefs();
2841 if (error) {
2842 mutex_exit(&zfs_share_lock);
2843 return (ENOSYS);
2844 }
2845 zfs_smbshare_inited = 1;
2846 mutex_exit(&zfs_share_lock);
2847 }
2848 break;
2849 default:
2850 return (EINVAL);
2851 }
2852
2853 switch (zc->zc_share.z_sharetype) {
2854 case ZFS_SHARE_NFS:
2855 case ZFS_UNSHARE_NFS:
2856 if (error =
2857 znfsexport_fs((void *)
2858 (uintptr_t)zc->zc_share.z_exportdata))
2859 return (error);
2860 break;
2861 case ZFS_SHARE_SMB:
2862 case ZFS_UNSHARE_SMB:
2863 if (error = zsmbexport_fs((void *)
2864 (uintptr_t)zc->zc_share.z_exportdata,
2865 zc->zc_share.z_sharetype == ZFS_SHARE_SMB ?
2866 B_TRUE : B_FALSE)) {
2867 return (error);
2868 }
2869 break;
2870 }
2871
2872 opcode = (zc->zc_share.z_sharetype == ZFS_SHARE_NFS ||
2873 zc->zc_share.z_sharetype == ZFS_SHARE_SMB) ?
2874 SHAREFS_ADD : SHAREFS_REMOVE;
2875
2876 /*
2877 * Add or remove share from sharetab
2878 */
2879 error = zshare_fs(opcode,
2880 (void *)(uintptr_t)zc->zc_share.z_sharedata,
2881 zc->zc_share.z_sharemax);
2882
2883 return (error);
2884
2885 }
2886
2887 /*
2888 * pool create, destroy, and export don't log the history as part of
2889 * zfsdev_ioctl, but rather zfs_ioc_pool_create, and zfs_ioc_pool_export
2890 * do the logging of those commands.
2891 */
2892 static zfs_ioc_vec_t zfs_ioc_vec[] = {
2893 { zfs_ioc_pool_create, zfs_secpolicy_config, POOL_NAME, B_FALSE },
2894 { zfs_ioc_pool_destroy, zfs_secpolicy_config, POOL_NAME, B_FALSE },
2895 { zfs_ioc_pool_import, zfs_secpolicy_config, POOL_NAME, B_TRUE },
2896 { zfs_ioc_pool_export, zfs_secpolicy_config, POOL_NAME, B_FALSE },
2897 { zfs_ioc_pool_configs, zfs_secpolicy_none, NO_NAME, B_FALSE },
2898 { zfs_ioc_pool_stats, zfs_secpolicy_read, POOL_NAME, B_FALSE },
2899 { zfs_ioc_pool_tryimport, zfs_secpolicy_config, NO_NAME, B_FALSE },
2900 { zfs_ioc_pool_scrub, zfs_secpolicy_config, POOL_NAME, B_TRUE },
2901 { zfs_ioc_pool_freeze, zfs_secpolicy_config, NO_NAME, B_FALSE },
2902 { zfs_ioc_pool_upgrade, zfs_secpolicy_config, POOL_NAME, B_TRUE },
2903 { zfs_ioc_pool_get_history, zfs_secpolicy_config, POOL_NAME, B_FALSE },
2904 { zfs_ioc_vdev_add, zfs_secpolicy_config, POOL_NAME, B_TRUE },
2905 { zfs_ioc_vdev_remove, zfs_secpolicy_config, POOL_NAME, B_TRUE },
2906 { zfs_ioc_vdev_set_state, zfs_secpolicy_config, POOL_NAME, B_TRUE },
2907 { zfs_ioc_vdev_attach, zfs_secpolicy_config, POOL_NAME, B_TRUE },
2908 { zfs_ioc_vdev_detach, zfs_secpolicy_config, POOL_NAME, B_TRUE },
2909 { zfs_ioc_vdev_setpath, zfs_secpolicy_config, POOL_NAME, B_FALSE },
2910 { zfs_ioc_objset_stats, zfs_secpolicy_read, DATASET_NAME, B_FALSE },
2911 { zfs_ioc_objset_zplprops, zfs_secpolicy_read, DATASET_NAME, B_FALSE },
2912 { zfs_ioc_dataset_list_next, zfs_secpolicy_read,
2913 DATASET_NAME, B_FALSE },
2914 { zfs_ioc_snapshot_list_next, zfs_secpolicy_read,
2915 DATASET_NAME, B_FALSE },
2916 { zfs_ioc_set_prop, zfs_secpolicy_none, DATASET_NAME, B_TRUE },
2917 { zfs_ioc_create_minor, zfs_secpolicy_minor, DATASET_NAME, B_FALSE },
2918 { zfs_ioc_remove_minor, zfs_secpolicy_minor, DATASET_NAME, B_FALSE },
2919 { zfs_ioc_create, zfs_secpolicy_create, DATASET_NAME, B_TRUE },
2920 { zfs_ioc_destroy, zfs_secpolicy_destroy, DATASET_NAME, B_TRUE },
2921 { zfs_ioc_rollback, zfs_secpolicy_rollback, DATASET_NAME, B_TRUE },
2922 { zfs_ioc_rename, zfs_secpolicy_rename, DATASET_NAME, B_TRUE },
2923 { zfs_ioc_recv, zfs_secpolicy_receive, DATASET_NAME, B_TRUE },
2924 { zfs_ioc_send, zfs_secpolicy_send, DATASET_NAME, B_TRUE },
2925 { zfs_ioc_inject_fault, zfs_secpolicy_inject, NO_NAME, B_FALSE },
2926 { zfs_ioc_clear_fault, zfs_secpolicy_inject, NO_NAME, B_FALSE },
2927 { zfs_ioc_inject_list_next, zfs_secpolicy_inject, NO_NAME, B_FALSE },
2928 { zfs_ioc_error_log, zfs_secpolicy_inject, POOL_NAME, B_FALSE },
2929 { zfs_ioc_clear, zfs_secpolicy_config, POOL_NAME, B_TRUE },
2930 { zfs_ioc_promote, zfs_secpolicy_promote, DATASET_NAME, B_TRUE },
2931 { zfs_ioc_destroy_snaps, zfs_secpolicy_destroy, DATASET_NAME, B_TRUE },
2932 { zfs_ioc_snapshot, zfs_secpolicy_snapshot, DATASET_NAME, B_TRUE },
2933 { zfs_ioc_dsobj_to_dsname, zfs_secpolicy_config, POOL_NAME, B_FALSE },
2934 { zfs_ioc_obj_to_path, zfs_secpolicy_config, NO_NAME, B_FALSE },
2935 { zfs_ioc_pool_set_props, zfs_secpolicy_config, POOL_NAME, B_TRUE },
2936 { zfs_ioc_pool_get_props, zfs_secpolicy_read, POOL_NAME, B_FALSE },
2937 { zfs_ioc_set_fsacl, zfs_secpolicy_fsacl, DATASET_NAME, B_TRUE },
2938 { zfs_ioc_get_fsacl, zfs_secpolicy_read, DATASET_NAME, B_FALSE },
2939 { zfs_ioc_iscsi_perm_check, zfs_secpolicy_iscsi,
2940 DATASET_NAME, B_FALSE },
2941 { zfs_ioc_share, zfs_secpolicy_share, DATASET_NAME, B_FALSE },
2942 { zfs_ioc_inherit_prop, zfs_secpolicy_inherit, DATASET_NAME, B_TRUE },
2943 };
2944
2945 static int
2946 zfsdev_ioctl(dev_t dev, int cmd, intptr_t arg, int flag, cred_t *cr, int *rvalp)
2947 {
2948 zfs_cmd_t *zc;
2949 uint_t vec;
2950 int error, rc;
2951
2952 if (getminor(dev) != 0)
2953 return (zvol_ioctl(dev, cmd, arg, flag, cr, rvalp));
2954
2955 vec = cmd - ZFS_IOC;
2956 ASSERT3U(getmajor(dev), ==, ddi_driver_major(zfs_dip));
2957
2958 if (vec >= sizeof (zfs_ioc_vec) / sizeof (zfs_ioc_vec[0]))
2959 return (EINVAL);
2960
2961 zc = kmem_zalloc(sizeof (zfs_cmd_t), KM_SLEEP);
2962
2963 error = xcopyin((void *)arg, zc, sizeof (zfs_cmd_t));
2964
2965 if (error == 0)
2966 error = zfs_ioc_vec[vec].zvec_secpolicy(zc, cr);
2967
2968 /*
2969 * Ensure that all pool/dataset names are valid before we pass down to
2970 * the lower layers.
2971 */
2972 if (error == 0) {
2973 zc->zc_name[sizeof (zc->zc_name) - 1] = '\0';
2974 switch (zfs_ioc_vec[vec].zvec_namecheck) {
2975 case POOL_NAME:
2976 if (pool_namecheck(zc->zc_name, NULL, NULL) != 0)
2977 error = EINVAL;
2978 break;
2979
2980 case DATASET_NAME:
2981 if (dataset_namecheck(zc->zc_name, NULL, NULL) != 0)
2982 error = EINVAL;
2983 break;
2984
2985 case NO_NAME:
2986 break;
2987 }
2988 }
2989
2990 if (error == 0)
2991 error = zfs_ioc_vec[vec].zvec_func(zc);
2992
2993 rc = xcopyout(zc, (void *)arg, sizeof (zfs_cmd_t));
2994 if (error == 0) {
2995 error = rc;
2996 if (zfs_ioc_vec[vec].zvec_his_log == B_TRUE)
2997 zfs_log_history(zc);
2998 }
2999
3000 kmem_free(zc, sizeof (zfs_cmd_t));
3001 return (error);
3002 }
3003
3004 static int
3005 zfs_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
3006 {
3007 if (cmd != DDI_ATTACH)
3008 return (DDI_FAILURE);
3009
3010 if (ddi_create_minor_node(dip, "zfs", S_IFCHR, 0,
3011 DDI_PSEUDO, 0) == DDI_FAILURE)
3012 return (DDI_FAILURE);
3013
3014 zfs_dip = dip;
3015
3016 ddi_report_dev(dip);
3017
3018 return (DDI_SUCCESS);
3019 }
3020
3021 static int
3022 zfs_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
3023 {
3024 if (spa_busy() || zfs_busy() || zvol_busy())
3025 return (DDI_FAILURE);
3026
3027 if (cmd != DDI_DETACH)
3028 return (DDI_FAILURE);
3029
3030 zfs_dip = NULL;
3031
3032 ddi_prop_remove_all(dip);
3033 ddi_remove_minor_node(dip, NULL);
3034
3035 return (DDI_SUCCESS);
3036 }
3037
3038 /*ARGSUSED*/
3039 static int
3040 zfs_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
3041 {
3042 switch (infocmd) {
3043 case DDI_INFO_DEVT2DEVINFO:
3044 *result = zfs_dip;
3045 return (DDI_SUCCESS);
3046
3047 case DDI_INFO_DEVT2INSTANCE:
3048 *result = (void *)0;
3049 return (DDI_SUCCESS);
3050 }
3051
3052 return (DDI_FAILURE);
3053 }
3054
3055 /*
3056 * OK, so this is a little weird.
3057 *
3058 * /dev/zfs is the control node, i.e. minor 0.
3059 * /dev/zvol/[r]dsk/pool/dataset are the zvols, minor > 0.
3060 *
3061 * /dev/zfs has basically nothing to do except serve up ioctls,
3062 * so most of the standard driver entry points are in zvol.c.
3063 */
3064 static struct cb_ops zfs_cb_ops = {
3065 zvol_open, /* open */
3066 zvol_close, /* close */
3067 zvol_strategy, /* strategy */
3068 nodev, /* print */
3069 zvol_dump, /* dump */
3070 zvol_read, /* read */
3071 zvol_write, /* write */
3072 zfsdev_ioctl, /* ioctl */
3073 nodev, /* devmap */
3074 nodev, /* mmap */
3075 nodev, /* segmap */
3076 nochpoll, /* poll */
3077 ddi_prop_op, /* prop_op */
3078 NULL, /* streamtab */
3079 D_NEW | D_MP | D_64BIT, /* Driver compatibility flag */
3080 CB_REV, /* version */
3081 nodev, /* async read */
3082 nodev, /* async write */
3083 };
3084
3085 static struct dev_ops zfs_dev_ops = {
3086 DEVO_REV, /* version */
3087 0, /* refcnt */
3088 zfs_info, /* info */
3089 nulldev, /* identify */
3090 nulldev, /* probe */
3091 zfs_attach, /* attach */
3092 zfs_detach, /* detach */
3093 nodev, /* reset */
3094 &zfs_cb_ops, /* driver operations */
3095 NULL, /* no bus operations */
3096 NULL, /* power */
3097 ddi_quiesce_not_needed, /* quiesce */
3098 };
3099
3100 static struct modldrv zfs_modldrv = {
3101 &mod_driverops,
3102 "ZFS storage pool",
3103 &zfs_dev_ops
3104 };
3105
3106 static struct modlinkage modlinkage = {
3107 MODREV_1,
3108 (void *)&zfs_modlfs,
3109 (void *)&zfs_modldrv,
3110 NULL
3111 };
3112
3113
3114 uint_t zfs_fsyncer_key;
3115 extern uint_t rrw_tsd_key;
3116
3117 int
3118 _init(void)
3119 {
3120 int error;
3121
3122 spa_init(FREAD | FWRITE);
3123 zfs_init();
3124 zvol_init();
3125
3126 if ((error = mod_install(&modlinkage)) != 0) {
3127 zvol_fini();
3128 zfs_fini();
3129 spa_fini();
3130 return (error);
3131 }
3132
3133 tsd_create(&zfs_fsyncer_key, NULL);
3134 tsd_create(&rrw_tsd_key, NULL);
3135
3136 error = ldi_ident_from_mod(&modlinkage, &zfs_li);
3137 ASSERT(error == 0);
3138 mutex_init(&zfs_share_lock, NULL, MUTEX_DEFAULT, NULL);
3139
3140 return (0);
3141 }
3142
3143 int
3144 _fini(void)
3145 {
3146 int error;
3147
3148 if (spa_busy() || zfs_busy() || zvol_busy() || zio_injection_enabled)
3149 return (EBUSY);
3150
3151 if ((error = mod_remove(&modlinkage)) != 0)
3152 return (error);
3153
3154 zvol_fini();
3155 zfs_fini();
3156 spa_fini();
3157 if (zfs_nfsshare_inited)
3158 (void) ddi_modclose(nfs_mod);
3159 if (zfs_smbshare_inited)
3160 (void) ddi_modclose(smbsrv_mod);
3161 if (zfs_nfsshare_inited || zfs_smbshare_inited)
3162 (void) ddi_modclose(sharefs_mod);
3163
3164 tsd_destroy(&zfs_fsyncer_key);
3165 ldi_ident_release(zfs_li);
3166 zfs_li = NULL;
3167 mutex_destroy(&zfs_share_lock);
3168
3169 return (error);
3170 }
3171
3172 int
3173 _info(struct modinfo *modinfop)
3174 {
3175 return (mod_info(&modlinkage, modinfop));
3176 }
ZFS On Linux mirror for PVE