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