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