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