1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved. 24 * Portions Copyright 2011 Martin Matuska 25 * Copyright 2015, OmniTI Computer Consulting, Inc. All rights reserved. 26 * Portions Copyright 2012 Pawel Jakub Dawidek <pawel@dawidek.net> 27 * Copyright (c) 2014, 2016 Joyent, Inc. All rights reserved. 28 * Copyright 2016 Nexenta Systems, Inc. All rights reserved. 29 * Copyright (c) 2014, Joyent, Inc. All rights reserved. 30 * Copyright (c) 2011, 2020 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 * Copyright (c) 2014 Integros [integros.com] 34 * Copyright 2016 Toomas Soome <tsoome@me.com> 35 * Copyright (c) 2016 Actifio, Inc. All rights reserved. 36 * Copyright (c) 2018, loli10K <ezomori.nozomu@gmail.com>. All rights reserved. 37 * Copyright 2017 RackTop Systems. 38 * Copyright (c) 2017 Open-E, Inc. All Rights Reserved. 39 * Copyright (c) 2019 Datto Inc. 40 * Copyright (c) 2019, 2020 by Christian Schwarz. All rights reserved. 41 * Copyright (c) 2019, 2021, Klara Inc. 42 * Copyright (c) 2019, Allan Jude 43 */ 44 45 /* 46 * ZFS ioctls. 47 * 48 * This file handles the ioctls to /dev/zfs, used for configuring ZFS storage 49 * pools and filesystems, e.g. with /sbin/zfs and /sbin/zpool. 50 * 51 * There are two ways that we handle ioctls: the legacy way where almost 52 * all of the logic is in the ioctl callback, and the new way where most 53 * of the marshalling is handled in the common entry point, zfsdev_ioctl(). 54 * 55 * Non-legacy ioctls should be registered by calling 56 * zfs_ioctl_register() from zfs_ioctl_init(). The ioctl is invoked 57 * from userland by lzc_ioctl(). 58 * 59 * The registration arguments are as follows: 60 * 61 * const char *name 62 * The name of the ioctl. This is used for history logging. If the 63 * ioctl returns successfully (the callback returns 0), and allow_log 64 * is true, then a history log entry will be recorded with the input & 65 * output nvlists. The log entry can be printed with "zpool history -i". 66 * 67 * zfs_ioc_t ioc 68 * The ioctl request number, which userland will pass to ioctl(2). 69 * We want newer versions of libzfs and libzfs_core to run against 70 * existing zfs kernel modules (i.e. a deferred reboot after an update). 71 * Therefore the ioctl numbers cannot change from release to release. 72 * 73 * zfs_secpolicy_func_t *secpolicy 74 * This function will be called before the zfs_ioc_func_t, to 75 * determine if this operation is permitted. It should return EPERM 76 * on failure, and 0 on success. Checks include determining if the 77 * dataset is visible in this zone, and if the user has either all 78 * zfs privileges in the zone (SYS_MOUNT), or has been granted permission 79 * to do this operation on this dataset with "zfs allow". 80 * 81 * zfs_ioc_namecheck_t namecheck 82 * This specifies what to expect in the zfs_cmd_t:zc_name -- a pool 83 * name, a dataset name, or nothing. If the name is not well-formed, 84 * the ioctl will fail and the callback will not be called. 85 * Therefore, the callback can assume that the name is well-formed 86 * (e.g. is null-terminated, doesn't have more than one '@' character, 87 * doesn't have invalid characters). 88 * 89 * zfs_ioc_poolcheck_t pool_check 90 * This specifies requirements on the pool state. If the pool does 91 * not meet them (is suspended or is readonly), the ioctl will fail 92 * and the callback will not be called. If any checks are specified 93 * (i.e. it is not POOL_CHECK_NONE), namecheck must not be NO_NAME. 94 * Multiple checks can be or-ed together (e.g. POOL_CHECK_SUSPENDED | 95 * POOL_CHECK_READONLY). 96 * 97 * zfs_ioc_key_t *nvl_keys 98 * The list of expected/allowable innvl input keys. This list is used 99 * to validate the nvlist input to the ioctl. 100 * 101 * boolean_t smush_outnvlist 102 * If smush_outnvlist is true, then the output is presumed to be a 103 * list of errors, and it will be "smushed" down to fit into the 104 * caller's buffer, by removing some entries and replacing them with a 105 * single "N_MORE_ERRORS" entry indicating how many were removed. See 106 * nvlist_smush() for details. If smush_outnvlist is false, and the 107 * outnvlist does not fit into the userland-provided buffer, then the 108 * ioctl will fail with ENOMEM. 109 * 110 * zfs_ioc_func_t *func 111 * The callback function that will perform the operation. 112 * 113 * The callback should return 0 on success, or an error number on 114 * failure. If the function fails, the userland ioctl will return -1, 115 * and errno will be set to the callback's return value. The callback 116 * will be called with the following arguments: 117 * 118 * const char *name 119 * The name of the pool or dataset to operate on, from 120 * zfs_cmd_t:zc_name. The 'namecheck' argument specifies the 121 * expected type (pool, dataset, or none). 122 * 123 * nvlist_t *innvl 124 * The input nvlist, deserialized from zfs_cmd_t:zc_nvlist_src. Or 125 * NULL if no input nvlist was provided. Changes to this nvlist are 126 * ignored. If the input nvlist could not be deserialized, the 127 * ioctl will fail and the callback will not be called. 128 * 129 * nvlist_t *outnvl 130 * The output nvlist, initially empty. The callback can fill it in, 131 * and it will be returned to userland by serializing it into 132 * zfs_cmd_t:zc_nvlist_dst. If it is non-empty, and serialization 133 * fails (e.g. because the caller didn't supply a large enough 134 * buffer), then the overall ioctl will fail. See the 135 * 'smush_nvlist' argument above for additional behaviors. 136 * 137 * There are two typical uses of the output nvlist: 138 * - To return state, e.g. property values. In this case, 139 * smush_outnvlist should be false. If the buffer was not large 140 * enough, the caller will reallocate a larger buffer and try 141 * the ioctl again. 142 * 143 * - To return multiple errors from an ioctl which makes on-disk 144 * changes. In this case, smush_outnvlist should be true. 145 * Ioctls which make on-disk modifications should generally not 146 * use the outnvl if they succeed, because the caller can not 147 * distinguish between the operation failing, and 148 * deserialization failing. 149 * 150 * IOCTL Interface Errors 151 * 152 * The following ioctl input errors can be returned: 153 * ZFS_ERR_IOC_CMD_UNAVAIL the ioctl number is not supported by kernel 154 * ZFS_ERR_IOC_ARG_UNAVAIL an input argument is not supported by kernel 155 * ZFS_ERR_IOC_ARG_REQUIRED a required input argument is missing 156 * ZFS_ERR_IOC_ARG_BADTYPE an input argument has an invalid type 157 */ 158 159 #include <sys/types.h> 160 #include <sys/param.h> 161 #include <sys/errno.h> 162 #include <sys/uio_impl.h> 163 #include <sys/file.h> 164 #include <sys/kmem.h> 165 #include <sys/cmn_err.h> 166 #include <sys/stat.h> 167 #include <sys/zfs_ioctl.h> 168 #include <sys/zfs_quota.h> 169 #include <sys/zfs_vfsops.h> 170 #include <sys/zfs_znode.h> 171 #include <sys/zap.h> 172 #include <sys/spa.h> 173 #include <sys/spa_impl.h> 174 #include <sys/vdev.h> 175 #include <sys/vdev_impl.h> 176 #include <sys/dmu.h> 177 #include <sys/dsl_dir.h> 178 #include <sys/dsl_dataset.h> 179 #include <sys/dsl_prop.h> 180 #include <sys/dsl_deleg.h> 181 #include <sys/dmu_objset.h> 182 #include <sys/dmu_impl.h> 183 #include <sys/dmu_redact.h> 184 #include <sys/dmu_tx.h> 185 #include <sys/sunddi.h> 186 #include <sys/policy.h> 187 #include <sys/zone.h> 188 #include <sys/nvpair.h> 189 #include <sys/pathname.h> 190 #include <sys/fs/zfs.h> 191 #include <sys/zfs_ctldir.h> 192 #include <sys/zfs_dir.h> 193 #include <sys/zfs_onexit.h> 194 #include <sys/zvol.h> 195 #include <sys/dsl_scan.h> 196 #include <sys/fm/util.h> 197 #include <sys/dsl_crypt.h> 198 #include <sys/rrwlock.h> 199 #include <sys/zfs_file.h> 200 201 #include <sys/dmu_recv.h> 202 #include <sys/dmu_send.h> 203 #include <sys/dmu_recv.h> 204 #include <sys/dsl_destroy.h> 205 #include <sys/dsl_bookmark.h> 206 #include <sys/dsl_userhold.h> 207 #include <sys/zfeature.h> 208 #include <sys/zcp.h> 209 #include <sys/zio_checksum.h> 210 #include <sys/vdev_removal.h> 211 #include <sys/vdev_impl.h> 212 #include <sys/vdev_initialize.h> 213 #include <sys/vdev_trim.h> 214 215 #include "zfs_namecheck.h" 216 #include "zfs_prop.h" 217 #include "zfs_deleg.h" 218 #include "zfs_comutil.h" 219 220 #include <sys/lua/lua.h> 221 #include <sys/lua/lauxlib.h> 222 #include <sys/zfs_ioctl_impl.h> 223 224 kmutex_t zfsdev_state_lock; 225 zfsdev_state_t *zfsdev_state_list; 226 227 /* 228 * Limit maximum nvlist size. We don't want users passing in insane values 229 * for zc->zc_nvlist_src_size, since we will need to allocate that much memory. 230 * Defaults to 0=auto which is handled by platform code. 231 */ 232 unsigned long zfs_max_nvlist_src_size = 0; 233 234 /* 235 * When logging the output nvlist of an ioctl in the on-disk history, limit 236 * the logged size to this many bytes. This must be less than DMU_MAX_ACCESS. 237 * This applies primarily to zfs_ioc_channel_program(). 238 */ 239 unsigned long zfs_history_output_max = 1024 * 1024; 240 241 uint_t zfs_fsyncer_key; 242 uint_t zfs_allow_log_key; 243 244 /* DATA_TYPE_ANY is used when zkey_type can vary. */ 245 #define DATA_TYPE_ANY DATA_TYPE_UNKNOWN 246 247 typedef struct zfs_ioc_vec { 248 zfs_ioc_legacy_func_t *zvec_legacy_func; 249 zfs_ioc_func_t *zvec_func; 250 zfs_secpolicy_func_t *zvec_secpolicy; 251 zfs_ioc_namecheck_t zvec_namecheck; 252 boolean_t zvec_allow_log; 253 zfs_ioc_poolcheck_t zvec_pool_check; 254 boolean_t zvec_smush_outnvlist; 255 const char *zvec_name; 256 const zfs_ioc_key_t *zvec_nvl_keys; 257 size_t zvec_nvl_key_count; 258 } zfs_ioc_vec_t; 259 260 /* This array is indexed by zfs_userquota_prop_t */ 261 static const char *userquota_perms[] = { 262 ZFS_DELEG_PERM_USERUSED, 263 ZFS_DELEG_PERM_USERQUOTA, 264 ZFS_DELEG_PERM_GROUPUSED, 265 ZFS_DELEG_PERM_GROUPQUOTA, 266 ZFS_DELEG_PERM_USEROBJUSED, 267 ZFS_DELEG_PERM_USEROBJQUOTA, 268 ZFS_DELEG_PERM_GROUPOBJUSED, 269 ZFS_DELEG_PERM_GROUPOBJQUOTA, 270 ZFS_DELEG_PERM_PROJECTUSED, 271 ZFS_DELEG_PERM_PROJECTQUOTA, 272 ZFS_DELEG_PERM_PROJECTOBJUSED, 273 ZFS_DELEG_PERM_PROJECTOBJQUOTA, 274 }; 275 276 static int zfs_ioc_userspace_upgrade(zfs_cmd_t *zc); 277 static int zfs_ioc_id_quota_upgrade(zfs_cmd_t *zc); 278 static int zfs_check_settable(const char *name, nvpair_t *property, 279 cred_t *cr); 280 static int zfs_check_clearable(const char *dataset, nvlist_t *props, 281 nvlist_t **errors); 282 static int zfs_fill_zplprops_root(uint64_t, nvlist_t *, nvlist_t *, 283 boolean_t *); 284 int zfs_set_prop_nvlist(const char *, zprop_source_t, nvlist_t *, nvlist_t *); 285 static int get_nvlist(uint64_t nvl, uint64_t size, int iflag, nvlist_t **nvp); 286 287 static void 288 history_str_free(char *buf) 289 { 290 kmem_free(buf, HIS_MAX_RECORD_LEN); 291 } 292 293 static char * 294 history_str_get(zfs_cmd_t *zc) 295 { 296 char *buf; 297 298 if (zc->zc_history == 0) 299 return (NULL); 300 301 buf = kmem_alloc(HIS_MAX_RECORD_LEN, KM_SLEEP); 302 if (copyinstr((void *)(uintptr_t)zc->zc_history, 303 buf, HIS_MAX_RECORD_LEN, NULL) != 0) { 304 history_str_free(buf); 305 return (NULL); 306 } 307 308 buf[HIS_MAX_RECORD_LEN -1] = '\0'; 309 310 return (buf); 311 } 312 313 /* 314 * Return non-zero if the spa version is less than requested version. 315 */ 316 static int 317 zfs_earlier_version(const char *name, int version) 318 { 319 spa_t *spa; 320 321 if (spa_open(name, &spa, FTAG) == 0) { 322 if (spa_version(spa) < version) { 323 spa_close(spa, FTAG); 324 return (1); 325 } 326 spa_close(spa, FTAG); 327 } 328 return (0); 329 } 330 331 /* 332 * Return TRUE if the ZPL version is less than requested version. 333 */ 334 static boolean_t 335 zpl_earlier_version(const char *name, int version) 336 { 337 objset_t *os; 338 boolean_t rc = B_TRUE; 339 340 if (dmu_objset_hold(name, FTAG, &os) == 0) { 341 uint64_t zplversion; 342 343 if (dmu_objset_type(os) != DMU_OST_ZFS) { 344 dmu_objset_rele(os, FTAG); 345 return (B_TRUE); 346 } 347 /* XXX reading from non-owned objset */ 348 if (zfs_get_zplprop(os, ZFS_PROP_VERSION, &zplversion) == 0) 349 rc = zplversion < version; 350 dmu_objset_rele(os, FTAG); 351 } 352 return (rc); 353 } 354 355 static void 356 zfs_log_history(zfs_cmd_t *zc) 357 { 358 spa_t *spa; 359 char *buf; 360 361 if ((buf = history_str_get(zc)) == NULL) 362 return; 363 364 if (spa_open(zc->zc_name, &spa, FTAG) == 0) { 365 if (spa_version(spa) >= SPA_VERSION_ZPOOL_HISTORY) 366 (void) spa_history_log(spa, buf); 367 spa_close(spa, FTAG); 368 } 369 history_str_free(buf); 370 } 371 372 /* 373 * Policy for top-level read operations (list pools). Requires no privileges, 374 * and can be used in the local zone, as there is no associated dataset. 375 */ 376 /* ARGSUSED */ 377 static int 378 zfs_secpolicy_none(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr) 379 { 380 return (0); 381 } 382 383 /* 384 * Policy for dataset read operations (list children, get statistics). Requires 385 * no privileges, but must be visible in the local zone. 386 */ 387 /* ARGSUSED */ 388 static int 389 zfs_secpolicy_read(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr) 390 { 391 if (INGLOBALZONE(curproc) || 392 zone_dataset_visible(zc->zc_name, NULL)) 393 return (0); 394 395 return (SET_ERROR(ENOENT)); 396 } 397 398 static int 399 zfs_dozonecheck_impl(const char *dataset, uint64_t zoned, cred_t *cr) 400 { 401 int writable = 1; 402 403 /* 404 * The dataset must be visible by this zone -- check this first 405 * so they don't see EPERM on something they shouldn't know about. 406 */ 407 if (!INGLOBALZONE(curproc) && 408 !zone_dataset_visible(dataset, &writable)) 409 return (SET_ERROR(ENOENT)); 410 411 if (INGLOBALZONE(curproc)) { 412 /* 413 * If the fs is zoned, only root can access it from the 414 * global zone. 415 */ 416 if (secpolicy_zfs(cr) && zoned) 417 return (SET_ERROR(EPERM)); 418 } else { 419 /* 420 * If we are in a local zone, the 'zoned' property must be set. 421 */ 422 if (!zoned) 423 return (SET_ERROR(EPERM)); 424 425 /* must be writable by this zone */ 426 if (!writable) 427 return (SET_ERROR(EPERM)); 428 } 429 return (0); 430 } 431 432 static int 433 zfs_dozonecheck(const char *dataset, cred_t *cr) 434 { 435 uint64_t zoned; 436 437 if (dsl_prop_get_integer(dataset, zfs_prop_to_name(ZFS_PROP_ZONED), 438 &zoned, NULL)) 439 return (SET_ERROR(ENOENT)); 440 441 return (zfs_dozonecheck_impl(dataset, zoned, cr)); 442 } 443 444 static int 445 zfs_dozonecheck_ds(const char *dataset, dsl_dataset_t *ds, cred_t *cr) 446 { 447 uint64_t zoned; 448 449 if (dsl_prop_get_int_ds(ds, zfs_prop_to_name(ZFS_PROP_ZONED), &zoned)) 450 return (SET_ERROR(ENOENT)); 451 452 return (zfs_dozonecheck_impl(dataset, zoned, cr)); 453 } 454 455 static int 456 zfs_secpolicy_write_perms_ds(const char *name, dsl_dataset_t *ds, 457 const char *perm, cred_t *cr) 458 { 459 int error; 460 461 error = zfs_dozonecheck_ds(name, ds, cr); 462 if (error == 0) { 463 error = secpolicy_zfs(cr); 464 if (error != 0) 465 error = dsl_deleg_access_impl(ds, perm, cr); 466 } 467 return (error); 468 } 469 470 static int 471 zfs_secpolicy_write_perms(const char *name, const char *perm, cred_t *cr) 472 { 473 int error; 474 dsl_dataset_t *ds; 475 dsl_pool_t *dp; 476 477 /* 478 * First do a quick check for root in the global zone, which 479 * is allowed to do all write_perms. This ensures that zfs_ioc_* 480 * will get to handle nonexistent datasets. 481 */ 482 if (INGLOBALZONE(curproc) && secpolicy_zfs(cr) == 0) 483 return (0); 484 485 error = dsl_pool_hold(name, FTAG, &dp); 486 if (error != 0) 487 return (error); 488 489 error = dsl_dataset_hold(dp, name, FTAG, &ds); 490 if (error != 0) { 491 dsl_pool_rele(dp, FTAG); 492 return (error); 493 } 494 495 error = zfs_secpolicy_write_perms_ds(name, ds, perm, cr); 496 497 dsl_dataset_rele(ds, FTAG); 498 dsl_pool_rele(dp, FTAG); 499 return (error); 500 } 501 502 /* 503 * Policy for setting the security label property. 504 * 505 * Returns 0 for success, non-zero for access and other errors. 506 */ 507 static int 508 zfs_set_slabel_policy(const char *name, const char *strval, cred_t *cr) 509 { 510 #ifdef HAVE_MLSLABEL 511 char ds_hexsl[MAXNAMELEN]; 512 bslabel_t ds_sl, new_sl; 513 boolean_t new_default = FALSE; 514 uint64_t zoned; 515 int needed_priv = -1; 516 int error; 517 518 /* First get the existing dataset label. */ 519 error = dsl_prop_get(name, zfs_prop_to_name(ZFS_PROP_MLSLABEL), 520 1, sizeof (ds_hexsl), &ds_hexsl, NULL); 521 if (error != 0) 522 return (SET_ERROR(EPERM)); 523 524 if (strcasecmp(strval, ZFS_MLSLABEL_DEFAULT) == 0) 525 new_default = TRUE; 526 527 /* The label must be translatable */ 528 if (!new_default && (hexstr_to_label(strval, &new_sl) != 0)) 529 return (SET_ERROR(EINVAL)); 530 531 /* 532 * In a non-global zone, disallow attempts to set a label that 533 * doesn't match that of the zone; otherwise no other checks 534 * are needed. 535 */ 536 if (!INGLOBALZONE(curproc)) { 537 if (new_default || !blequal(&new_sl, CR_SL(CRED()))) 538 return (SET_ERROR(EPERM)); 539 return (0); 540 } 541 542 /* 543 * For global-zone datasets (i.e., those whose zoned property is 544 * "off", verify that the specified new label is valid for the 545 * global zone. 546 */ 547 if (dsl_prop_get_integer(name, 548 zfs_prop_to_name(ZFS_PROP_ZONED), &zoned, NULL)) 549 return (SET_ERROR(EPERM)); 550 if (!zoned) { 551 if (zfs_check_global_label(name, strval) != 0) 552 return (SET_ERROR(EPERM)); 553 } 554 555 /* 556 * If the existing dataset label is nondefault, check if the 557 * dataset is mounted (label cannot be changed while mounted). 558 * Get the zfsvfs_t; if there isn't one, then the dataset isn't 559 * mounted (or isn't a dataset, doesn't exist, ...). 560 */ 561 if (strcasecmp(ds_hexsl, ZFS_MLSLABEL_DEFAULT) != 0) { 562 objset_t *os; 563 static const char *setsl_tag = "setsl_tag"; 564 565 /* 566 * Try to own the dataset; abort if there is any error, 567 * (e.g., already mounted, in use, or other error). 568 */ 569 error = dmu_objset_own(name, DMU_OST_ZFS, B_TRUE, B_TRUE, 570 setsl_tag, &os); 571 if (error != 0) 572 return (SET_ERROR(EPERM)); 573 574 dmu_objset_disown(os, B_TRUE, setsl_tag); 575 576 if (new_default) { 577 needed_priv = PRIV_FILE_DOWNGRADE_SL; 578 goto out_check; 579 } 580 581 if (hexstr_to_label(strval, &new_sl) != 0) 582 return (SET_ERROR(EPERM)); 583 584 if (blstrictdom(&ds_sl, &new_sl)) 585 needed_priv = PRIV_FILE_DOWNGRADE_SL; 586 else if (blstrictdom(&new_sl, &ds_sl)) 587 needed_priv = PRIV_FILE_UPGRADE_SL; 588 } else { 589 /* dataset currently has a default label */ 590 if (!new_default) 591 needed_priv = PRIV_FILE_UPGRADE_SL; 592 } 593 594 out_check: 595 if (needed_priv != -1) 596 return (PRIV_POLICY(cr, needed_priv, B_FALSE, EPERM, NULL)); 597 return (0); 598 #else 599 return (SET_ERROR(ENOTSUP)); 600 #endif /* HAVE_MLSLABEL */ 601 } 602 603 static int 604 zfs_secpolicy_setprop(const char *dsname, zfs_prop_t prop, nvpair_t *propval, 605 cred_t *cr) 606 { 607 char *strval; 608 609 /* 610 * Check permissions for special properties. 611 */ 612 switch (prop) { 613 default: 614 break; 615 case ZFS_PROP_ZONED: 616 /* 617 * Disallow setting of 'zoned' from within a local zone. 618 */ 619 if (!INGLOBALZONE(curproc)) 620 return (SET_ERROR(EPERM)); 621 break; 622 623 case ZFS_PROP_QUOTA: 624 case ZFS_PROP_FILESYSTEM_LIMIT: 625 case ZFS_PROP_SNAPSHOT_LIMIT: 626 if (!INGLOBALZONE(curproc)) { 627 uint64_t zoned; 628 char setpoint[ZFS_MAX_DATASET_NAME_LEN]; 629 /* 630 * Unprivileged users are allowed to modify the 631 * limit on things *under* (ie. contained by) 632 * the thing they own. 633 */ 634 if (dsl_prop_get_integer(dsname, 635 zfs_prop_to_name(ZFS_PROP_ZONED), &zoned, setpoint)) 636 return (SET_ERROR(EPERM)); 637 if (!zoned || strlen(dsname) <= strlen(setpoint)) 638 return (SET_ERROR(EPERM)); 639 } 640 break; 641 642 case ZFS_PROP_MLSLABEL: 643 if (!is_system_labeled()) 644 return (SET_ERROR(EPERM)); 645 646 if (nvpair_value_string(propval, &strval) == 0) { 647 int err; 648 649 err = zfs_set_slabel_policy(dsname, strval, CRED()); 650 if (err != 0) 651 return (err); 652 } 653 break; 654 } 655 656 return (zfs_secpolicy_write_perms(dsname, zfs_prop_to_name(prop), cr)); 657 } 658 659 /* ARGSUSED */ 660 static int 661 zfs_secpolicy_set_fsacl(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr) 662 { 663 int error; 664 665 error = zfs_dozonecheck(zc->zc_name, cr); 666 if (error != 0) 667 return (error); 668 669 /* 670 * permission to set permissions will be evaluated later in 671 * dsl_deleg_can_allow() 672 */ 673 return (0); 674 } 675 676 /* ARGSUSED */ 677 static int 678 zfs_secpolicy_rollback(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr) 679 { 680 return (zfs_secpolicy_write_perms(zc->zc_name, 681 ZFS_DELEG_PERM_ROLLBACK, cr)); 682 } 683 684 /* ARGSUSED */ 685 static int 686 zfs_secpolicy_send(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr) 687 { 688 dsl_pool_t *dp; 689 dsl_dataset_t *ds; 690 const char *cp; 691 int error; 692 693 /* 694 * Generate the current snapshot name from the given objsetid, then 695 * use that name for the secpolicy/zone checks. 696 */ 697 cp = strchr(zc->zc_name, '@'); 698 if (cp == NULL) 699 return (SET_ERROR(EINVAL)); 700 error = dsl_pool_hold(zc->zc_name, FTAG, &dp); 701 if (error != 0) 702 return (error); 703 704 error = dsl_dataset_hold_obj(dp, zc->zc_sendobj, FTAG, &ds); 705 if (error != 0) { 706 dsl_pool_rele(dp, FTAG); 707 return (error); 708 } 709 710 dsl_dataset_name(ds, zc->zc_name); 711 712 error = zfs_secpolicy_write_perms_ds(zc->zc_name, ds, 713 ZFS_DELEG_PERM_SEND, cr); 714 dsl_dataset_rele(ds, FTAG); 715 dsl_pool_rele(dp, FTAG); 716 717 return (error); 718 } 719 720 /* ARGSUSED */ 721 static int 722 zfs_secpolicy_send_new(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr) 723 { 724 return (zfs_secpolicy_write_perms(zc->zc_name, 725 ZFS_DELEG_PERM_SEND, cr)); 726 } 727 728 static int 729 zfs_secpolicy_share(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr) 730 { 731 return (SET_ERROR(ENOTSUP)); 732 } 733 734 static int 735 zfs_secpolicy_smb_acl(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr) 736 { 737 return (SET_ERROR(ENOTSUP)); 738 } 739 740 static int 741 zfs_get_parent(const char *datasetname, char *parent, int parentsize) 742 { 743 char *cp; 744 745 /* 746 * Remove the @bla or /bla from the end of the name to get the parent. 747 */ 748 (void) strncpy(parent, datasetname, parentsize); 749 cp = strrchr(parent, '@'); 750 if (cp != NULL) { 751 cp[0] = '\0'; 752 } else { 753 cp = strrchr(parent, '/'); 754 if (cp == NULL) 755 return (SET_ERROR(ENOENT)); 756 cp[0] = '\0'; 757 } 758 759 return (0); 760 } 761 762 int 763 zfs_secpolicy_destroy_perms(const char *name, cred_t *cr) 764 { 765 int error; 766 767 if ((error = zfs_secpolicy_write_perms(name, 768 ZFS_DELEG_PERM_MOUNT, cr)) != 0) 769 return (error); 770 771 return (zfs_secpolicy_write_perms(name, ZFS_DELEG_PERM_DESTROY, cr)); 772 } 773 774 /* ARGSUSED */ 775 static int 776 zfs_secpolicy_destroy(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr) 777 { 778 return (zfs_secpolicy_destroy_perms(zc->zc_name, cr)); 779 } 780 781 /* 782 * Destroying snapshots with delegated permissions requires 783 * descendant mount and destroy permissions. 784 */ 785 /* ARGSUSED */ 786 static int 787 zfs_secpolicy_destroy_snaps(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr) 788 { 789 nvlist_t *snaps; 790 nvpair_t *pair, *nextpair; 791 int error = 0; 792 793 snaps = fnvlist_lookup_nvlist(innvl, "snaps"); 794 795 for (pair = nvlist_next_nvpair(snaps, NULL); pair != NULL; 796 pair = nextpair) { 797 nextpair = nvlist_next_nvpair(snaps, pair); 798 error = zfs_secpolicy_destroy_perms(nvpair_name(pair), cr); 799 if (error == ENOENT) { 800 /* 801 * Ignore any snapshots that don't exist (we consider 802 * them "already destroyed"). Remove the name from the 803 * nvl here in case the snapshot is created between 804 * now and when we try to destroy it (in which case 805 * we don't want to destroy it since we haven't 806 * checked for permission). 807 */ 808 fnvlist_remove_nvpair(snaps, pair); 809 error = 0; 810 } 811 if (error != 0) 812 break; 813 } 814 815 return (error); 816 } 817 818 int 819 zfs_secpolicy_rename_perms(const char *from, const char *to, cred_t *cr) 820 { 821 char parentname[ZFS_MAX_DATASET_NAME_LEN]; 822 int error; 823 824 if ((error = zfs_secpolicy_write_perms(from, 825 ZFS_DELEG_PERM_RENAME, cr)) != 0) 826 return (error); 827 828 if ((error = zfs_secpolicy_write_perms(from, 829 ZFS_DELEG_PERM_MOUNT, cr)) != 0) 830 return (error); 831 832 if ((error = zfs_get_parent(to, parentname, 833 sizeof (parentname))) != 0) 834 return (error); 835 836 if ((error = zfs_secpolicy_write_perms(parentname, 837 ZFS_DELEG_PERM_CREATE, cr)) != 0) 838 return (error); 839 840 if ((error = zfs_secpolicy_write_perms(parentname, 841 ZFS_DELEG_PERM_MOUNT, cr)) != 0) 842 return (error); 843 844 return (error); 845 } 846 847 /* ARGSUSED */ 848 static int 849 zfs_secpolicy_rename(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr) 850 { 851 return (zfs_secpolicy_rename_perms(zc->zc_name, zc->zc_value, cr)); 852 } 853 854 /* ARGSUSED */ 855 static int 856 zfs_secpolicy_promote(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr) 857 { 858 dsl_pool_t *dp; 859 dsl_dataset_t *clone; 860 int error; 861 862 error = zfs_secpolicy_write_perms(zc->zc_name, 863 ZFS_DELEG_PERM_PROMOTE, cr); 864 if (error != 0) 865 return (error); 866 867 error = dsl_pool_hold(zc->zc_name, FTAG, &dp); 868 if (error != 0) 869 return (error); 870 871 error = dsl_dataset_hold(dp, zc->zc_name, FTAG, &clone); 872 873 if (error == 0) { 874 char parentname[ZFS_MAX_DATASET_NAME_LEN]; 875 dsl_dataset_t *origin = NULL; 876 dsl_dir_t *dd; 877 dd = clone->ds_dir; 878 879 error = dsl_dataset_hold_obj(dd->dd_pool, 880 dsl_dir_phys(dd)->dd_origin_obj, FTAG, &origin); 881 if (error != 0) { 882 dsl_dataset_rele(clone, FTAG); 883 dsl_pool_rele(dp, FTAG); 884 return (error); 885 } 886 887 error = zfs_secpolicy_write_perms_ds(zc->zc_name, clone, 888 ZFS_DELEG_PERM_MOUNT, cr); 889 890 dsl_dataset_name(origin, parentname); 891 if (error == 0) { 892 error = zfs_secpolicy_write_perms_ds(parentname, origin, 893 ZFS_DELEG_PERM_PROMOTE, cr); 894 } 895 dsl_dataset_rele(clone, FTAG); 896 dsl_dataset_rele(origin, FTAG); 897 } 898 dsl_pool_rele(dp, FTAG); 899 return (error); 900 } 901 902 /* ARGSUSED */ 903 static int 904 zfs_secpolicy_recv(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr) 905 { 906 int error; 907 908 if ((error = zfs_secpolicy_write_perms(zc->zc_name, 909 ZFS_DELEG_PERM_RECEIVE, cr)) != 0) 910 return (error); 911 912 if ((error = zfs_secpolicy_write_perms(zc->zc_name, 913 ZFS_DELEG_PERM_MOUNT, cr)) != 0) 914 return (error); 915 916 return (zfs_secpolicy_write_perms(zc->zc_name, 917 ZFS_DELEG_PERM_CREATE, cr)); 918 } 919 920 /* ARGSUSED */ 921 static int 922 zfs_secpolicy_recv_new(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr) 923 { 924 return (zfs_secpolicy_recv(zc, innvl, cr)); 925 } 926 927 int 928 zfs_secpolicy_snapshot_perms(const char *name, cred_t *cr) 929 { 930 return (zfs_secpolicy_write_perms(name, 931 ZFS_DELEG_PERM_SNAPSHOT, cr)); 932 } 933 934 /* 935 * Check for permission to create each snapshot in the nvlist. 936 */ 937 /* ARGSUSED */ 938 static int 939 zfs_secpolicy_snapshot(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr) 940 { 941 nvlist_t *snaps; 942 int error = 0; 943 nvpair_t *pair; 944 945 snaps = fnvlist_lookup_nvlist(innvl, "snaps"); 946 947 for (pair = nvlist_next_nvpair(snaps, NULL); pair != NULL; 948 pair = nvlist_next_nvpair(snaps, pair)) { 949 char *name = nvpair_name(pair); 950 char *atp = strchr(name, '@'); 951 952 if (atp == NULL) { 953 error = SET_ERROR(EINVAL); 954 break; 955 } 956 *atp = '\0'; 957 error = zfs_secpolicy_snapshot_perms(name, cr); 958 *atp = '@'; 959 if (error != 0) 960 break; 961 } 962 return (error); 963 } 964 965 /* 966 * Check for permission to create each bookmark in the nvlist. 967 */ 968 /* ARGSUSED */ 969 static int 970 zfs_secpolicy_bookmark(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr) 971 { 972 int error = 0; 973 974 for (nvpair_t *pair = nvlist_next_nvpair(innvl, NULL); 975 pair != NULL; pair = nvlist_next_nvpair(innvl, pair)) { 976 char *name = nvpair_name(pair); 977 char *hashp = strchr(name, '#'); 978 979 if (hashp == NULL) { 980 error = SET_ERROR(EINVAL); 981 break; 982 } 983 *hashp = '\0'; 984 error = zfs_secpolicy_write_perms(name, 985 ZFS_DELEG_PERM_BOOKMARK, cr); 986 *hashp = '#'; 987 if (error != 0) 988 break; 989 } 990 return (error); 991 } 992 993 /* ARGSUSED */ 994 static int 995 zfs_secpolicy_destroy_bookmarks(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr) 996 { 997 nvpair_t *pair, *nextpair; 998 int error = 0; 999 1000 for (pair = nvlist_next_nvpair(innvl, NULL); pair != NULL; 1001 pair = nextpair) { 1002 char *name = nvpair_name(pair); 1003 char *hashp = strchr(name, '#'); 1004 nextpair = nvlist_next_nvpair(innvl, pair); 1005 1006 if (hashp == NULL) { 1007 error = SET_ERROR(EINVAL); 1008 break; 1009 } 1010 1011 *hashp = '\0'; 1012 error = zfs_secpolicy_write_perms(name, 1013 ZFS_DELEG_PERM_DESTROY, cr); 1014 *hashp = '#'; 1015 if (error == ENOENT) { 1016 /* 1017 * Ignore any filesystems that don't exist (we consider 1018 * their bookmarks "already destroyed"). Remove 1019 * the name from the nvl here in case the filesystem 1020 * is created between now and when we try to destroy 1021 * the bookmark (in which case we don't want to 1022 * destroy it since we haven't checked for permission). 1023 */ 1024 fnvlist_remove_nvpair(innvl, pair); 1025 error = 0; 1026 } 1027 if (error != 0) 1028 break; 1029 } 1030 1031 return (error); 1032 } 1033 1034 /* ARGSUSED */ 1035 static int 1036 zfs_secpolicy_log_history(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr) 1037 { 1038 /* 1039 * Even root must have a proper TSD so that we know what pool 1040 * to log to. 1041 */ 1042 if (tsd_get(zfs_allow_log_key) == NULL) 1043 return (SET_ERROR(EPERM)); 1044 return (0); 1045 } 1046 1047 static int 1048 zfs_secpolicy_create_clone(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr) 1049 { 1050 char parentname[ZFS_MAX_DATASET_NAME_LEN]; 1051 int error; 1052 char *origin; 1053 1054 if ((error = zfs_get_parent(zc->zc_name, parentname, 1055 sizeof (parentname))) != 0) 1056 return (error); 1057 1058 if (nvlist_lookup_string(innvl, "origin", &origin) == 0 && 1059 (error = zfs_secpolicy_write_perms(origin, 1060 ZFS_DELEG_PERM_CLONE, cr)) != 0) 1061 return (error); 1062 1063 if ((error = zfs_secpolicy_write_perms(parentname, 1064 ZFS_DELEG_PERM_CREATE, cr)) != 0) 1065 return (error); 1066 1067 return (zfs_secpolicy_write_perms(parentname, 1068 ZFS_DELEG_PERM_MOUNT, cr)); 1069 } 1070 1071 /* 1072 * Policy for pool operations - create/destroy pools, add vdevs, etc. Requires 1073 * SYS_CONFIG privilege, which is not available in a local zone. 1074 */ 1075 /* ARGSUSED */ 1076 int 1077 zfs_secpolicy_config(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr) 1078 { 1079 if (secpolicy_sys_config(cr, B_FALSE) != 0) 1080 return (SET_ERROR(EPERM)); 1081 1082 return (0); 1083 } 1084 1085 /* 1086 * Policy for object to name lookups. 1087 */ 1088 /* ARGSUSED */ 1089 static int 1090 zfs_secpolicy_diff(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr) 1091 { 1092 int error; 1093 1094 if ((error = secpolicy_sys_config(cr, B_FALSE)) == 0) 1095 return (0); 1096 1097 error = zfs_secpolicy_write_perms(zc->zc_name, ZFS_DELEG_PERM_DIFF, cr); 1098 return (error); 1099 } 1100 1101 /* 1102 * Policy for fault injection. Requires all privileges. 1103 */ 1104 /* ARGSUSED */ 1105 static int 1106 zfs_secpolicy_inject(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr) 1107 { 1108 return (secpolicy_zinject(cr)); 1109 } 1110 1111 /* ARGSUSED */ 1112 static int 1113 zfs_secpolicy_inherit_prop(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr) 1114 { 1115 zfs_prop_t prop = zfs_name_to_prop(zc->zc_value); 1116 1117 if (prop == ZPROP_INVAL) { 1118 if (!zfs_prop_user(zc->zc_value)) 1119 return (SET_ERROR(EINVAL)); 1120 return (zfs_secpolicy_write_perms(zc->zc_name, 1121 ZFS_DELEG_PERM_USERPROP, cr)); 1122 } else { 1123 return (zfs_secpolicy_setprop(zc->zc_name, prop, 1124 NULL, cr)); 1125 } 1126 } 1127 1128 static int 1129 zfs_secpolicy_userspace_one(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr) 1130 { 1131 int err = zfs_secpolicy_read(zc, innvl, cr); 1132 if (err) 1133 return (err); 1134 1135 if (zc->zc_objset_type >= ZFS_NUM_USERQUOTA_PROPS) 1136 return (SET_ERROR(EINVAL)); 1137 1138 if (zc->zc_value[0] == 0) { 1139 /* 1140 * They are asking about a posix uid/gid. If it's 1141 * themself, allow it. 1142 */ 1143 if (zc->zc_objset_type == ZFS_PROP_USERUSED || 1144 zc->zc_objset_type == ZFS_PROP_USERQUOTA || 1145 zc->zc_objset_type == ZFS_PROP_USEROBJUSED || 1146 zc->zc_objset_type == ZFS_PROP_USEROBJQUOTA) { 1147 if (zc->zc_guid == crgetuid(cr)) 1148 return (0); 1149 } else if (zc->zc_objset_type == ZFS_PROP_GROUPUSED || 1150 zc->zc_objset_type == ZFS_PROP_GROUPQUOTA || 1151 zc->zc_objset_type == ZFS_PROP_GROUPOBJUSED || 1152 zc->zc_objset_type == ZFS_PROP_GROUPOBJQUOTA) { 1153 if (groupmember(zc->zc_guid, cr)) 1154 return (0); 1155 } 1156 /* else is for project quota/used */ 1157 } 1158 1159 return (zfs_secpolicy_write_perms(zc->zc_name, 1160 userquota_perms[zc->zc_objset_type], cr)); 1161 } 1162 1163 static int 1164 zfs_secpolicy_userspace_many(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr) 1165 { 1166 int err = zfs_secpolicy_read(zc, innvl, cr); 1167 if (err) 1168 return (err); 1169 1170 if (zc->zc_objset_type >= ZFS_NUM_USERQUOTA_PROPS) 1171 return (SET_ERROR(EINVAL)); 1172 1173 return (zfs_secpolicy_write_perms(zc->zc_name, 1174 userquota_perms[zc->zc_objset_type], cr)); 1175 } 1176 1177 /* ARGSUSED */ 1178 static int 1179 zfs_secpolicy_userspace_upgrade(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr) 1180 { 1181 return (zfs_secpolicy_setprop(zc->zc_name, ZFS_PROP_VERSION, 1182 NULL, cr)); 1183 } 1184 1185 /* ARGSUSED */ 1186 static int 1187 zfs_secpolicy_hold(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr) 1188 { 1189 nvpair_t *pair; 1190 nvlist_t *holds; 1191 int error; 1192 1193 holds = fnvlist_lookup_nvlist(innvl, "holds"); 1194 1195 for (pair = nvlist_next_nvpair(holds, NULL); pair != NULL; 1196 pair = nvlist_next_nvpair(holds, pair)) { 1197 char fsname[ZFS_MAX_DATASET_NAME_LEN]; 1198 error = dmu_fsname(nvpair_name(pair), fsname); 1199 if (error != 0) 1200 return (error); 1201 error = zfs_secpolicy_write_perms(fsname, 1202 ZFS_DELEG_PERM_HOLD, cr); 1203 if (error != 0) 1204 return (error); 1205 } 1206 return (0); 1207 } 1208 1209 /* ARGSUSED */ 1210 static int 1211 zfs_secpolicy_release(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr) 1212 { 1213 nvpair_t *pair; 1214 int error; 1215 1216 for (pair = nvlist_next_nvpair(innvl, NULL); pair != NULL; 1217 pair = nvlist_next_nvpair(innvl, pair)) { 1218 char fsname[ZFS_MAX_DATASET_NAME_LEN]; 1219 error = dmu_fsname(nvpair_name(pair), fsname); 1220 if (error != 0) 1221 return (error); 1222 error = zfs_secpolicy_write_perms(fsname, 1223 ZFS_DELEG_PERM_RELEASE, cr); 1224 if (error != 0) 1225 return (error); 1226 } 1227 return (0); 1228 } 1229 1230 /* 1231 * Policy for allowing temporary snapshots to be taken or released 1232 */ 1233 static int 1234 zfs_secpolicy_tmp_snapshot(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr) 1235 { 1236 /* 1237 * A temporary snapshot is the same as a snapshot, 1238 * hold, destroy and release all rolled into one. 1239 * Delegated diff alone is sufficient that we allow this. 1240 */ 1241 int error; 1242 1243 if ((error = zfs_secpolicy_write_perms(zc->zc_name, 1244 ZFS_DELEG_PERM_DIFF, cr)) == 0) 1245 return (0); 1246 1247 error = zfs_secpolicy_snapshot_perms(zc->zc_name, cr); 1248 1249 if (innvl != NULL) { 1250 if (error == 0) 1251 error = zfs_secpolicy_hold(zc, innvl, cr); 1252 if (error == 0) 1253 error = zfs_secpolicy_release(zc, innvl, cr); 1254 if (error == 0) 1255 error = zfs_secpolicy_destroy(zc, innvl, cr); 1256 } 1257 return (error); 1258 } 1259 1260 static int 1261 zfs_secpolicy_load_key(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr) 1262 { 1263 return (zfs_secpolicy_write_perms(zc->zc_name, 1264 ZFS_DELEG_PERM_LOAD_KEY, cr)); 1265 } 1266 1267 static int 1268 zfs_secpolicy_change_key(zfs_cmd_t *zc, nvlist_t *innvl, cred_t *cr) 1269 { 1270 return (zfs_secpolicy_write_perms(zc->zc_name, 1271 ZFS_DELEG_PERM_CHANGE_KEY, cr)); 1272 } 1273 1274 /* 1275 * Returns the nvlist as specified by the user in the zfs_cmd_t. 1276 */ 1277 static int 1278 get_nvlist(uint64_t nvl, uint64_t size, int iflag, nvlist_t **nvp) 1279 { 1280 char *packed; 1281 int error; 1282 nvlist_t *list = NULL; 1283 1284 /* 1285 * Read in and unpack the user-supplied nvlist. 1286 */ 1287 if (size == 0) 1288 return (SET_ERROR(EINVAL)); 1289 1290 packed = vmem_alloc(size, KM_SLEEP); 1291 1292 if ((error = ddi_copyin((void *)(uintptr_t)nvl, packed, size, 1293 iflag)) != 0) { 1294 vmem_free(packed, size); 1295 return (SET_ERROR(EFAULT)); 1296 } 1297 1298 if ((error = nvlist_unpack(packed, size, &list, 0)) != 0) { 1299 vmem_free(packed, size); 1300 return (error); 1301 } 1302 1303 vmem_free(packed, size); 1304 1305 *nvp = list; 1306 return (0); 1307 } 1308 1309 /* 1310 * Reduce the size of this nvlist until it can be serialized in 'max' bytes. 1311 * Entries will be removed from the end of the nvlist, and one int32 entry 1312 * named "N_MORE_ERRORS" will be added indicating how many entries were 1313 * removed. 1314 */ 1315 static int 1316 nvlist_smush(nvlist_t *errors, size_t max) 1317 { 1318 size_t size; 1319 1320 size = fnvlist_size(errors); 1321 1322 if (size > max) { 1323 nvpair_t *more_errors; 1324 int n = 0; 1325 1326 if (max < 1024) 1327 return (SET_ERROR(ENOMEM)); 1328 1329 fnvlist_add_int32(errors, ZPROP_N_MORE_ERRORS, 0); 1330 more_errors = nvlist_prev_nvpair(errors, NULL); 1331 1332 do { 1333 nvpair_t *pair = nvlist_prev_nvpair(errors, 1334 more_errors); 1335 fnvlist_remove_nvpair(errors, pair); 1336 n++; 1337 size = fnvlist_size(errors); 1338 } while (size > max); 1339 1340 fnvlist_remove_nvpair(errors, more_errors); 1341 fnvlist_add_int32(errors, ZPROP_N_MORE_ERRORS, n); 1342 ASSERT3U(fnvlist_size(errors), <=, max); 1343 } 1344 1345 return (0); 1346 } 1347 1348 static int 1349 put_nvlist(zfs_cmd_t *zc, nvlist_t *nvl) 1350 { 1351 char *packed = NULL; 1352 int error = 0; 1353 size_t size; 1354 1355 size = fnvlist_size(nvl); 1356 1357 if (size > zc->zc_nvlist_dst_size) { 1358 error = SET_ERROR(ENOMEM); 1359 } else { 1360 packed = fnvlist_pack(nvl, &size); 1361 if (ddi_copyout(packed, (void *)(uintptr_t)zc->zc_nvlist_dst, 1362 size, zc->zc_iflags) != 0) 1363 error = SET_ERROR(EFAULT); 1364 fnvlist_pack_free(packed, size); 1365 } 1366 1367 zc->zc_nvlist_dst_size = size; 1368 zc->zc_nvlist_dst_filled = B_TRUE; 1369 return (error); 1370 } 1371 1372 int 1373 getzfsvfs_impl(objset_t *os, zfsvfs_t **zfvp) 1374 { 1375 int error = 0; 1376 if (dmu_objset_type(os) != DMU_OST_ZFS) { 1377 return (SET_ERROR(EINVAL)); 1378 } 1379 1380 mutex_enter(&os->os_user_ptr_lock); 1381 *zfvp = dmu_objset_get_user(os); 1382 /* bump s_active only when non-zero to prevent umount race */ 1383 error = zfs_vfs_ref(zfvp); 1384 mutex_exit(&os->os_user_ptr_lock); 1385 return (error); 1386 } 1387 1388 int 1389 getzfsvfs(const char *dsname, zfsvfs_t **zfvp) 1390 { 1391 objset_t *os; 1392 int error; 1393 1394 error = dmu_objset_hold(dsname, FTAG, &os); 1395 if (error != 0) 1396 return (error); 1397 1398 error = getzfsvfs_impl(os, zfvp); 1399 dmu_objset_rele(os, FTAG); 1400 return (error); 1401 } 1402 1403 /* 1404 * Find a zfsvfs_t for a mounted filesystem, or create our own, in which 1405 * case its z_sb will be NULL, and it will be opened as the owner. 1406 * If 'writer' is set, the z_teardown_lock will be held for RW_WRITER, 1407 * which prevents all inode ops from running. 1408 */ 1409 static int 1410 zfsvfs_hold(const char *name, void *tag, zfsvfs_t **zfvp, boolean_t writer) 1411 { 1412 int error = 0; 1413 1414 if (getzfsvfs(name, zfvp) != 0) 1415 error = zfsvfs_create(name, B_FALSE, zfvp); 1416 if (error == 0) { 1417 if (writer) 1418 ZFS_TEARDOWN_ENTER_WRITE(*zfvp, tag); 1419 else 1420 ZFS_TEARDOWN_ENTER_READ(*zfvp, tag); 1421 if ((*zfvp)->z_unmounted) { 1422 /* 1423 * XXX we could probably try again, since the unmounting 1424 * thread should be just about to disassociate the 1425 * objset from the zfsvfs. 1426 */ 1427 ZFS_TEARDOWN_EXIT(*zfvp, tag); 1428 return (SET_ERROR(EBUSY)); 1429 } 1430 } 1431 return (error); 1432 } 1433 1434 static void 1435 zfsvfs_rele(zfsvfs_t *zfsvfs, void *tag) 1436 { 1437 ZFS_TEARDOWN_EXIT(zfsvfs, tag); 1438 1439 if (zfs_vfs_held(zfsvfs)) { 1440 zfs_vfs_rele(zfsvfs); 1441 } else { 1442 dmu_objset_disown(zfsvfs->z_os, B_TRUE, zfsvfs); 1443 zfsvfs_free(zfsvfs); 1444 } 1445 } 1446 1447 static int 1448 zfs_ioc_pool_create(zfs_cmd_t *zc) 1449 { 1450 int error; 1451 nvlist_t *config, *props = NULL; 1452 nvlist_t *rootprops = NULL; 1453 nvlist_t *zplprops = NULL; 1454 dsl_crypto_params_t *dcp = NULL; 1455 const char *spa_name = zc->zc_name; 1456 boolean_t unload_wkey = B_TRUE; 1457 1458 if ((error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size, 1459 zc->zc_iflags, &config))) 1460 return (error); 1461 1462 if (zc->zc_nvlist_src_size != 0 && (error = 1463 get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size, 1464 zc->zc_iflags, &props))) { 1465 nvlist_free(config); 1466 return (error); 1467 } 1468 1469 if (props) { 1470 nvlist_t *nvl = NULL; 1471 nvlist_t *hidden_args = NULL; 1472 uint64_t version = SPA_VERSION; 1473 char *tname; 1474 1475 (void) nvlist_lookup_uint64(props, 1476 zpool_prop_to_name(ZPOOL_PROP_VERSION), &version); 1477 if (!SPA_VERSION_IS_SUPPORTED(version)) { 1478 error = SET_ERROR(EINVAL); 1479 goto pool_props_bad; 1480 } 1481 (void) nvlist_lookup_nvlist(props, ZPOOL_ROOTFS_PROPS, &nvl); 1482 if (nvl) { 1483 error = nvlist_dup(nvl, &rootprops, KM_SLEEP); 1484 if (error != 0) 1485 goto pool_props_bad; 1486 (void) nvlist_remove_all(props, ZPOOL_ROOTFS_PROPS); 1487 } 1488 1489 (void) nvlist_lookup_nvlist(props, ZPOOL_HIDDEN_ARGS, 1490 &hidden_args); 1491 error = dsl_crypto_params_create_nvlist(DCP_CMD_NONE, 1492 rootprops, hidden_args, &dcp); 1493 if (error != 0) 1494 goto pool_props_bad; 1495 (void) nvlist_remove_all(props, ZPOOL_HIDDEN_ARGS); 1496 1497 VERIFY(nvlist_alloc(&zplprops, NV_UNIQUE_NAME, KM_SLEEP) == 0); 1498 error = zfs_fill_zplprops_root(version, rootprops, 1499 zplprops, NULL); 1500 if (error != 0) 1501 goto pool_props_bad; 1502 1503 if (nvlist_lookup_string(props, 1504 zpool_prop_to_name(ZPOOL_PROP_TNAME), &tname) == 0) 1505 spa_name = tname; 1506 } 1507 1508 error = spa_create(zc->zc_name, config, props, zplprops, dcp); 1509 1510 /* 1511 * Set the remaining root properties 1512 */ 1513 if (!error && (error = zfs_set_prop_nvlist(spa_name, 1514 ZPROP_SRC_LOCAL, rootprops, NULL)) != 0) { 1515 (void) spa_destroy(spa_name); 1516 unload_wkey = B_FALSE; /* spa_destroy() unloads wrapping keys */ 1517 } 1518 1519 pool_props_bad: 1520 nvlist_free(rootprops); 1521 nvlist_free(zplprops); 1522 nvlist_free(config); 1523 nvlist_free(props); 1524 dsl_crypto_params_free(dcp, unload_wkey && !!error); 1525 1526 return (error); 1527 } 1528 1529 static int 1530 zfs_ioc_pool_destroy(zfs_cmd_t *zc) 1531 { 1532 int error; 1533 zfs_log_history(zc); 1534 error = spa_destroy(zc->zc_name); 1535 1536 return (error); 1537 } 1538 1539 static int 1540 zfs_ioc_pool_import(zfs_cmd_t *zc) 1541 { 1542 nvlist_t *config, *props = NULL; 1543 uint64_t guid; 1544 int error; 1545 1546 if ((error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size, 1547 zc->zc_iflags, &config)) != 0) 1548 return (error); 1549 1550 if (zc->zc_nvlist_src_size != 0 && (error = 1551 get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size, 1552 zc->zc_iflags, &props))) { 1553 nvlist_free(config); 1554 return (error); 1555 } 1556 1557 if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, &guid) != 0 || 1558 guid != zc->zc_guid) 1559 error = SET_ERROR(EINVAL); 1560 else 1561 error = spa_import(zc->zc_name, config, props, zc->zc_cookie); 1562 1563 if (zc->zc_nvlist_dst != 0) { 1564 int err; 1565 1566 if ((err = put_nvlist(zc, config)) != 0) 1567 error = err; 1568 } 1569 1570 nvlist_free(config); 1571 nvlist_free(props); 1572 1573 return (error); 1574 } 1575 1576 static int 1577 zfs_ioc_pool_export(zfs_cmd_t *zc) 1578 { 1579 int error; 1580 boolean_t force = (boolean_t)zc->zc_cookie; 1581 boolean_t hardforce = (boolean_t)zc->zc_guid; 1582 1583 zfs_log_history(zc); 1584 error = spa_export(zc->zc_name, NULL, force, hardforce); 1585 1586 return (error); 1587 } 1588 1589 static int 1590 zfs_ioc_pool_configs(zfs_cmd_t *zc) 1591 { 1592 nvlist_t *configs; 1593 int error; 1594 1595 if ((configs = spa_all_configs(&zc->zc_cookie)) == NULL) 1596 return (SET_ERROR(EEXIST)); 1597 1598 error = put_nvlist(zc, configs); 1599 1600 nvlist_free(configs); 1601 1602 return (error); 1603 } 1604 1605 /* 1606 * inputs: 1607 * zc_name name of the pool 1608 * 1609 * outputs: 1610 * zc_cookie real errno 1611 * zc_nvlist_dst config nvlist 1612 * zc_nvlist_dst_size size of config nvlist 1613 */ 1614 static int 1615 zfs_ioc_pool_stats(zfs_cmd_t *zc) 1616 { 1617 nvlist_t *config; 1618 int error; 1619 int ret = 0; 1620 1621 error = spa_get_stats(zc->zc_name, &config, zc->zc_value, 1622 sizeof (zc->zc_value)); 1623 1624 if (config != NULL) { 1625 ret = put_nvlist(zc, config); 1626 nvlist_free(config); 1627 1628 /* 1629 * The config may be present even if 'error' is non-zero. 1630 * In this case we return success, and preserve the real errno 1631 * in 'zc_cookie'. 1632 */ 1633 zc->zc_cookie = error; 1634 } else { 1635 ret = error; 1636 } 1637 1638 return (ret); 1639 } 1640 1641 /* 1642 * Try to import the given pool, returning pool stats as appropriate so that 1643 * user land knows which devices are available and overall pool health. 1644 */ 1645 static int 1646 zfs_ioc_pool_tryimport(zfs_cmd_t *zc) 1647 { 1648 nvlist_t *tryconfig, *config = NULL; 1649 int error; 1650 1651 if ((error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size, 1652 zc->zc_iflags, &tryconfig)) != 0) 1653 return (error); 1654 1655 config = spa_tryimport(tryconfig); 1656 1657 nvlist_free(tryconfig); 1658 1659 if (config == NULL) 1660 return (SET_ERROR(EINVAL)); 1661 1662 error = put_nvlist(zc, config); 1663 nvlist_free(config); 1664 1665 return (error); 1666 } 1667 1668 /* 1669 * inputs: 1670 * zc_name name of the pool 1671 * zc_cookie scan func (pool_scan_func_t) 1672 * zc_flags scrub pause/resume flag (pool_scrub_cmd_t) 1673 */ 1674 static int 1675 zfs_ioc_pool_scan(zfs_cmd_t *zc) 1676 { 1677 spa_t *spa; 1678 int error; 1679 1680 if (zc->zc_flags >= POOL_SCRUB_FLAGS_END) 1681 return (SET_ERROR(EINVAL)); 1682 1683 if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0) 1684 return (error); 1685 1686 if (zc->zc_flags == POOL_SCRUB_PAUSE) 1687 error = spa_scrub_pause_resume(spa, POOL_SCRUB_PAUSE); 1688 else if (zc->zc_cookie == POOL_SCAN_NONE) 1689 error = spa_scan_stop(spa); 1690 else 1691 error = spa_scan(spa, zc->zc_cookie); 1692 1693 spa_close(spa, FTAG); 1694 1695 return (error); 1696 } 1697 1698 static int 1699 zfs_ioc_pool_freeze(zfs_cmd_t *zc) 1700 { 1701 spa_t *spa; 1702 int error; 1703 1704 error = spa_open(zc->zc_name, &spa, FTAG); 1705 if (error == 0) { 1706 spa_freeze(spa); 1707 spa_close(spa, FTAG); 1708 } 1709 return (error); 1710 } 1711 1712 static int 1713 zfs_ioc_pool_upgrade(zfs_cmd_t *zc) 1714 { 1715 spa_t *spa; 1716 int error; 1717 1718 if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0) 1719 return (error); 1720 1721 if (zc->zc_cookie < spa_version(spa) || 1722 !SPA_VERSION_IS_SUPPORTED(zc->zc_cookie)) { 1723 spa_close(spa, FTAG); 1724 return (SET_ERROR(EINVAL)); 1725 } 1726 1727 spa_upgrade(spa, zc->zc_cookie); 1728 spa_close(spa, FTAG); 1729 1730 return (error); 1731 } 1732 1733 static int 1734 zfs_ioc_pool_get_history(zfs_cmd_t *zc) 1735 { 1736 spa_t *spa; 1737 char *hist_buf; 1738 uint64_t size; 1739 int error; 1740 1741 if ((size = zc->zc_history_len) == 0) 1742 return (SET_ERROR(EINVAL)); 1743 1744 if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0) 1745 return (error); 1746 1747 if (spa_version(spa) < SPA_VERSION_ZPOOL_HISTORY) { 1748 spa_close(spa, FTAG); 1749 return (SET_ERROR(ENOTSUP)); 1750 } 1751 1752 hist_buf = vmem_alloc(size, KM_SLEEP); 1753 if ((error = spa_history_get(spa, &zc->zc_history_offset, 1754 &zc->zc_history_len, hist_buf)) == 0) { 1755 error = ddi_copyout(hist_buf, 1756 (void *)(uintptr_t)zc->zc_history, 1757 zc->zc_history_len, zc->zc_iflags); 1758 } 1759 1760 spa_close(spa, FTAG); 1761 vmem_free(hist_buf, size); 1762 return (error); 1763 } 1764 1765 static int 1766 zfs_ioc_pool_reguid(zfs_cmd_t *zc) 1767 { 1768 spa_t *spa; 1769 int error; 1770 1771 error = spa_open(zc->zc_name, &spa, FTAG); 1772 if (error == 0) { 1773 error = spa_change_guid(spa); 1774 spa_close(spa, FTAG); 1775 } 1776 return (error); 1777 } 1778 1779 static int 1780 zfs_ioc_dsobj_to_dsname(zfs_cmd_t *zc) 1781 { 1782 return (dsl_dsobj_to_dsname(zc->zc_name, zc->zc_obj, zc->zc_value)); 1783 } 1784 1785 /* 1786 * inputs: 1787 * zc_name name of filesystem 1788 * zc_obj object to find 1789 * 1790 * outputs: 1791 * zc_value name of object 1792 */ 1793 static int 1794 zfs_ioc_obj_to_path(zfs_cmd_t *zc) 1795 { 1796 objset_t *os; 1797 int error; 1798 1799 /* XXX reading from objset not owned */ 1800 if ((error = dmu_objset_hold_flags(zc->zc_name, B_TRUE, 1801 FTAG, &os)) != 0) 1802 return (error); 1803 if (dmu_objset_type(os) != DMU_OST_ZFS) { 1804 dmu_objset_rele_flags(os, B_TRUE, FTAG); 1805 return (SET_ERROR(EINVAL)); 1806 } 1807 error = zfs_obj_to_path(os, zc->zc_obj, zc->zc_value, 1808 sizeof (zc->zc_value)); 1809 dmu_objset_rele_flags(os, B_TRUE, FTAG); 1810 1811 return (error); 1812 } 1813 1814 /* 1815 * inputs: 1816 * zc_name name of filesystem 1817 * zc_obj object to find 1818 * 1819 * outputs: 1820 * zc_stat stats on object 1821 * zc_value path to object 1822 */ 1823 static int 1824 zfs_ioc_obj_to_stats(zfs_cmd_t *zc) 1825 { 1826 objset_t *os; 1827 int error; 1828 1829 /* XXX reading from objset not owned */ 1830 if ((error = dmu_objset_hold_flags(zc->zc_name, B_TRUE, 1831 FTAG, &os)) != 0) 1832 return (error); 1833 if (dmu_objset_type(os) != DMU_OST_ZFS) { 1834 dmu_objset_rele_flags(os, B_TRUE, FTAG); 1835 return (SET_ERROR(EINVAL)); 1836 } 1837 error = zfs_obj_to_stats(os, zc->zc_obj, &zc->zc_stat, zc->zc_value, 1838 sizeof (zc->zc_value)); 1839 dmu_objset_rele_flags(os, B_TRUE, FTAG); 1840 1841 return (error); 1842 } 1843 1844 static int 1845 zfs_ioc_vdev_add(zfs_cmd_t *zc) 1846 { 1847 spa_t *spa; 1848 int error; 1849 nvlist_t *config; 1850 1851 error = spa_open(zc->zc_name, &spa, FTAG); 1852 if (error != 0) 1853 return (error); 1854 1855 error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size, 1856 zc->zc_iflags, &config); 1857 if (error == 0) { 1858 error = spa_vdev_add(spa, config); 1859 nvlist_free(config); 1860 } 1861 spa_close(spa, FTAG); 1862 return (error); 1863 } 1864 1865 /* 1866 * inputs: 1867 * zc_name name of the pool 1868 * zc_guid guid of vdev to remove 1869 * zc_cookie cancel removal 1870 */ 1871 static int 1872 zfs_ioc_vdev_remove(zfs_cmd_t *zc) 1873 { 1874 spa_t *spa; 1875 int error; 1876 1877 error = spa_open(zc->zc_name, &spa, FTAG); 1878 if (error != 0) 1879 return (error); 1880 if (zc->zc_cookie != 0) { 1881 error = spa_vdev_remove_cancel(spa); 1882 } else { 1883 error = spa_vdev_remove(spa, zc->zc_guid, B_FALSE); 1884 } 1885 spa_close(spa, FTAG); 1886 return (error); 1887 } 1888 1889 static int 1890 zfs_ioc_vdev_set_state(zfs_cmd_t *zc) 1891 { 1892 spa_t *spa; 1893 int error; 1894 vdev_state_t newstate = VDEV_STATE_UNKNOWN; 1895 1896 if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0) 1897 return (error); 1898 switch (zc->zc_cookie) { 1899 case VDEV_STATE_ONLINE: 1900 error = vdev_online(spa, zc->zc_guid, zc->zc_obj, &newstate); 1901 break; 1902 1903 case VDEV_STATE_OFFLINE: 1904 error = vdev_offline(spa, zc->zc_guid, zc->zc_obj); 1905 break; 1906 1907 case VDEV_STATE_FAULTED: 1908 if (zc->zc_obj != VDEV_AUX_ERR_EXCEEDED && 1909 zc->zc_obj != VDEV_AUX_EXTERNAL && 1910 zc->zc_obj != VDEV_AUX_EXTERNAL_PERSIST) 1911 zc->zc_obj = VDEV_AUX_ERR_EXCEEDED; 1912 1913 error = vdev_fault(spa, zc->zc_guid, zc->zc_obj); 1914 break; 1915 1916 case VDEV_STATE_DEGRADED: 1917 if (zc->zc_obj != VDEV_AUX_ERR_EXCEEDED && 1918 zc->zc_obj != VDEV_AUX_EXTERNAL) 1919 zc->zc_obj = VDEV_AUX_ERR_EXCEEDED; 1920 1921 error = vdev_degrade(spa, zc->zc_guid, zc->zc_obj); 1922 break; 1923 1924 default: 1925 error = SET_ERROR(EINVAL); 1926 } 1927 zc->zc_cookie = newstate; 1928 spa_close(spa, FTAG); 1929 return (error); 1930 } 1931 1932 static int 1933 zfs_ioc_vdev_attach(zfs_cmd_t *zc) 1934 { 1935 spa_t *spa; 1936 nvlist_t *config; 1937 int replacing = zc->zc_cookie; 1938 int rebuild = zc->zc_simple; 1939 int error; 1940 1941 if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0) 1942 return (error); 1943 1944 if ((error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size, 1945 zc->zc_iflags, &config)) == 0) { 1946 error = spa_vdev_attach(spa, zc->zc_guid, config, replacing, 1947 rebuild); 1948 nvlist_free(config); 1949 } 1950 1951 spa_close(spa, FTAG); 1952 return (error); 1953 } 1954 1955 static int 1956 zfs_ioc_vdev_detach(zfs_cmd_t *zc) 1957 { 1958 spa_t *spa; 1959 int error; 1960 1961 if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0) 1962 return (error); 1963 1964 error = spa_vdev_detach(spa, zc->zc_guid, 0, B_FALSE); 1965 1966 spa_close(spa, FTAG); 1967 return (error); 1968 } 1969 1970 static int 1971 zfs_ioc_vdev_split(zfs_cmd_t *zc) 1972 { 1973 spa_t *spa; 1974 nvlist_t *config, *props = NULL; 1975 int error; 1976 boolean_t exp = !!(zc->zc_cookie & ZPOOL_EXPORT_AFTER_SPLIT); 1977 1978 if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0) 1979 return (error); 1980 1981 if ((error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size, 1982 zc->zc_iflags, &config))) { 1983 spa_close(spa, FTAG); 1984 return (error); 1985 } 1986 1987 if (zc->zc_nvlist_src_size != 0 && (error = 1988 get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size, 1989 zc->zc_iflags, &props))) { 1990 spa_close(spa, FTAG); 1991 nvlist_free(config); 1992 return (error); 1993 } 1994 1995 error = spa_vdev_split_mirror(spa, zc->zc_string, config, props, exp); 1996 1997 spa_close(spa, FTAG); 1998 1999 nvlist_free(config); 2000 nvlist_free(props); 2001 2002 return (error); 2003 } 2004 2005 static int 2006 zfs_ioc_vdev_setpath(zfs_cmd_t *zc) 2007 { 2008 spa_t *spa; 2009 const char *path = zc->zc_value; 2010 uint64_t guid = zc->zc_guid; 2011 int error; 2012 2013 error = spa_open(zc->zc_name, &spa, FTAG); 2014 if (error != 0) 2015 return (error); 2016 2017 error = spa_vdev_setpath(spa, guid, path); 2018 spa_close(spa, FTAG); 2019 return (error); 2020 } 2021 2022 static int 2023 zfs_ioc_vdev_setfru(zfs_cmd_t *zc) 2024 { 2025 spa_t *spa; 2026 const char *fru = zc->zc_value; 2027 uint64_t guid = zc->zc_guid; 2028 int error; 2029 2030 error = spa_open(zc->zc_name, &spa, FTAG); 2031 if (error != 0) 2032 return (error); 2033 2034 error = spa_vdev_setfru(spa, guid, fru); 2035 spa_close(spa, FTAG); 2036 return (error); 2037 } 2038 2039 static int 2040 zfs_ioc_objset_stats_impl(zfs_cmd_t *zc, objset_t *os) 2041 { 2042 int error = 0; 2043 nvlist_t *nv; 2044 2045 dmu_objset_fast_stat(os, &zc->zc_objset_stats); 2046 2047 if (zc->zc_nvlist_dst != 0 && 2048 (error = dsl_prop_get_all(os, &nv)) == 0) { 2049 dmu_objset_stats(os, nv); 2050 /* 2051 * NB: zvol_get_stats() will read the objset contents, 2052 * which we aren't supposed to do with a 2053 * DS_MODE_USER hold, because it could be 2054 * inconsistent. So this is a bit of a workaround... 2055 * XXX reading without owning 2056 */ 2057 if (!zc->zc_objset_stats.dds_inconsistent && 2058 dmu_objset_type(os) == DMU_OST_ZVOL) { 2059 error = zvol_get_stats(os, nv); 2060 if (error == EIO) { 2061 nvlist_free(nv); 2062 return (error); 2063 } 2064 VERIFY0(error); 2065 } 2066 if (error == 0) 2067 error = put_nvlist(zc, nv); 2068 nvlist_free(nv); 2069 } 2070 2071 return (error); 2072 } 2073 2074 /* 2075 * inputs: 2076 * zc_name name of filesystem 2077 * zc_nvlist_dst_size size of buffer for property nvlist 2078 * 2079 * outputs: 2080 * zc_objset_stats stats 2081 * zc_nvlist_dst property nvlist 2082 * zc_nvlist_dst_size size of property nvlist 2083 */ 2084 static int 2085 zfs_ioc_objset_stats(zfs_cmd_t *zc) 2086 { 2087 objset_t *os; 2088 int error; 2089 2090 error = dmu_objset_hold(zc->zc_name, FTAG, &os); 2091 if (error == 0) { 2092 error = zfs_ioc_objset_stats_impl(zc, os); 2093 dmu_objset_rele(os, FTAG); 2094 } 2095 2096 return (error); 2097 } 2098 2099 /* 2100 * inputs: 2101 * zc_name name of filesystem 2102 * zc_nvlist_dst_size size of buffer for property nvlist 2103 * 2104 * outputs: 2105 * zc_nvlist_dst received property nvlist 2106 * zc_nvlist_dst_size size of received property nvlist 2107 * 2108 * Gets received properties (distinct from local properties on or after 2109 * SPA_VERSION_RECVD_PROPS) for callers who want to differentiate received from 2110 * local property values. 2111 */ 2112 static int 2113 zfs_ioc_objset_recvd_props(zfs_cmd_t *zc) 2114 { 2115 int error = 0; 2116 nvlist_t *nv; 2117 2118 /* 2119 * Without this check, we would return local property values if the 2120 * caller has not already received properties on or after 2121 * SPA_VERSION_RECVD_PROPS. 2122 */ 2123 if (!dsl_prop_get_hasrecvd(zc->zc_name)) 2124 return (SET_ERROR(ENOTSUP)); 2125 2126 if (zc->zc_nvlist_dst != 0 && 2127 (error = dsl_prop_get_received(zc->zc_name, &nv)) == 0) { 2128 error = put_nvlist(zc, nv); 2129 nvlist_free(nv); 2130 } 2131 2132 return (error); 2133 } 2134 2135 static int 2136 nvl_add_zplprop(objset_t *os, nvlist_t *props, zfs_prop_t prop) 2137 { 2138 uint64_t value; 2139 int error; 2140 2141 /* 2142 * zfs_get_zplprop() will either find a value or give us 2143 * the default value (if there is one). 2144 */ 2145 if ((error = zfs_get_zplprop(os, prop, &value)) != 0) 2146 return (error); 2147 VERIFY(nvlist_add_uint64(props, zfs_prop_to_name(prop), value) == 0); 2148 return (0); 2149 } 2150 2151 /* 2152 * inputs: 2153 * zc_name name of filesystem 2154 * zc_nvlist_dst_size size of buffer for zpl property nvlist 2155 * 2156 * outputs: 2157 * zc_nvlist_dst zpl property nvlist 2158 * zc_nvlist_dst_size size of zpl property nvlist 2159 */ 2160 static int 2161 zfs_ioc_objset_zplprops(zfs_cmd_t *zc) 2162 { 2163 objset_t *os; 2164 int err; 2165 2166 /* XXX reading without owning */ 2167 if ((err = dmu_objset_hold(zc->zc_name, FTAG, &os))) 2168 return (err); 2169 2170 dmu_objset_fast_stat(os, &zc->zc_objset_stats); 2171 2172 /* 2173 * NB: nvl_add_zplprop() will read the objset contents, 2174 * which we aren't supposed to do with a DS_MODE_USER 2175 * hold, because it could be inconsistent. 2176 */ 2177 if (zc->zc_nvlist_dst != 0 && 2178 !zc->zc_objset_stats.dds_inconsistent && 2179 dmu_objset_type(os) == DMU_OST_ZFS) { 2180 nvlist_t *nv; 2181 2182 VERIFY(nvlist_alloc(&nv, NV_UNIQUE_NAME, KM_SLEEP) == 0); 2183 if ((err = nvl_add_zplprop(os, nv, ZFS_PROP_VERSION)) == 0 && 2184 (err = nvl_add_zplprop(os, nv, ZFS_PROP_NORMALIZE)) == 0 && 2185 (err = nvl_add_zplprop(os, nv, ZFS_PROP_UTF8ONLY)) == 0 && 2186 (err = nvl_add_zplprop(os, nv, ZFS_PROP_CASE)) == 0) 2187 err = put_nvlist(zc, nv); 2188 nvlist_free(nv); 2189 } else { 2190 err = SET_ERROR(ENOENT); 2191 } 2192 dmu_objset_rele(os, FTAG); 2193 return (err); 2194 } 2195 2196 /* 2197 * inputs: 2198 * zc_name name of filesystem 2199 * zc_cookie zap cursor 2200 * zc_nvlist_dst_size size of buffer for property nvlist 2201 * 2202 * outputs: 2203 * zc_name name of next filesystem 2204 * zc_cookie zap cursor 2205 * zc_objset_stats stats 2206 * zc_nvlist_dst property nvlist 2207 * zc_nvlist_dst_size size of property nvlist 2208 */ 2209 static int 2210 zfs_ioc_dataset_list_next(zfs_cmd_t *zc) 2211 { 2212 objset_t *os; 2213 int error; 2214 char *p; 2215 size_t orig_len = strlen(zc->zc_name); 2216 2217 top: 2218 if ((error = dmu_objset_hold(zc->zc_name, FTAG, &os))) { 2219 if (error == ENOENT) 2220 error = SET_ERROR(ESRCH); 2221 return (error); 2222 } 2223 2224 p = strrchr(zc->zc_name, '/'); 2225 if (p == NULL || p[1] != '\0') 2226 (void) strlcat(zc->zc_name, "/", sizeof (zc->zc_name)); 2227 p = zc->zc_name + strlen(zc->zc_name); 2228 2229 do { 2230 error = dmu_dir_list_next(os, 2231 sizeof (zc->zc_name) - (p - zc->zc_name), p, 2232 NULL, &zc->zc_cookie); 2233 if (error == ENOENT) 2234 error = SET_ERROR(ESRCH); 2235 } while (error == 0 && zfs_dataset_name_hidden(zc->zc_name)); 2236 dmu_objset_rele(os, FTAG); 2237 2238 /* 2239 * If it's an internal dataset (ie. with a '$' in its name), 2240 * don't try to get stats for it, otherwise we'll return ENOENT. 2241 */ 2242 if (error == 0 && strchr(zc->zc_name, '$') == NULL) { 2243 error = zfs_ioc_objset_stats(zc); /* fill in the stats */ 2244 if (error == ENOENT) { 2245 /* We lost a race with destroy, get the next one. */ 2246 zc->zc_name[orig_len] = '\0'; 2247 goto top; 2248 } 2249 } 2250 return (error); 2251 } 2252 2253 /* 2254 * inputs: 2255 * zc_name name of filesystem 2256 * zc_cookie zap cursor 2257 * zc_nvlist_src iteration range nvlist 2258 * zc_nvlist_src_size size of iteration range nvlist 2259 * 2260 * outputs: 2261 * zc_name name of next snapshot 2262 * zc_objset_stats stats 2263 * zc_nvlist_dst property nvlist 2264 * zc_nvlist_dst_size size of property nvlist 2265 */ 2266 static int 2267 zfs_ioc_snapshot_list_next(zfs_cmd_t *zc) 2268 { 2269 int error; 2270 objset_t *os, *ossnap; 2271 dsl_dataset_t *ds; 2272 uint64_t min_txg = 0, max_txg = 0; 2273 2274 if (zc->zc_nvlist_src_size != 0) { 2275 nvlist_t *props = NULL; 2276 error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size, 2277 zc->zc_iflags, &props); 2278 if (error != 0) 2279 return (error); 2280 (void) nvlist_lookup_uint64(props, SNAP_ITER_MIN_TXG, 2281 &min_txg); 2282 (void) nvlist_lookup_uint64(props, SNAP_ITER_MAX_TXG, 2283 &max_txg); 2284 nvlist_free(props); 2285 } 2286 2287 error = dmu_objset_hold(zc->zc_name, FTAG, &os); 2288 if (error != 0) { 2289 return (error == ENOENT ? SET_ERROR(ESRCH) : error); 2290 } 2291 2292 /* 2293 * A dataset name of maximum length cannot have any snapshots, 2294 * so exit immediately. 2295 */ 2296 if (strlcat(zc->zc_name, "@", sizeof (zc->zc_name)) >= 2297 ZFS_MAX_DATASET_NAME_LEN) { 2298 dmu_objset_rele(os, FTAG); 2299 return (SET_ERROR(ESRCH)); 2300 } 2301 2302 while (error == 0) { 2303 if (issig(JUSTLOOKING) && issig(FORREAL)) { 2304 error = SET_ERROR(EINTR); 2305 break; 2306 } 2307 2308 error = dmu_snapshot_list_next(os, 2309 sizeof (zc->zc_name) - strlen(zc->zc_name), 2310 zc->zc_name + strlen(zc->zc_name), &zc->zc_obj, 2311 &zc->zc_cookie, NULL); 2312 if (error == ENOENT) { 2313 error = SET_ERROR(ESRCH); 2314 break; 2315 } else if (error != 0) { 2316 break; 2317 } 2318 2319 error = dsl_dataset_hold_obj(dmu_objset_pool(os), zc->zc_obj, 2320 FTAG, &ds); 2321 if (error != 0) 2322 break; 2323 2324 if ((min_txg != 0 && dsl_get_creationtxg(ds) < min_txg) || 2325 (max_txg != 0 && dsl_get_creationtxg(ds) > max_txg)) { 2326 dsl_dataset_rele(ds, FTAG); 2327 /* undo snapshot name append */ 2328 *(strchr(zc->zc_name, '@') + 1) = '\0'; 2329 /* skip snapshot */ 2330 continue; 2331 } 2332 2333 if (zc->zc_simple) { 2334 dsl_dataset_rele(ds, FTAG); 2335 break; 2336 } 2337 2338 if ((error = dmu_objset_from_ds(ds, &ossnap)) != 0) { 2339 dsl_dataset_rele(ds, FTAG); 2340 break; 2341 } 2342 if ((error = zfs_ioc_objset_stats_impl(zc, ossnap)) != 0) { 2343 dsl_dataset_rele(ds, FTAG); 2344 break; 2345 } 2346 dsl_dataset_rele(ds, FTAG); 2347 break; 2348 } 2349 2350 dmu_objset_rele(os, FTAG); 2351 /* if we failed, undo the @ that we tacked on to zc_name */ 2352 if (error != 0) 2353 *strchr(zc->zc_name, '@') = '\0'; 2354 return (error); 2355 } 2356 2357 static int 2358 zfs_prop_set_userquota(const char *dsname, nvpair_t *pair) 2359 { 2360 const char *propname = nvpair_name(pair); 2361 uint64_t *valary; 2362 unsigned int vallen; 2363 const char *dash, *domain; 2364 zfs_userquota_prop_t type; 2365 uint64_t rid; 2366 uint64_t quota; 2367 zfsvfs_t *zfsvfs; 2368 int err; 2369 2370 if (nvpair_type(pair) == DATA_TYPE_NVLIST) { 2371 nvlist_t *attrs; 2372 VERIFY(nvpair_value_nvlist(pair, &attrs) == 0); 2373 if (nvlist_lookup_nvpair(attrs, ZPROP_VALUE, 2374 &pair) != 0) 2375 return (SET_ERROR(EINVAL)); 2376 } 2377 2378 /* 2379 * A correctly constructed propname is encoded as 2380 * userquota@<rid>-<domain>. 2381 */ 2382 if ((dash = strchr(propname, '-')) == NULL || 2383 nvpair_value_uint64_array(pair, &valary, &vallen) != 0 || 2384 vallen != 3) 2385 return (SET_ERROR(EINVAL)); 2386 2387 domain = dash + 1; 2388 type = valary[0]; 2389 rid = valary[1]; 2390 quota = valary[2]; 2391 2392 err = zfsvfs_hold(dsname, FTAG, &zfsvfs, B_FALSE); 2393 if (err == 0) { 2394 err = zfs_set_userquota(zfsvfs, type, domain, rid, quota); 2395 zfsvfs_rele(zfsvfs, FTAG); 2396 } 2397 2398 return (err); 2399 } 2400 2401 /* 2402 * If the named property is one that has a special function to set its value, 2403 * return 0 on success and a positive error code on failure; otherwise if it is 2404 * not one of the special properties handled by this function, return -1. 2405 * 2406 * XXX: It would be better for callers of the property interface if we handled 2407 * these special cases in dsl_prop.c (in the dsl layer). 2408 */ 2409 static int 2410 zfs_prop_set_special(const char *dsname, zprop_source_t source, 2411 nvpair_t *pair) 2412 { 2413 const char *propname = nvpair_name(pair); 2414 zfs_prop_t prop = zfs_name_to_prop(propname); 2415 uint64_t intval = 0; 2416 const char *strval = NULL; 2417 int err = -1; 2418 2419 if (prop == ZPROP_INVAL) { 2420 if (zfs_prop_userquota(propname)) 2421 return (zfs_prop_set_userquota(dsname, pair)); 2422 return (-1); 2423 } 2424 2425 if (nvpair_type(pair) == DATA_TYPE_NVLIST) { 2426 nvlist_t *attrs; 2427 VERIFY(nvpair_value_nvlist(pair, &attrs) == 0); 2428 VERIFY(nvlist_lookup_nvpair(attrs, ZPROP_VALUE, 2429 &pair) == 0); 2430 } 2431 2432 /* all special properties are numeric except for keylocation */ 2433 if (zfs_prop_get_type(prop) == PROP_TYPE_STRING) { 2434 strval = fnvpair_value_string(pair); 2435 } else { 2436 intval = fnvpair_value_uint64(pair); 2437 } 2438 2439 switch (prop) { 2440 case ZFS_PROP_QUOTA: 2441 err = dsl_dir_set_quota(dsname, source, intval); 2442 break; 2443 case ZFS_PROP_REFQUOTA: 2444 err = dsl_dataset_set_refquota(dsname, source, intval); 2445 break; 2446 case ZFS_PROP_FILESYSTEM_LIMIT: 2447 case ZFS_PROP_SNAPSHOT_LIMIT: 2448 if (intval == UINT64_MAX) { 2449 /* clearing the limit, just do it */ 2450 err = 0; 2451 } else { 2452 err = dsl_dir_activate_fs_ss_limit(dsname); 2453 } 2454 /* 2455 * Set err to -1 to force the zfs_set_prop_nvlist code down the 2456 * default path to set the value in the nvlist. 2457 */ 2458 if (err == 0) 2459 err = -1; 2460 break; 2461 case ZFS_PROP_KEYLOCATION: 2462 err = dsl_crypto_can_set_keylocation(dsname, strval); 2463 2464 /* 2465 * Set err to -1 to force the zfs_set_prop_nvlist code down the 2466 * default path to set the value in the nvlist. 2467 */ 2468 if (err == 0) 2469 err = -1; 2470 break; 2471 case ZFS_PROP_RESERVATION: 2472 err = dsl_dir_set_reservation(dsname, source, intval); 2473 break; 2474 case ZFS_PROP_REFRESERVATION: 2475 err = dsl_dataset_set_refreservation(dsname, source, intval); 2476 break; 2477 case ZFS_PROP_COMPRESSION: 2478 err = dsl_dataset_set_compression(dsname, source, intval); 2479 /* 2480 * Set err to -1 to force the zfs_set_prop_nvlist code down the 2481 * default path to set the value in the nvlist. 2482 */ 2483 if (err == 0) 2484 err = -1; 2485 break; 2486 case ZFS_PROP_VOLSIZE: 2487 err = zvol_set_volsize(dsname, intval); 2488 break; 2489 case ZFS_PROP_SNAPDEV: 2490 err = zvol_set_snapdev(dsname, source, intval); 2491 break; 2492 case ZFS_PROP_VOLMODE: 2493 err = zvol_set_volmode(dsname, source, intval); 2494 break; 2495 case ZFS_PROP_VERSION: 2496 { 2497 zfsvfs_t *zfsvfs; 2498 2499 if ((err = zfsvfs_hold(dsname, FTAG, &zfsvfs, B_TRUE)) != 0) 2500 break; 2501 2502 err = zfs_set_version(zfsvfs, intval); 2503 zfsvfs_rele(zfsvfs, FTAG); 2504 2505 if (err == 0 && intval >= ZPL_VERSION_USERSPACE) { 2506 zfs_cmd_t *zc; 2507 2508 zc = kmem_zalloc(sizeof (zfs_cmd_t), KM_SLEEP); 2509 (void) strlcpy(zc->zc_name, dsname, 2510 sizeof (zc->zc_name)); 2511 (void) zfs_ioc_userspace_upgrade(zc); 2512 (void) zfs_ioc_id_quota_upgrade(zc); 2513 kmem_free(zc, sizeof (zfs_cmd_t)); 2514 } 2515 break; 2516 } 2517 default: 2518 err = -1; 2519 } 2520 2521 return (err); 2522 } 2523 2524 static boolean_t 2525 zfs_is_namespace_prop(zfs_prop_t prop) 2526 { 2527 switch (prop) { 2528 2529 case ZFS_PROP_ATIME: 2530 case ZFS_PROP_RELATIME: 2531 case ZFS_PROP_DEVICES: 2532 case ZFS_PROP_EXEC: 2533 case ZFS_PROP_SETUID: 2534 case ZFS_PROP_READONLY: 2535 case ZFS_PROP_XATTR: 2536 case ZFS_PROP_NBMAND: 2537 return (B_TRUE); 2538 2539 default: 2540 return (B_FALSE); 2541 } 2542 } 2543 2544 /* 2545 * This function is best effort. If it fails to set any of the given properties, 2546 * it continues to set as many as it can and returns the last error 2547 * encountered. If the caller provides a non-NULL errlist, it will be filled in 2548 * with the list of names of all the properties that failed along with the 2549 * corresponding error numbers. 2550 * 2551 * If every property is set successfully, zero is returned and errlist is not 2552 * modified. 2553 */ 2554 int 2555 zfs_set_prop_nvlist(const char *dsname, zprop_source_t source, nvlist_t *nvl, 2556 nvlist_t *errlist) 2557 { 2558 nvpair_t *pair; 2559 nvpair_t *propval; 2560 int rv = 0; 2561 uint64_t intval; 2562 const char *strval; 2563 boolean_t should_update_mount_cache = B_FALSE; 2564 2565 nvlist_t *genericnvl = fnvlist_alloc(); 2566 nvlist_t *retrynvl = fnvlist_alloc(); 2567 retry: 2568 pair = NULL; 2569 while ((pair = nvlist_next_nvpair(nvl, pair)) != NULL) { 2570 const char *propname = nvpair_name(pair); 2571 zfs_prop_t prop = zfs_name_to_prop(propname); 2572 int err = 0; 2573 2574 /* decode the property value */ 2575 propval = pair; 2576 if (nvpair_type(pair) == DATA_TYPE_NVLIST) { 2577 nvlist_t *attrs; 2578 attrs = fnvpair_value_nvlist(pair); 2579 if (nvlist_lookup_nvpair(attrs, ZPROP_VALUE, 2580 &propval) != 0) 2581 err = SET_ERROR(EINVAL); 2582 } 2583 2584 /* Validate value type */ 2585 if (err == 0 && source == ZPROP_SRC_INHERITED) { 2586 /* inherited properties are expected to be booleans */ 2587 if (nvpair_type(propval) != DATA_TYPE_BOOLEAN) 2588 err = SET_ERROR(EINVAL); 2589 } else if (err == 0 && prop == ZPROP_INVAL) { 2590 if (zfs_prop_user(propname)) { 2591 if (nvpair_type(propval) != DATA_TYPE_STRING) 2592 err = SET_ERROR(EINVAL); 2593 } else if (zfs_prop_userquota(propname)) { 2594 if (nvpair_type(propval) != 2595 DATA_TYPE_UINT64_ARRAY) 2596 err = SET_ERROR(EINVAL); 2597 } else { 2598 err = SET_ERROR(EINVAL); 2599 } 2600 } else if (err == 0) { 2601 if (nvpair_type(propval) == DATA_TYPE_STRING) { 2602 if (zfs_prop_get_type(prop) != PROP_TYPE_STRING) 2603 err = SET_ERROR(EINVAL); 2604 } else if (nvpair_type(propval) == DATA_TYPE_UINT64) { 2605 const char *unused; 2606 2607 intval = fnvpair_value_uint64(propval); 2608 2609 switch (zfs_prop_get_type(prop)) { 2610 case PROP_TYPE_NUMBER: 2611 break; 2612 case PROP_TYPE_STRING: 2613 err = SET_ERROR(EINVAL); 2614 break; 2615 case PROP_TYPE_INDEX: 2616 if (zfs_prop_index_to_string(prop, 2617 intval, &unused) != 0) 2618 err = 2619 SET_ERROR(ZFS_ERR_BADPROP); 2620 break; 2621 default: 2622 cmn_err(CE_PANIC, 2623 "unknown property type"); 2624 } 2625 } else { 2626 err = SET_ERROR(EINVAL); 2627 } 2628 } 2629 2630 /* Validate permissions */ 2631 if (err == 0) 2632 err = zfs_check_settable(dsname, pair, CRED()); 2633 2634 if (err == 0) { 2635 if (source == ZPROP_SRC_INHERITED) 2636 err = -1; /* does not need special handling */ 2637 else 2638 err = zfs_prop_set_special(dsname, source, 2639 pair); 2640 if (err == -1) { 2641 /* 2642 * For better performance we build up a list of 2643 * properties to set in a single transaction. 2644 */ 2645 err = nvlist_add_nvpair(genericnvl, pair); 2646 } else if (err != 0 && nvl != retrynvl) { 2647 /* 2648 * This may be a spurious error caused by 2649 * receiving quota and reservation out of order. 2650 * Try again in a second pass. 2651 */ 2652 err = nvlist_add_nvpair(retrynvl, pair); 2653 } 2654 } 2655 2656 if (err != 0) { 2657 if (errlist != NULL) 2658 fnvlist_add_int32(errlist, propname, err); 2659 rv = err; 2660 } 2661 2662 if (zfs_is_namespace_prop(prop)) 2663 should_update_mount_cache = B_TRUE; 2664 } 2665 2666 if (nvl != retrynvl && !nvlist_empty(retrynvl)) { 2667 nvl = retrynvl; 2668 goto retry; 2669 } 2670 2671 if (!nvlist_empty(genericnvl) && 2672 dsl_props_set(dsname, source, genericnvl) != 0) { 2673 /* 2674 * If this fails, we still want to set as many properties as we 2675 * can, so try setting them individually. 2676 */ 2677 pair = NULL; 2678 while ((pair = nvlist_next_nvpair(genericnvl, pair)) != NULL) { 2679 const char *propname = nvpair_name(pair); 2680 int err = 0; 2681 2682 propval = pair; 2683 if (nvpair_type(pair) == DATA_TYPE_NVLIST) { 2684 nvlist_t *attrs; 2685 attrs = fnvpair_value_nvlist(pair); 2686 propval = fnvlist_lookup_nvpair(attrs, 2687 ZPROP_VALUE); 2688 } 2689 2690 if (nvpair_type(propval) == DATA_TYPE_STRING) { 2691 strval = fnvpair_value_string(propval); 2692 err = dsl_prop_set_string(dsname, propname, 2693 source, strval); 2694 } else if (nvpair_type(propval) == DATA_TYPE_BOOLEAN) { 2695 err = dsl_prop_inherit(dsname, propname, 2696 source); 2697 } else { 2698 intval = fnvpair_value_uint64(propval); 2699 err = dsl_prop_set_int(dsname, propname, source, 2700 intval); 2701 } 2702 2703 if (err != 0) { 2704 if (errlist != NULL) { 2705 fnvlist_add_int32(errlist, propname, 2706 err); 2707 } 2708 rv = err; 2709 } 2710 } 2711 } 2712 if (should_update_mount_cache) 2713 zfs_ioctl_update_mount_cache(dsname); 2714 2715 nvlist_free(genericnvl); 2716 nvlist_free(retrynvl); 2717 2718 return (rv); 2719 } 2720 2721 /* 2722 * Check that all the properties are valid user properties. 2723 */ 2724 static int 2725 zfs_check_userprops(nvlist_t *nvl) 2726 { 2727 nvpair_t *pair = NULL; 2728 2729 while ((pair = nvlist_next_nvpair(nvl, pair)) != NULL) { 2730 const char *propname = nvpair_name(pair); 2731 2732 if (!zfs_prop_user(propname) || 2733 nvpair_type(pair) != DATA_TYPE_STRING) 2734 return (SET_ERROR(EINVAL)); 2735 2736 if (strlen(propname) >= ZAP_MAXNAMELEN) 2737 return (SET_ERROR(ENAMETOOLONG)); 2738 2739 if (strlen(fnvpair_value_string(pair)) >= ZAP_MAXVALUELEN) 2740 return (SET_ERROR(E2BIG)); 2741 } 2742 return (0); 2743 } 2744 2745 static void 2746 props_skip(nvlist_t *props, nvlist_t *skipped, nvlist_t **newprops) 2747 { 2748 nvpair_t *pair; 2749 2750 VERIFY(nvlist_alloc(newprops, NV_UNIQUE_NAME, KM_SLEEP) == 0); 2751 2752 pair = NULL; 2753 while ((pair = nvlist_next_nvpair(props, pair)) != NULL) { 2754 if (nvlist_exists(skipped, nvpair_name(pair))) 2755 continue; 2756 2757 VERIFY(nvlist_add_nvpair(*newprops, pair) == 0); 2758 } 2759 } 2760 2761 static int 2762 clear_received_props(const char *dsname, nvlist_t *props, 2763 nvlist_t *skipped) 2764 { 2765 int err = 0; 2766 nvlist_t *cleared_props = NULL; 2767 props_skip(props, skipped, &cleared_props); 2768 if (!nvlist_empty(cleared_props)) { 2769 /* 2770 * Acts on local properties until the dataset has received 2771 * properties at least once on or after SPA_VERSION_RECVD_PROPS. 2772 */ 2773 zprop_source_t flags = (ZPROP_SRC_NONE | 2774 (dsl_prop_get_hasrecvd(dsname) ? ZPROP_SRC_RECEIVED : 0)); 2775 err = zfs_set_prop_nvlist(dsname, flags, cleared_props, NULL); 2776 } 2777 nvlist_free(cleared_props); 2778 return (err); 2779 } 2780 2781 /* 2782 * inputs: 2783 * zc_name name of filesystem 2784 * zc_value name of property to set 2785 * zc_nvlist_src{_size} nvlist of properties to apply 2786 * zc_cookie received properties flag 2787 * 2788 * outputs: 2789 * zc_nvlist_dst{_size} error for each unapplied received property 2790 */ 2791 static int 2792 zfs_ioc_set_prop(zfs_cmd_t *zc) 2793 { 2794 nvlist_t *nvl; 2795 boolean_t received = zc->zc_cookie; 2796 zprop_source_t source = (received ? ZPROP_SRC_RECEIVED : 2797 ZPROP_SRC_LOCAL); 2798 nvlist_t *errors; 2799 int error; 2800 2801 if ((error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size, 2802 zc->zc_iflags, &nvl)) != 0) 2803 return (error); 2804 2805 if (received) { 2806 nvlist_t *origprops; 2807 2808 if (dsl_prop_get_received(zc->zc_name, &origprops) == 0) { 2809 (void) clear_received_props(zc->zc_name, 2810 origprops, nvl); 2811 nvlist_free(origprops); 2812 } 2813 2814 error = dsl_prop_set_hasrecvd(zc->zc_name); 2815 } 2816 2817 errors = fnvlist_alloc(); 2818 if (error == 0) 2819 error = zfs_set_prop_nvlist(zc->zc_name, source, nvl, errors); 2820 2821 if (zc->zc_nvlist_dst != 0 && errors != NULL) { 2822 (void) put_nvlist(zc, errors); 2823 } 2824 2825 nvlist_free(errors); 2826 nvlist_free(nvl); 2827 return (error); 2828 } 2829 2830 /* 2831 * inputs: 2832 * zc_name name of filesystem 2833 * zc_value name of property to inherit 2834 * zc_cookie revert to received value if TRUE 2835 * 2836 * outputs: none 2837 */ 2838 static int 2839 zfs_ioc_inherit_prop(zfs_cmd_t *zc) 2840 { 2841 const char *propname = zc->zc_value; 2842 zfs_prop_t prop = zfs_name_to_prop(propname); 2843 boolean_t received = zc->zc_cookie; 2844 zprop_source_t source = (received 2845 ? ZPROP_SRC_NONE /* revert to received value, if any */ 2846 : ZPROP_SRC_INHERITED); /* explicitly inherit */ 2847 nvlist_t *dummy; 2848 nvpair_t *pair; 2849 zprop_type_t type; 2850 int err; 2851 2852 if (!received) { 2853 /* 2854 * Only check this in the non-received case. We want to allow 2855 * 'inherit -S' to revert non-inheritable properties like quota 2856 * and reservation to the received or default values even though 2857 * they are not considered inheritable. 2858 */ 2859 if (prop != ZPROP_INVAL && !zfs_prop_inheritable(prop)) 2860 return (SET_ERROR(EINVAL)); 2861 } 2862 2863 if (prop == ZPROP_INVAL) { 2864 if (!zfs_prop_user(propname)) 2865 return (SET_ERROR(EINVAL)); 2866 2867 type = PROP_TYPE_STRING; 2868 } else if (prop == ZFS_PROP_VOLSIZE || prop == ZFS_PROP_VERSION) { 2869 return (SET_ERROR(EINVAL)); 2870 } else { 2871 type = zfs_prop_get_type(prop); 2872 } 2873 2874 /* 2875 * zfs_prop_set_special() expects properties in the form of an 2876 * nvpair with type info. 2877 */ 2878 dummy = fnvlist_alloc(); 2879 2880 switch (type) { 2881 case PROP_TYPE_STRING: 2882 VERIFY(0 == nvlist_add_string(dummy, propname, "")); 2883 break; 2884 case PROP_TYPE_NUMBER: 2885 case PROP_TYPE_INDEX: 2886 VERIFY(0 == nvlist_add_uint64(dummy, propname, 0)); 2887 break; 2888 default: 2889 err = SET_ERROR(EINVAL); 2890 goto errout; 2891 } 2892 2893 pair = nvlist_next_nvpair(dummy, NULL); 2894 if (pair == NULL) { 2895 err = SET_ERROR(EINVAL); 2896 } else { 2897 err = zfs_prop_set_special(zc->zc_name, source, pair); 2898 if (err == -1) /* property is not "special", needs handling */ 2899 err = dsl_prop_inherit(zc->zc_name, zc->zc_value, 2900 source); 2901 } 2902 2903 errout: 2904 nvlist_free(dummy); 2905 return (err); 2906 } 2907 2908 static int 2909 zfs_ioc_pool_set_props(zfs_cmd_t *zc) 2910 { 2911 nvlist_t *props; 2912 spa_t *spa; 2913 int error; 2914 nvpair_t *pair; 2915 2916 if ((error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size, 2917 zc->zc_iflags, &props))) 2918 return (error); 2919 2920 /* 2921 * If the only property is the configfile, then just do a spa_lookup() 2922 * to handle the faulted case. 2923 */ 2924 pair = nvlist_next_nvpair(props, NULL); 2925 if (pair != NULL && strcmp(nvpair_name(pair), 2926 zpool_prop_to_name(ZPOOL_PROP_CACHEFILE)) == 0 && 2927 nvlist_next_nvpair(props, pair) == NULL) { 2928 mutex_enter(&spa_namespace_lock); 2929 if ((spa = spa_lookup(zc->zc_name)) != NULL) { 2930 spa_configfile_set(spa, props, B_FALSE); 2931 spa_write_cachefile(spa, B_FALSE, B_TRUE); 2932 } 2933 mutex_exit(&spa_namespace_lock); 2934 if (spa != NULL) { 2935 nvlist_free(props); 2936 return (0); 2937 } 2938 } 2939 2940 if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0) { 2941 nvlist_free(props); 2942 return (error); 2943 } 2944 2945 error = spa_prop_set(spa, props); 2946 2947 nvlist_free(props); 2948 spa_close(spa, FTAG); 2949 2950 return (error); 2951 } 2952 2953 static int 2954 zfs_ioc_pool_get_props(zfs_cmd_t *zc) 2955 { 2956 spa_t *spa; 2957 int error; 2958 nvlist_t *nvp = NULL; 2959 2960 if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0) { 2961 /* 2962 * If the pool is faulted, there may be properties we can still 2963 * get (such as altroot and cachefile), so attempt to get them 2964 * anyway. 2965 */ 2966 mutex_enter(&spa_namespace_lock); 2967 if ((spa = spa_lookup(zc->zc_name)) != NULL) 2968 error = spa_prop_get(spa, &nvp); 2969 mutex_exit(&spa_namespace_lock); 2970 } else { 2971 error = spa_prop_get(spa, &nvp); 2972 spa_close(spa, FTAG); 2973 } 2974 2975 if (error == 0 && zc->zc_nvlist_dst != 0) 2976 error = put_nvlist(zc, nvp); 2977 else 2978 error = SET_ERROR(EFAULT); 2979 2980 nvlist_free(nvp); 2981 return (error); 2982 } 2983 2984 /* 2985 * innvl: { 2986 * "vdevprops_set_vdev" -> guid 2987 * "vdevprops_set_props" -> { prop -> value } 2988 * } 2989 * 2990 * outnvl: propname -> error code (int32) 2991 */ 2992 static const zfs_ioc_key_t zfs_keys_vdev_set_props[] = { 2993 {ZPOOL_VDEV_PROPS_SET_VDEV, DATA_TYPE_UINT64, 0}, 2994 {ZPOOL_VDEV_PROPS_SET_PROPS, DATA_TYPE_NVLIST, 0} 2995 }; 2996 2997 static int 2998 zfs_ioc_vdev_set_props(const char *poolname, nvlist_t *innvl, nvlist_t *outnvl) 2999 { 3000 spa_t *spa; 3001 int error; 3002 vdev_t *vd; 3003 uint64_t vdev_guid; 3004 3005 /* Early validation */ 3006 if (nvlist_lookup_uint64(innvl, ZPOOL_VDEV_PROPS_SET_VDEV, 3007 &vdev_guid) != 0) 3008 return (SET_ERROR(EINVAL)); 3009 3010 if (outnvl == NULL) 3011 return (SET_ERROR(EINVAL)); 3012 3013 if ((error = spa_open(poolname, &spa, FTAG)) != 0) 3014 return (error); 3015 3016 ASSERT(spa_writeable(spa)); 3017 3018 if ((vd = spa_lookup_by_guid(spa, vdev_guid, B_TRUE)) == NULL) { 3019 spa_close(spa, FTAG); 3020 return (SET_ERROR(ENOENT)); 3021 } 3022 3023 error = vdev_prop_set(vd, innvl, outnvl); 3024 3025 spa_close(spa, FTAG); 3026 3027 return (error); 3028 } 3029 3030 /* 3031 * innvl: { 3032 * "vdevprops_get_vdev" -> guid 3033 * (optional) "vdevprops_get_props" -> { propname -> propid } 3034 * } 3035 * 3036 * outnvl: propname -> value 3037 */ 3038 static const zfs_ioc_key_t zfs_keys_vdev_get_props[] = { 3039 {ZPOOL_VDEV_PROPS_GET_VDEV, DATA_TYPE_UINT64, 0}, 3040 {ZPOOL_VDEV_PROPS_GET_PROPS, DATA_TYPE_NVLIST, ZK_OPTIONAL} 3041 }; 3042 3043 static int 3044 zfs_ioc_vdev_get_props(const char *poolname, nvlist_t *innvl, nvlist_t *outnvl) 3045 { 3046 spa_t *spa; 3047 int error; 3048 vdev_t *vd; 3049 uint64_t vdev_guid; 3050 3051 /* Early validation */ 3052 if (nvlist_lookup_uint64(innvl, ZPOOL_VDEV_PROPS_GET_VDEV, 3053 &vdev_guid) != 0) 3054 return (SET_ERROR(EINVAL)); 3055 3056 if (outnvl == NULL) 3057 return (SET_ERROR(EINVAL)); 3058 3059 if ((error = spa_open(poolname, &spa, FTAG)) != 0) 3060 return (error); 3061 3062 if ((vd = spa_lookup_by_guid(spa, vdev_guid, B_TRUE)) == NULL) { 3063 spa_close(spa, FTAG); 3064 return (SET_ERROR(ENOENT)); 3065 } 3066 3067 error = vdev_prop_get(vd, innvl, outnvl); 3068 3069 spa_close(spa, FTAG); 3070 3071 return (error); 3072 } 3073 3074 /* 3075 * inputs: 3076 * zc_name name of filesystem 3077 * zc_nvlist_src{_size} nvlist of delegated permissions 3078 * zc_perm_action allow/unallow flag 3079 * 3080 * outputs: none 3081 */ 3082 static int 3083 zfs_ioc_set_fsacl(zfs_cmd_t *zc) 3084 { 3085 int error; 3086 nvlist_t *fsaclnv = NULL; 3087 3088 if ((error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size, 3089 zc->zc_iflags, &fsaclnv)) != 0) 3090 return (error); 3091 3092 /* 3093 * Verify nvlist is constructed correctly 3094 */ 3095 if ((error = zfs_deleg_verify_nvlist(fsaclnv)) != 0) { 3096 nvlist_free(fsaclnv); 3097 return (SET_ERROR(EINVAL)); 3098 } 3099 3100 /* 3101 * If we don't have PRIV_SYS_MOUNT, then validate 3102 * that user is allowed to hand out each permission in 3103 * the nvlist(s) 3104 */ 3105 3106 error = secpolicy_zfs(CRED()); 3107 if (error != 0) { 3108 if (zc->zc_perm_action == B_FALSE) { 3109 error = dsl_deleg_can_allow(zc->zc_name, 3110 fsaclnv, CRED()); 3111 } else { 3112 error = dsl_deleg_can_unallow(zc->zc_name, 3113 fsaclnv, CRED()); 3114 } 3115 } 3116 3117 if (error == 0) 3118 error = dsl_deleg_set(zc->zc_name, fsaclnv, zc->zc_perm_action); 3119 3120 nvlist_free(fsaclnv); 3121 return (error); 3122 } 3123 3124 /* 3125 * inputs: 3126 * zc_name name of filesystem 3127 * 3128 * outputs: 3129 * zc_nvlist_src{_size} nvlist of delegated permissions 3130 */ 3131 static int 3132 zfs_ioc_get_fsacl(zfs_cmd_t *zc) 3133 { 3134 nvlist_t *nvp; 3135 int error; 3136 3137 if ((error = dsl_deleg_get(zc->zc_name, &nvp)) == 0) { 3138 error = put_nvlist(zc, nvp); 3139 nvlist_free(nvp); 3140 } 3141 3142 return (error); 3143 } 3144 3145 /* ARGSUSED */ 3146 static void 3147 zfs_create_cb(objset_t *os, void *arg, cred_t *cr, dmu_tx_t *tx) 3148 { 3149 zfs_creat_t *zct = arg; 3150 3151 zfs_create_fs(os, cr, zct->zct_zplprops, tx); 3152 } 3153 3154 #define ZFS_PROP_UNDEFINED ((uint64_t)-1) 3155 3156 /* 3157 * inputs: 3158 * os parent objset pointer (NULL if root fs) 3159 * fuids_ok fuids allowed in this version of the spa? 3160 * sa_ok SAs allowed in this version of the spa? 3161 * createprops list of properties requested by creator 3162 * 3163 * outputs: 3164 * zplprops values for the zplprops we attach to the master node object 3165 * is_ci true if requested file system will be purely case-insensitive 3166 * 3167 * Determine the settings for utf8only, normalization and 3168 * casesensitivity. Specific values may have been requested by the 3169 * creator and/or we can inherit values from the parent dataset. If 3170 * the file system is of too early a vintage, a creator can not 3171 * request settings for these properties, even if the requested 3172 * setting is the default value. We don't actually want to create dsl 3173 * properties for these, so remove them from the source nvlist after 3174 * processing. 3175 */ 3176 static int 3177 zfs_fill_zplprops_impl(objset_t *os, uint64_t zplver, 3178 boolean_t fuids_ok, boolean_t sa_ok, nvlist_t *createprops, 3179 nvlist_t *zplprops, boolean_t *is_ci) 3180 { 3181 uint64_t sense = ZFS_PROP_UNDEFINED; 3182 uint64_t norm = ZFS_PROP_UNDEFINED; 3183 uint64_t u8 = ZFS_PROP_UNDEFINED; 3184 int error; 3185 3186 ASSERT(zplprops != NULL); 3187 3188 /* parent dataset must be a filesystem */ 3189 if (os != NULL && os->os_phys->os_type != DMU_OST_ZFS) 3190 return (SET_ERROR(ZFS_ERR_WRONG_PARENT)); 3191 3192 /* 3193 * Pull out creator prop choices, if any. 3194 */ 3195 if (createprops) { 3196 (void) nvlist_lookup_uint64(createprops, 3197 zfs_prop_to_name(ZFS_PROP_VERSION), &zplver); 3198 (void) nvlist_lookup_uint64(createprops, 3199 zfs_prop_to_name(ZFS_PROP_NORMALIZE), &norm); 3200 (void) nvlist_remove_all(createprops, 3201 zfs_prop_to_name(ZFS_PROP_NORMALIZE)); 3202 (void) nvlist_lookup_uint64(createprops, 3203 zfs_prop_to_name(ZFS_PROP_UTF8ONLY), &u8); 3204 (void) nvlist_remove_all(createprops, 3205 zfs_prop_to_name(ZFS_PROP_UTF8ONLY)); 3206 (void) nvlist_lookup_uint64(createprops, 3207 zfs_prop_to_name(ZFS_PROP_CASE), &sense); 3208 (void) nvlist_remove_all(createprops, 3209 zfs_prop_to_name(ZFS_PROP_CASE)); 3210 } 3211 3212 /* 3213 * If the zpl version requested is whacky or the file system 3214 * or pool is version is too "young" to support normalization 3215 * and the creator tried to set a value for one of the props, 3216 * error out. 3217 */ 3218 if ((zplver < ZPL_VERSION_INITIAL || zplver > ZPL_VERSION) || 3219 (zplver >= ZPL_VERSION_FUID && !fuids_ok) || 3220 (zplver >= ZPL_VERSION_SA && !sa_ok) || 3221 (zplver < ZPL_VERSION_NORMALIZATION && 3222 (norm != ZFS_PROP_UNDEFINED || u8 != ZFS_PROP_UNDEFINED || 3223 sense != ZFS_PROP_UNDEFINED))) 3224 return (SET_ERROR(ENOTSUP)); 3225 3226 /* 3227 * Put the version in the zplprops 3228 */ 3229 VERIFY(nvlist_add_uint64(zplprops, 3230 zfs_prop_to_name(ZFS_PROP_VERSION), zplver) == 0); 3231 3232 if (norm == ZFS_PROP_UNDEFINED && 3233 (error = zfs_get_zplprop(os, ZFS_PROP_NORMALIZE, &norm)) != 0) 3234 return (error); 3235 VERIFY(nvlist_add_uint64(zplprops, 3236 zfs_prop_to_name(ZFS_PROP_NORMALIZE), norm) == 0); 3237 3238 /* 3239 * If we're normalizing, names must always be valid UTF-8 strings. 3240 */ 3241 if (norm) 3242 u8 = 1; 3243 if (u8 == ZFS_PROP_UNDEFINED && 3244 (error = zfs_get_zplprop(os, ZFS_PROP_UTF8ONLY, &u8)) != 0) 3245 return (error); 3246 VERIFY(nvlist_add_uint64(zplprops, 3247 zfs_prop_to_name(ZFS_PROP_UTF8ONLY), u8) == 0); 3248 3249 if (sense == ZFS_PROP_UNDEFINED && 3250 (error = zfs_get_zplprop(os, ZFS_PROP_CASE, &sense)) != 0) 3251 return (error); 3252 VERIFY(nvlist_add_uint64(zplprops, 3253 zfs_prop_to_name(ZFS_PROP_CASE), sense) == 0); 3254 3255 if (is_ci) 3256 *is_ci = (sense == ZFS_CASE_INSENSITIVE); 3257 3258 return (0); 3259 } 3260 3261 static int 3262 zfs_fill_zplprops(const char *dataset, nvlist_t *createprops, 3263 nvlist_t *zplprops, boolean_t *is_ci) 3264 { 3265 boolean_t fuids_ok, sa_ok; 3266 uint64_t zplver = ZPL_VERSION; 3267 objset_t *os = NULL; 3268 char parentname[ZFS_MAX_DATASET_NAME_LEN]; 3269 spa_t *spa; 3270 uint64_t spa_vers; 3271 int error; 3272 3273 zfs_get_parent(dataset, parentname, sizeof (parentname)); 3274 3275 if ((error = spa_open(dataset, &spa, FTAG)) != 0) 3276 return (error); 3277 3278 spa_vers = spa_version(spa); 3279 spa_close(spa, FTAG); 3280 3281 zplver = zfs_zpl_version_map(spa_vers); 3282 fuids_ok = (zplver >= ZPL_VERSION_FUID); 3283 sa_ok = (zplver >= ZPL_VERSION_SA); 3284 3285 /* 3286 * Open parent object set so we can inherit zplprop values. 3287 */ 3288 if ((error = dmu_objset_hold(parentname, FTAG, &os)) != 0) 3289 return (error); 3290 3291 error = zfs_fill_zplprops_impl(os, zplver, fuids_ok, sa_ok, createprops, 3292 zplprops, is_ci); 3293 dmu_objset_rele(os, FTAG); 3294 return (error); 3295 } 3296 3297 static int 3298 zfs_fill_zplprops_root(uint64_t spa_vers, nvlist_t *createprops, 3299 nvlist_t *zplprops, boolean_t *is_ci) 3300 { 3301 boolean_t fuids_ok; 3302 boolean_t sa_ok; 3303 uint64_t zplver = ZPL_VERSION; 3304 int error; 3305 3306 zplver = zfs_zpl_version_map(spa_vers); 3307 fuids_ok = (zplver >= ZPL_VERSION_FUID); 3308 sa_ok = (zplver >= ZPL_VERSION_SA); 3309 3310 error = zfs_fill_zplprops_impl(NULL, zplver, fuids_ok, sa_ok, 3311 createprops, zplprops, is_ci); 3312 return (error); 3313 } 3314 3315 /* 3316 * innvl: { 3317 * "type" -> dmu_objset_type_t (int32) 3318 * (optional) "props" -> { prop -> value } 3319 * (optional) "hidden_args" -> { "wkeydata" -> value } 3320 * raw uint8_t array of encryption wrapping key data (32 bytes) 3321 * } 3322 * 3323 * outnvl: propname -> error code (int32) 3324 */ 3325 3326 static const zfs_ioc_key_t zfs_keys_create[] = { 3327 {"type", DATA_TYPE_INT32, 0}, 3328 {"props", DATA_TYPE_NVLIST, ZK_OPTIONAL}, 3329 {"hidden_args", DATA_TYPE_NVLIST, ZK_OPTIONAL}, 3330 }; 3331 3332 static int 3333 zfs_ioc_create(const char *fsname, nvlist_t *innvl, nvlist_t *outnvl) 3334 { 3335 int error = 0; 3336 zfs_creat_t zct = { 0 }; 3337 nvlist_t *nvprops = NULL; 3338 nvlist_t *hidden_args = NULL; 3339 void (*cbfunc)(objset_t *os, void *arg, cred_t *cr, dmu_tx_t *tx); 3340 dmu_objset_type_t type; 3341 boolean_t is_insensitive = B_FALSE; 3342 dsl_crypto_params_t *dcp = NULL; 3343 3344 type = (dmu_objset_type_t)fnvlist_lookup_int32(innvl, "type"); 3345 (void) nvlist_lookup_nvlist(innvl, "props", &nvprops); 3346 (void) nvlist_lookup_nvlist(innvl, ZPOOL_HIDDEN_ARGS, &hidden_args); 3347 3348 switch (type) { 3349 case DMU_OST_ZFS: 3350 cbfunc = zfs_create_cb; 3351 break; 3352 3353 case DMU_OST_ZVOL: 3354 cbfunc = zvol_create_cb; 3355 break; 3356 3357 default: 3358 cbfunc = NULL; 3359 break; 3360 } 3361 if (strchr(fsname, '@') || 3362 strchr(fsname, '%')) 3363 return (SET_ERROR(EINVAL)); 3364 3365 zct.zct_props = nvprops; 3366 3367 if (cbfunc == NULL) 3368 return (SET_ERROR(EINVAL)); 3369 3370 if (type == DMU_OST_ZVOL) { 3371 uint64_t volsize, volblocksize; 3372 3373 if (nvprops == NULL) 3374 return (SET_ERROR(EINVAL)); 3375 if (nvlist_lookup_uint64(nvprops, 3376 zfs_prop_to_name(ZFS_PROP_VOLSIZE), &volsize) != 0) 3377 return (SET_ERROR(EINVAL)); 3378 3379 if ((error = nvlist_lookup_uint64(nvprops, 3380 zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE), 3381 &volblocksize)) != 0 && error != ENOENT) 3382 return (SET_ERROR(EINVAL)); 3383 3384 if (error != 0) 3385 volblocksize = zfs_prop_default_numeric( 3386 ZFS_PROP_VOLBLOCKSIZE); 3387 3388 if ((error = zvol_check_volblocksize(fsname, 3389 volblocksize)) != 0 || 3390 (error = zvol_check_volsize(volsize, 3391 volblocksize)) != 0) 3392 return (error); 3393 } else if (type == DMU_OST_ZFS) { 3394 int error; 3395 3396 /* 3397 * We have to have normalization and 3398 * case-folding flags correct when we do the 3399 * file system creation, so go figure them out 3400 * now. 3401 */ 3402 VERIFY(nvlist_alloc(&zct.zct_zplprops, 3403 NV_UNIQUE_NAME, KM_SLEEP) == 0); 3404 error = zfs_fill_zplprops(fsname, nvprops, 3405 zct.zct_zplprops, &is_insensitive); 3406 if (error != 0) { 3407 nvlist_free(zct.zct_zplprops); 3408 return (error); 3409 } 3410 } 3411 3412 error = dsl_crypto_params_create_nvlist(DCP_CMD_NONE, nvprops, 3413 hidden_args, &dcp); 3414 if (error != 0) { 3415 nvlist_free(zct.zct_zplprops); 3416 return (error); 3417 } 3418 3419 error = dmu_objset_create(fsname, type, 3420 is_insensitive ? DS_FLAG_CI_DATASET : 0, dcp, cbfunc, &zct); 3421 3422 nvlist_free(zct.zct_zplprops); 3423 dsl_crypto_params_free(dcp, !!error); 3424 3425 /* 3426 * It would be nice to do this atomically. 3427 */ 3428 if (error == 0) { 3429 error = zfs_set_prop_nvlist(fsname, ZPROP_SRC_LOCAL, 3430 nvprops, outnvl); 3431 if (error != 0) { 3432 spa_t *spa; 3433 int error2; 3434 3435 /* 3436 * Volumes will return EBUSY and cannot be destroyed 3437 * until all asynchronous minor handling (e.g. from 3438 * setting the volmode property) has completed. Wait for 3439 * the spa_zvol_taskq to drain then retry. 3440 */ 3441 error2 = dsl_destroy_head(fsname); 3442 while ((error2 == EBUSY) && (type == DMU_OST_ZVOL)) { 3443 error2 = spa_open(fsname, &spa, FTAG); 3444 if (error2 == 0) { 3445 taskq_wait(spa->spa_zvol_taskq); 3446 spa_close(spa, FTAG); 3447 } 3448 error2 = dsl_destroy_head(fsname); 3449 } 3450 } 3451 } 3452 return (error); 3453 } 3454 3455 /* 3456 * innvl: { 3457 * "origin" -> name of origin snapshot 3458 * (optional) "props" -> { prop -> value } 3459 * (optional) "hidden_args" -> { "wkeydata" -> value } 3460 * raw uint8_t array of encryption wrapping key data (32 bytes) 3461 * } 3462 * 3463 * outputs: 3464 * outnvl: propname -> error code (int32) 3465 */ 3466 static const zfs_ioc_key_t zfs_keys_clone[] = { 3467 {"origin", DATA_TYPE_STRING, 0}, 3468 {"props", DATA_TYPE_NVLIST, ZK_OPTIONAL}, 3469 {"hidden_args", DATA_TYPE_NVLIST, ZK_OPTIONAL}, 3470 }; 3471 3472 static int 3473 zfs_ioc_clone(const char *fsname, nvlist_t *innvl, nvlist_t *outnvl) 3474 { 3475 int error = 0; 3476 nvlist_t *nvprops = NULL; 3477 const char *origin_name; 3478 3479 origin_name = fnvlist_lookup_string(innvl, "origin"); 3480 (void) nvlist_lookup_nvlist(innvl, "props", &nvprops); 3481 3482 if (strchr(fsname, '@') || 3483 strchr(fsname, '%')) 3484 return (SET_ERROR(EINVAL)); 3485 3486 if (dataset_namecheck(origin_name, NULL, NULL) != 0) 3487 return (SET_ERROR(EINVAL)); 3488 3489 error = dmu_objset_clone(fsname, origin_name); 3490 3491 /* 3492 * It would be nice to do this atomically. 3493 */ 3494 if (error == 0) { 3495 error = zfs_set_prop_nvlist(fsname, ZPROP_SRC_LOCAL, 3496 nvprops, outnvl); 3497 if (error != 0) 3498 (void) dsl_destroy_head(fsname); 3499 } 3500 return (error); 3501 } 3502 3503 static const zfs_ioc_key_t zfs_keys_remap[] = { 3504 /* no nvl keys */ 3505 }; 3506 3507 /* ARGSUSED */ 3508 static int 3509 zfs_ioc_remap(const char *fsname, nvlist_t *innvl, nvlist_t *outnvl) 3510 { 3511 /* This IOCTL is no longer supported. */ 3512 return (0); 3513 } 3514 3515 /* 3516 * innvl: { 3517 * "snaps" -> { snapshot1, snapshot2 } 3518 * (optional) "props" -> { prop -> value (string) } 3519 * } 3520 * 3521 * outnvl: snapshot -> error code (int32) 3522 */ 3523 static const zfs_ioc_key_t zfs_keys_snapshot[] = { 3524 {"snaps", DATA_TYPE_NVLIST, 0}, 3525 {"props", DATA_TYPE_NVLIST, ZK_OPTIONAL}, 3526 }; 3527 3528 static int 3529 zfs_ioc_snapshot(const char *poolname, nvlist_t *innvl, nvlist_t *outnvl) 3530 { 3531 nvlist_t *snaps; 3532 nvlist_t *props = NULL; 3533 int error, poollen; 3534 nvpair_t *pair; 3535 3536 (void) nvlist_lookup_nvlist(innvl, "props", &props); 3537 if (!nvlist_empty(props) && 3538 zfs_earlier_version(poolname, SPA_VERSION_SNAP_PROPS)) 3539 return (SET_ERROR(ENOTSUP)); 3540 if ((error = zfs_check_userprops(props)) != 0) 3541 return (error); 3542 3543 snaps = fnvlist_lookup_nvlist(innvl, "snaps"); 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 char *cp = strchr(name, '@'); 3549 3550 /* 3551 * The snap name must contain an @, and the part after it must 3552 * contain only valid characters. 3553 */ 3554 if (cp == NULL || 3555 zfs_component_namecheck(cp + 1, NULL, NULL) != 0) 3556 return (SET_ERROR(EINVAL)); 3557 3558 /* 3559 * The snap must be in the specified pool. 3560 */ 3561 if (strncmp(name, poolname, poollen) != 0 || 3562 (name[poollen] != '/' && name[poollen] != '@')) 3563 return (SET_ERROR(EXDEV)); 3564 3565 /* 3566 * Check for permission to set the properties on the fs. 3567 */ 3568 if (!nvlist_empty(props)) { 3569 *cp = '\0'; 3570 error = zfs_secpolicy_write_perms(name, 3571 ZFS_DELEG_PERM_USERPROP, CRED()); 3572 *cp = '@'; 3573 if (error != 0) 3574 return (error); 3575 } 3576 3577 /* This must be the only snap of this fs. */ 3578 for (nvpair_t *pair2 = nvlist_next_nvpair(snaps, pair); 3579 pair2 != NULL; pair2 = nvlist_next_nvpair(snaps, pair2)) { 3580 if (strncmp(name, nvpair_name(pair2), cp - name + 1) 3581 == 0) { 3582 return (SET_ERROR(EXDEV)); 3583 } 3584 } 3585 } 3586 3587 error = dsl_dataset_snapshot(snaps, props, outnvl); 3588 3589 return (error); 3590 } 3591 3592 /* 3593 * innvl: "message" -> string 3594 */ 3595 static const zfs_ioc_key_t zfs_keys_log_history[] = { 3596 {"message", DATA_TYPE_STRING, 0}, 3597 }; 3598 3599 /* ARGSUSED */ 3600 static int 3601 zfs_ioc_log_history(const char *unused, nvlist_t *innvl, nvlist_t *outnvl) 3602 { 3603 const char *message; 3604 char *poolname; 3605 spa_t *spa; 3606 int error; 3607 3608 /* 3609 * The poolname in the ioctl is not set, we get it from the TSD, 3610 * which was set at the end of the last successful ioctl that allows 3611 * logging. The secpolicy func already checked that it is set. 3612 * Only one log ioctl is allowed after each successful ioctl, so 3613 * we clear the TSD here. 3614 */ 3615 poolname = tsd_get(zfs_allow_log_key); 3616 if (poolname == NULL) 3617 return (SET_ERROR(EINVAL)); 3618 (void) tsd_set(zfs_allow_log_key, NULL); 3619 error = spa_open(poolname, &spa, FTAG); 3620 kmem_strfree(poolname); 3621 if (error != 0) 3622 return (error); 3623 3624 message = fnvlist_lookup_string(innvl, "message"); 3625 3626 if (spa_version(spa) < SPA_VERSION_ZPOOL_HISTORY) { 3627 spa_close(spa, FTAG); 3628 return (SET_ERROR(ENOTSUP)); 3629 } 3630 3631 error = spa_history_log(spa, message); 3632 spa_close(spa, FTAG); 3633 return (error); 3634 } 3635 3636 /* 3637 * This ioctl is used to set the bootenv configuration on the current 3638 * pool. This configuration is stored in the second padding area of the label, 3639 * and it is used by the bootloader(s) to store the bootloader and/or system 3640 * specific data. 3641 * The data is stored as nvlist data stream, and is protected by 3642 * an embedded checksum. 3643 * The version can have two possible values: 3644 * VB_RAW: nvlist should have key GRUB_ENVMAP, value DATA_TYPE_STRING. 3645 * VB_NVLIST: nvlist with arbitrary <key, value> pairs. 3646 */ 3647 static const zfs_ioc_key_t zfs_keys_set_bootenv[] = { 3648 {"version", DATA_TYPE_UINT64, 0}, 3649 {"<keys>", DATA_TYPE_ANY, ZK_OPTIONAL | ZK_WILDCARDLIST}, 3650 }; 3651 3652 static int 3653 zfs_ioc_set_bootenv(const char *name, nvlist_t *innvl, nvlist_t *outnvl) 3654 { 3655 int error; 3656 spa_t *spa; 3657 3658 if ((error = spa_open(name, &spa, FTAG)) != 0) 3659 return (error); 3660 spa_vdev_state_enter(spa, SCL_ALL); 3661 error = vdev_label_write_bootenv(spa->spa_root_vdev, innvl); 3662 (void) spa_vdev_state_exit(spa, NULL, 0); 3663 spa_close(spa, FTAG); 3664 return (error); 3665 } 3666 3667 static const zfs_ioc_key_t zfs_keys_get_bootenv[] = { 3668 /* no nvl keys */ 3669 }; 3670 3671 static int 3672 zfs_ioc_get_bootenv(const char *name, nvlist_t *innvl, nvlist_t *outnvl) 3673 { 3674 spa_t *spa; 3675 int error; 3676 3677 if ((error = spa_open(name, &spa, FTAG)) != 0) 3678 return (error); 3679 spa_vdev_state_enter(spa, SCL_ALL); 3680 error = vdev_label_read_bootenv(spa->spa_root_vdev, outnvl); 3681 (void) spa_vdev_state_exit(spa, NULL, 0); 3682 spa_close(spa, FTAG); 3683 return (error); 3684 } 3685 3686 /* 3687 * The dp_config_rwlock must not be held when calling this, because the 3688 * unmount may need to write out data. 3689 * 3690 * This function is best-effort. Callers must deal gracefully if it 3691 * remains mounted (or is remounted after this call). 3692 * 3693 * Returns 0 if the argument is not a snapshot, or it is not currently a 3694 * filesystem, or we were able to unmount it. Returns error code otherwise. 3695 */ 3696 void 3697 zfs_unmount_snap(const char *snapname) 3698 { 3699 if (strchr(snapname, '@') == NULL) 3700 return; 3701 3702 (void) zfsctl_snapshot_unmount(snapname, MNT_FORCE); 3703 } 3704 3705 /* ARGSUSED */ 3706 static int 3707 zfs_unmount_snap_cb(const char *snapname, void *arg) 3708 { 3709 zfs_unmount_snap(snapname); 3710 return (0); 3711 } 3712 3713 /* 3714 * When a clone is destroyed, its origin may also need to be destroyed, 3715 * in which case it must be unmounted. This routine will do that unmount 3716 * if necessary. 3717 */ 3718 void 3719 zfs_destroy_unmount_origin(const char *fsname) 3720 { 3721 int error; 3722 objset_t *os; 3723 dsl_dataset_t *ds; 3724 3725 error = dmu_objset_hold(fsname, FTAG, &os); 3726 if (error != 0) 3727 return; 3728 ds = dmu_objset_ds(os); 3729 if (dsl_dir_is_clone(ds->ds_dir) && DS_IS_DEFER_DESTROY(ds->ds_prev)) { 3730 char originname[ZFS_MAX_DATASET_NAME_LEN]; 3731 dsl_dataset_name(ds->ds_prev, originname); 3732 dmu_objset_rele(os, FTAG); 3733 zfs_unmount_snap(originname); 3734 } else { 3735 dmu_objset_rele(os, FTAG); 3736 } 3737 } 3738 3739 /* 3740 * innvl: { 3741 * "snaps" -> { snapshot1, snapshot2 } 3742 * (optional boolean) "defer" 3743 * } 3744 * 3745 * outnvl: snapshot -> error code (int32) 3746 */ 3747 static const zfs_ioc_key_t zfs_keys_destroy_snaps[] = { 3748 {"snaps", DATA_TYPE_NVLIST, 0}, 3749 {"defer", DATA_TYPE_BOOLEAN, ZK_OPTIONAL}, 3750 }; 3751 3752 /* ARGSUSED */ 3753 static int 3754 zfs_ioc_destroy_snaps(const char *poolname, nvlist_t *innvl, nvlist_t *outnvl) 3755 { 3756 int poollen; 3757 nvlist_t *snaps; 3758 nvpair_t *pair; 3759 boolean_t defer; 3760 spa_t *spa; 3761 3762 snaps = fnvlist_lookup_nvlist(innvl, "snaps"); 3763 defer = nvlist_exists(innvl, "defer"); 3764 3765 poollen = strlen(poolname); 3766 for (pair = nvlist_next_nvpair(snaps, NULL); pair != NULL; 3767 pair = nvlist_next_nvpair(snaps, pair)) { 3768 const char *name = nvpair_name(pair); 3769 3770 /* 3771 * The snap must be in the specified pool to prevent the 3772 * invalid removal of zvol minors below. 3773 */ 3774 if (strncmp(name, poolname, poollen) != 0 || 3775 (name[poollen] != '/' && name[poollen] != '@')) 3776 return (SET_ERROR(EXDEV)); 3777 3778 zfs_unmount_snap(nvpair_name(pair)); 3779 if (spa_open(name, &spa, FTAG) == 0) { 3780 zvol_remove_minors(spa, name, B_TRUE); 3781 spa_close(spa, FTAG); 3782 } 3783 } 3784 3785 return (dsl_destroy_snapshots_nvl(snaps, defer, outnvl)); 3786 } 3787 3788 /* 3789 * Create bookmarks. The bookmark names are of the form <fs>#<bmark>. 3790 * All bookmarks and snapshots must be in the same pool. 3791 * dsl_bookmark_create_nvl_validate describes the nvlist schema in more detail. 3792 * 3793 * innvl: { 3794 * new_bookmark1 -> existing_snapshot, 3795 * new_bookmark2 -> existing_bookmark, 3796 * } 3797 * 3798 * outnvl: bookmark -> error code (int32) 3799 * 3800 */ 3801 static const zfs_ioc_key_t zfs_keys_bookmark[] = { 3802 {"<bookmark>...", DATA_TYPE_STRING, ZK_WILDCARDLIST}, 3803 }; 3804 3805 /* ARGSUSED */ 3806 static int 3807 zfs_ioc_bookmark(const char *poolname, nvlist_t *innvl, nvlist_t *outnvl) 3808 { 3809 return (dsl_bookmark_create(innvl, outnvl)); 3810 } 3811 3812 /* 3813 * innvl: { 3814 * property 1, property 2, ... 3815 * } 3816 * 3817 * outnvl: { 3818 * bookmark name 1 -> { property 1, property 2, ... }, 3819 * bookmark name 2 -> { property 1, property 2, ... } 3820 * } 3821 * 3822 */ 3823 static const zfs_ioc_key_t zfs_keys_get_bookmarks[] = { 3824 {"<property>...", DATA_TYPE_BOOLEAN, ZK_WILDCARDLIST | ZK_OPTIONAL}, 3825 }; 3826 3827 static int 3828 zfs_ioc_get_bookmarks(const char *fsname, nvlist_t *innvl, nvlist_t *outnvl) 3829 { 3830 return (dsl_get_bookmarks(fsname, innvl, outnvl)); 3831 } 3832 3833 /* 3834 * innvl is not used. 3835 * 3836 * outnvl: { 3837 * property 1, property 2, ... 3838 * } 3839 * 3840 */ 3841 static const zfs_ioc_key_t zfs_keys_get_bookmark_props[] = { 3842 /* no nvl keys */ 3843 }; 3844 3845 /* ARGSUSED */ 3846 static int 3847 zfs_ioc_get_bookmark_props(const char *bookmark, nvlist_t *innvl, 3848 nvlist_t *outnvl) 3849 { 3850 char fsname[ZFS_MAX_DATASET_NAME_LEN]; 3851 char *bmname; 3852 3853 bmname = strchr(bookmark, '#'); 3854 if (bmname == NULL) 3855 return (SET_ERROR(EINVAL)); 3856 bmname++; 3857 3858 (void) strlcpy(fsname, bookmark, sizeof (fsname)); 3859 *(strchr(fsname, '#')) = '\0'; 3860 3861 return (dsl_get_bookmark_props(fsname, bmname, outnvl)); 3862 } 3863 3864 /* 3865 * innvl: { 3866 * bookmark name 1, bookmark name 2 3867 * } 3868 * 3869 * outnvl: bookmark -> error code (int32) 3870 * 3871 */ 3872 static const zfs_ioc_key_t zfs_keys_destroy_bookmarks[] = { 3873 {"<bookmark>...", DATA_TYPE_BOOLEAN, ZK_WILDCARDLIST}, 3874 }; 3875 3876 static int 3877 zfs_ioc_destroy_bookmarks(const char *poolname, nvlist_t *innvl, 3878 nvlist_t *outnvl) 3879 { 3880 int error, poollen; 3881 3882 poollen = strlen(poolname); 3883 for (nvpair_t *pair = nvlist_next_nvpair(innvl, NULL); 3884 pair != NULL; pair = nvlist_next_nvpair(innvl, pair)) { 3885 const char *name = nvpair_name(pair); 3886 const char *cp = strchr(name, '#'); 3887 3888 /* 3889 * The bookmark name must contain an #, and the part after it 3890 * must contain only valid characters. 3891 */ 3892 if (cp == NULL || 3893 zfs_component_namecheck(cp + 1, NULL, NULL) != 0) 3894 return (SET_ERROR(EINVAL)); 3895 3896 /* 3897 * The bookmark must be in the specified pool. 3898 */ 3899 if (strncmp(name, poolname, poollen) != 0 || 3900 (name[poollen] != '/' && name[poollen] != '#')) 3901 return (SET_ERROR(EXDEV)); 3902 } 3903 3904 error = dsl_bookmark_destroy(innvl, outnvl); 3905 return (error); 3906 } 3907 3908 static const zfs_ioc_key_t zfs_keys_channel_program[] = { 3909 {"program", DATA_TYPE_STRING, 0}, 3910 {"arg", DATA_TYPE_ANY, 0}, 3911 {"sync", DATA_TYPE_BOOLEAN_VALUE, ZK_OPTIONAL}, 3912 {"instrlimit", DATA_TYPE_UINT64, ZK_OPTIONAL}, 3913 {"memlimit", DATA_TYPE_UINT64, ZK_OPTIONAL}, 3914 }; 3915 3916 static int 3917 zfs_ioc_channel_program(const char *poolname, nvlist_t *innvl, 3918 nvlist_t *outnvl) 3919 { 3920 char *program; 3921 uint64_t instrlimit, memlimit; 3922 boolean_t sync_flag; 3923 nvpair_t *nvarg = NULL; 3924 3925 program = fnvlist_lookup_string(innvl, ZCP_ARG_PROGRAM); 3926 if (0 != nvlist_lookup_boolean_value(innvl, ZCP_ARG_SYNC, &sync_flag)) { 3927 sync_flag = B_TRUE; 3928 } 3929 if (0 != nvlist_lookup_uint64(innvl, ZCP_ARG_INSTRLIMIT, &instrlimit)) { 3930 instrlimit = ZCP_DEFAULT_INSTRLIMIT; 3931 } 3932 if (0 != nvlist_lookup_uint64(innvl, ZCP_ARG_MEMLIMIT, &memlimit)) { 3933 memlimit = ZCP_DEFAULT_MEMLIMIT; 3934 } 3935 nvarg = fnvlist_lookup_nvpair(innvl, ZCP_ARG_ARGLIST); 3936 3937 if (instrlimit == 0 || instrlimit > zfs_lua_max_instrlimit) 3938 return (SET_ERROR(EINVAL)); 3939 if (memlimit == 0 || memlimit > zfs_lua_max_memlimit) 3940 return (SET_ERROR(EINVAL)); 3941 3942 return (zcp_eval(poolname, program, sync_flag, instrlimit, memlimit, 3943 nvarg, outnvl)); 3944 } 3945 3946 /* 3947 * innvl: unused 3948 * outnvl: empty 3949 */ 3950 static const zfs_ioc_key_t zfs_keys_pool_checkpoint[] = { 3951 /* no nvl keys */ 3952 }; 3953 3954 /* ARGSUSED */ 3955 static int 3956 zfs_ioc_pool_checkpoint(const char *poolname, nvlist_t *innvl, nvlist_t *outnvl) 3957 { 3958 return (spa_checkpoint(poolname)); 3959 } 3960 3961 /* 3962 * innvl: unused 3963 * outnvl: empty 3964 */ 3965 static const zfs_ioc_key_t zfs_keys_pool_discard_checkpoint[] = { 3966 /* no nvl keys */ 3967 }; 3968 3969 /* ARGSUSED */ 3970 static int 3971 zfs_ioc_pool_discard_checkpoint(const char *poolname, nvlist_t *innvl, 3972 nvlist_t *outnvl) 3973 { 3974 return (spa_checkpoint_discard(poolname)); 3975 } 3976 3977 /* 3978 * inputs: 3979 * zc_name name of dataset to destroy 3980 * zc_defer_destroy mark for deferred destroy 3981 * 3982 * outputs: none 3983 */ 3984 static int 3985 zfs_ioc_destroy(zfs_cmd_t *zc) 3986 { 3987 objset_t *os; 3988 dmu_objset_type_t ost; 3989 int err; 3990 3991 err = dmu_objset_hold(zc->zc_name, FTAG, &os); 3992 if (err != 0) 3993 return (err); 3994 ost = dmu_objset_type(os); 3995 dmu_objset_rele(os, FTAG); 3996 3997 if (ost == DMU_OST_ZFS) 3998 zfs_unmount_snap(zc->zc_name); 3999 4000 if (strchr(zc->zc_name, '@')) { 4001 err = dsl_destroy_snapshot(zc->zc_name, zc->zc_defer_destroy); 4002 } else { 4003 err = dsl_destroy_head(zc->zc_name); 4004 if (err == EEXIST) { 4005 /* 4006 * It is possible that the given DS may have 4007 * hidden child (%recv) datasets - "leftovers" 4008 * resulting from the previously interrupted 4009 * 'zfs receive'. 4010 * 4011 * 6 extra bytes for /%recv 4012 */ 4013 char namebuf[ZFS_MAX_DATASET_NAME_LEN + 6]; 4014 4015 if (snprintf(namebuf, sizeof (namebuf), "%s/%s", 4016 zc->zc_name, recv_clone_name) >= 4017 sizeof (namebuf)) 4018 return (SET_ERROR(EINVAL)); 4019 4020 /* 4021 * Try to remove the hidden child (%recv) and after 4022 * that try to remove the target dataset. 4023 * If the hidden child (%recv) does not exist 4024 * the original error (EEXIST) will be returned 4025 */ 4026 err = dsl_destroy_head(namebuf); 4027 if (err == 0) 4028 err = dsl_destroy_head(zc->zc_name); 4029 else if (err == ENOENT) 4030 err = SET_ERROR(EEXIST); 4031 } 4032 } 4033 4034 return (err); 4035 } 4036 4037 /* 4038 * innvl: { 4039 * "initialize_command" -> POOL_INITIALIZE_{CANCEL|START|SUSPEND} (uint64) 4040 * "initialize_vdevs": { -> guids to initialize (nvlist) 4041 * "vdev_path_1": vdev_guid_1, (uint64), 4042 * "vdev_path_2": vdev_guid_2, (uint64), 4043 * ... 4044 * }, 4045 * } 4046 * 4047 * outnvl: { 4048 * "initialize_vdevs": { -> initialization errors (nvlist) 4049 * "vdev_path_1": errno, see function body for possible errnos (uint64) 4050 * "vdev_path_2": errno, ... (uint64) 4051 * ... 4052 * } 4053 * } 4054 * 4055 * EINVAL is returned for an unknown commands or if any of the provided vdev 4056 * guids have be specified with a type other than uint64. 4057 */ 4058 static const zfs_ioc_key_t zfs_keys_pool_initialize[] = { 4059 {ZPOOL_INITIALIZE_COMMAND, DATA_TYPE_UINT64, 0}, 4060 {ZPOOL_INITIALIZE_VDEVS, DATA_TYPE_NVLIST, 0} 4061 }; 4062 4063 static int 4064 zfs_ioc_pool_initialize(const char *poolname, nvlist_t *innvl, nvlist_t *outnvl) 4065 { 4066 uint64_t cmd_type; 4067 if (nvlist_lookup_uint64(innvl, ZPOOL_INITIALIZE_COMMAND, 4068 &cmd_type) != 0) { 4069 return (SET_ERROR(EINVAL)); 4070 } 4071 4072 if (!(cmd_type == POOL_INITIALIZE_CANCEL || 4073 cmd_type == POOL_INITIALIZE_START || 4074 cmd_type == POOL_INITIALIZE_SUSPEND)) { 4075 return (SET_ERROR(EINVAL)); 4076 } 4077 4078 nvlist_t *vdev_guids; 4079 if (nvlist_lookup_nvlist(innvl, ZPOOL_INITIALIZE_VDEVS, 4080 &vdev_guids) != 0) { 4081 return (SET_ERROR(EINVAL)); 4082 } 4083 4084 for (nvpair_t *pair = nvlist_next_nvpair(vdev_guids, NULL); 4085 pair != NULL; pair = nvlist_next_nvpair(vdev_guids, pair)) { 4086 uint64_t vdev_guid; 4087 if (nvpair_value_uint64(pair, &vdev_guid) != 0) { 4088 return (SET_ERROR(EINVAL)); 4089 } 4090 } 4091 4092 spa_t *spa; 4093 int error = spa_open(poolname, &spa, FTAG); 4094 if (error != 0) 4095 return (error); 4096 4097 nvlist_t *vdev_errlist = fnvlist_alloc(); 4098 int total_errors = spa_vdev_initialize(spa, vdev_guids, cmd_type, 4099 vdev_errlist); 4100 4101 if (fnvlist_size(vdev_errlist) > 0) { 4102 fnvlist_add_nvlist(outnvl, ZPOOL_INITIALIZE_VDEVS, 4103 vdev_errlist); 4104 } 4105 fnvlist_free(vdev_errlist); 4106 4107 spa_close(spa, FTAG); 4108 return (total_errors > 0 ? SET_ERROR(EINVAL) : 0); 4109 } 4110 4111 /* 4112 * innvl: { 4113 * "trim_command" -> POOL_TRIM_{CANCEL|START|SUSPEND} (uint64) 4114 * "trim_vdevs": { -> guids to TRIM (nvlist) 4115 * "vdev_path_1": vdev_guid_1, (uint64), 4116 * "vdev_path_2": vdev_guid_2, (uint64), 4117 * ... 4118 * }, 4119 * "trim_rate" -> Target TRIM rate in bytes/sec. 4120 * "trim_secure" -> Set to request a secure TRIM. 4121 * } 4122 * 4123 * outnvl: { 4124 * "trim_vdevs": { -> TRIM errors (nvlist) 4125 * "vdev_path_1": errno, see function body for possible errnos (uint64) 4126 * "vdev_path_2": errno, ... (uint64) 4127 * ... 4128 * } 4129 * } 4130 * 4131 * EINVAL is returned for an unknown commands or if any of the provided vdev 4132 * guids have be specified with a type other than uint64. 4133 */ 4134 static const zfs_ioc_key_t zfs_keys_pool_trim[] = { 4135 {ZPOOL_TRIM_COMMAND, DATA_TYPE_UINT64, 0}, 4136 {ZPOOL_TRIM_VDEVS, DATA_TYPE_NVLIST, 0}, 4137 {ZPOOL_TRIM_RATE, DATA_TYPE_UINT64, ZK_OPTIONAL}, 4138 {ZPOOL_TRIM_SECURE, DATA_TYPE_BOOLEAN_VALUE, ZK_OPTIONAL}, 4139 }; 4140 4141 static int 4142 zfs_ioc_pool_trim(const char *poolname, nvlist_t *innvl, nvlist_t *outnvl) 4143 { 4144 uint64_t cmd_type; 4145 if (nvlist_lookup_uint64(innvl, ZPOOL_TRIM_COMMAND, &cmd_type) != 0) 4146 return (SET_ERROR(EINVAL)); 4147 4148 if (!(cmd_type == POOL_TRIM_CANCEL || 4149 cmd_type == POOL_TRIM_START || 4150 cmd_type == POOL_TRIM_SUSPEND)) { 4151 return (SET_ERROR(EINVAL)); 4152 } 4153 4154 nvlist_t *vdev_guids; 4155 if (nvlist_lookup_nvlist(innvl, ZPOOL_TRIM_VDEVS, &vdev_guids) != 0) 4156 return (SET_ERROR(EINVAL)); 4157 4158 for (nvpair_t *pair = nvlist_next_nvpair(vdev_guids, NULL); 4159 pair != NULL; pair = nvlist_next_nvpair(vdev_guids, pair)) { 4160 uint64_t vdev_guid; 4161 if (nvpair_value_uint64(pair, &vdev_guid) != 0) { 4162 return (SET_ERROR(EINVAL)); 4163 } 4164 } 4165 4166 /* Optional, defaults to maximum rate when not provided */ 4167 uint64_t rate; 4168 if (nvlist_lookup_uint64(innvl, ZPOOL_TRIM_RATE, &rate) != 0) 4169 rate = 0; 4170 4171 /* Optional, defaults to standard TRIM when not provided */ 4172 boolean_t secure; 4173 if (nvlist_lookup_boolean_value(innvl, ZPOOL_TRIM_SECURE, 4174 &secure) != 0) { 4175 secure = B_FALSE; 4176 } 4177 4178 spa_t *spa; 4179 int error = spa_open(poolname, &spa, FTAG); 4180 if (error != 0) 4181 return (error); 4182 4183 nvlist_t *vdev_errlist = fnvlist_alloc(); 4184 int total_errors = spa_vdev_trim(spa, vdev_guids, cmd_type, 4185 rate, !!zfs_trim_metaslab_skip, secure, vdev_errlist); 4186 4187 if (fnvlist_size(vdev_errlist) > 0) 4188 fnvlist_add_nvlist(outnvl, ZPOOL_TRIM_VDEVS, vdev_errlist); 4189 4190 fnvlist_free(vdev_errlist); 4191 4192 spa_close(spa, FTAG); 4193 return (total_errors > 0 ? SET_ERROR(EINVAL) : 0); 4194 } 4195 4196 /* 4197 * This ioctl waits for activity of a particular type to complete. If there is 4198 * no activity of that type in progress, it returns immediately, and the 4199 * returned value "waited" is false. If there is activity in progress, and no 4200 * tag is passed in, the ioctl blocks until all activity of that type is 4201 * complete, and then returns with "waited" set to true. 4202 * 4203 * If a tag is provided, it identifies a particular instance of an activity to 4204 * wait for. Currently, this is only valid for use with 'initialize', because 4205 * that is the only activity for which there can be multiple instances running 4206 * concurrently. In the case of 'initialize', the tag corresponds to the guid of 4207 * the vdev on which to wait. 4208 * 4209 * If a thread waiting in the ioctl receives a signal, the call will return 4210 * immediately, and the return value will be EINTR. 4211 * 4212 * innvl: { 4213 * "wait_activity" -> int32_t 4214 * (optional) "wait_tag" -> uint64_t 4215 * } 4216 * 4217 * outnvl: "waited" -> boolean_t 4218 */ 4219 static const zfs_ioc_key_t zfs_keys_pool_wait[] = { 4220 {ZPOOL_WAIT_ACTIVITY, DATA_TYPE_INT32, 0}, 4221 {ZPOOL_WAIT_TAG, DATA_TYPE_UINT64, ZK_OPTIONAL}, 4222 }; 4223 4224 static int 4225 zfs_ioc_wait(const char *name, nvlist_t *innvl, nvlist_t *outnvl) 4226 { 4227 int32_t activity; 4228 uint64_t tag; 4229 boolean_t waited; 4230 int error; 4231 4232 if (nvlist_lookup_int32(innvl, ZPOOL_WAIT_ACTIVITY, &activity) != 0) 4233 return (EINVAL); 4234 4235 if (nvlist_lookup_uint64(innvl, ZPOOL_WAIT_TAG, &tag) == 0) 4236 error = spa_wait_tag(name, activity, tag, &waited); 4237 else 4238 error = spa_wait(name, activity, &waited); 4239 4240 if (error == 0) 4241 fnvlist_add_boolean_value(outnvl, ZPOOL_WAIT_WAITED, waited); 4242 4243 return (error); 4244 } 4245 4246 /* 4247 * This ioctl waits for activity of a particular type to complete. If there is 4248 * no activity of that type in progress, it returns immediately, and the 4249 * returned value "waited" is false. If there is activity in progress, and no 4250 * tag is passed in, the ioctl blocks until all activity of that type is 4251 * complete, and then returns with "waited" set to true. 4252 * 4253 * If a thread waiting in the ioctl receives a signal, the call will return 4254 * immediately, and the return value will be EINTR. 4255 * 4256 * innvl: { 4257 * "wait_activity" -> int32_t 4258 * } 4259 * 4260 * outnvl: "waited" -> boolean_t 4261 */ 4262 static const zfs_ioc_key_t zfs_keys_fs_wait[] = { 4263 {ZFS_WAIT_ACTIVITY, DATA_TYPE_INT32, 0}, 4264 }; 4265 4266 static int 4267 zfs_ioc_wait_fs(const char *name, nvlist_t *innvl, nvlist_t *outnvl) 4268 { 4269 int32_t activity; 4270 boolean_t waited = B_FALSE; 4271 int error; 4272 dsl_pool_t *dp; 4273 dsl_dir_t *dd; 4274 dsl_dataset_t *ds; 4275 4276 if (nvlist_lookup_int32(innvl, ZFS_WAIT_ACTIVITY, &activity) != 0) 4277 return (SET_ERROR(EINVAL)); 4278 4279 if (activity >= ZFS_WAIT_NUM_ACTIVITIES || activity < 0) 4280 return (SET_ERROR(EINVAL)); 4281 4282 if ((error = dsl_pool_hold(name, FTAG, &dp)) != 0) 4283 return (error); 4284 4285 if ((error = dsl_dataset_hold(dp, name, FTAG, &ds)) != 0) { 4286 dsl_pool_rele(dp, FTAG); 4287 return (error); 4288 } 4289 4290 dd = ds->ds_dir; 4291 mutex_enter(&dd->dd_activity_lock); 4292 dd->dd_activity_waiters++; 4293 4294 /* 4295 * We get a long-hold here so that the dsl_dataset_t and dsl_dir_t 4296 * aren't evicted while we're waiting. Normally this is prevented by 4297 * holding the pool, but we can't do that while we're waiting since 4298 * that would prevent TXGs from syncing out. Some of the functionality 4299 * of long-holds (e.g. preventing deletion) is unnecessary for this 4300 * case, since we would cancel the waiters before proceeding with a 4301 * deletion. An alternative mechanism for keeping the dataset around 4302 * could be developed but this is simpler. 4303 */ 4304 dsl_dataset_long_hold(ds, FTAG); 4305 dsl_pool_rele(dp, FTAG); 4306 4307 error = dsl_dir_wait(dd, ds, activity, &waited); 4308 4309 dsl_dataset_long_rele(ds, FTAG); 4310 dd->dd_activity_waiters--; 4311 if (dd->dd_activity_waiters == 0) 4312 cv_signal(&dd->dd_activity_cv); 4313 mutex_exit(&dd->dd_activity_lock); 4314 4315 dsl_dataset_rele(ds, FTAG); 4316 4317 if (error == 0) 4318 fnvlist_add_boolean_value(outnvl, ZFS_WAIT_WAITED, waited); 4319 4320 return (error); 4321 } 4322 4323 /* 4324 * fsname is name of dataset to rollback (to most recent snapshot) 4325 * 4326 * innvl may contain name of expected target snapshot 4327 * 4328 * outnvl: "target" -> name of most recent snapshot 4329 * } 4330 */ 4331 static const zfs_ioc_key_t zfs_keys_rollback[] = { 4332 {"target", DATA_TYPE_STRING, ZK_OPTIONAL}, 4333 }; 4334 4335 /* ARGSUSED */ 4336 static int 4337 zfs_ioc_rollback(const char *fsname, nvlist_t *innvl, nvlist_t *outnvl) 4338 { 4339 zfsvfs_t *zfsvfs; 4340 zvol_state_handle_t *zv; 4341 char *target = NULL; 4342 int error; 4343 4344 (void) nvlist_lookup_string(innvl, "target", &target); 4345 if (target != NULL) { 4346 const char *cp = strchr(target, '@'); 4347 4348 /* 4349 * The snap name must contain an @, and the part after it must 4350 * contain only valid characters. 4351 */ 4352 if (cp == NULL || 4353 zfs_component_namecheck(cp + 1, NULL, NULL) != 0) 4354 return (SET_ERROR(EINVAL)); 4355 } 4356 4357 if (getzfsvfs(fsname, &zfsvfs) == 0) { 4358 dsl_dataset_t *ds; 4359 4360 ds = dmu_objset_ds(zfsvfs->z_os); 4361 error = zfs_suspend_fs(zfsvfs); 4362 if (error == 0) { 4363 int resume_err; 4364 4365 error = dsl_dataset_rollback(fsname, target, zfsvfs, 4366 outnvl); 4367 resume_err = zfs_resume_fs(zfsvfs, ds); 4368 error = error ? error : resume_err; 4369 } 4370 zfs_vfs_rele(zfsvfs); 4371 } else if ((zv = zvol_suspend(fsname)) != NULL) { 4372 error = dsl_dataset_rollback(fsname, target, zvol_tag(zv), 4373 outnvl); 4374 zvol_resume(zv); 4375 } else { 4376 error = dsl_dataset_rollback(fsname, target, NULL, outnvl); 4377 } 4378 return (error); 4379 } 4380 4381 static int 4382 recursive_unmount(const char *fsname, void *arg) 4383 { 4384 const char *snapname = arg; 4385 char *fullname; 4386 4387 fullname = kmem_asprintf("%s@%s", fsname, snapname); 4388 zfs_unmount_snap(fullname); 4389 kmem_strfree(fullname); 4390 4391 return (0); 4392 } 4393 4394 /* 4395 * 4396 * snapname is the snapshot to redact. 4397 * innvl: { 4398 * "bookname" -> (string) 4399 * shortname of the redaction bookmark to generate 4400 * "snapnv" -> (nvlist, values ignored) 4401 * snapshots to redact snapname with respect to 4402 * } 4403 * 4404 * outnvl is unused 4405 */ 4406 4407 /* ARGSUSED */ 4408 static const zfs_ioc_key_t zfs_keys_redact[] = { 4409 {"bookname", DATA_TYPE_STRING, 0}, 4410 {"snapnv", DATA_TYPE_NVLIST, 0}, 4411 }; 4412 static int 4413 zfs_ioc_redact(const char *snapname, nvlist_t *innvl, nvlist_t *outnvl) 4414 { 4415 nvlist_t *redactnvl = NULL; 4416 char *redactbook = NULL; 4417 4418 if (nvlist_lookup_nvlist(innvl, "snapnv", &redactnvl) != 0) 4419 return (SET_ERROR(EINVAL)); 4420 if (fnvlist_num_pairs(redactnvl) == 0) 4421 return (SET_ERROR(ENXIO)); 4422 if (nvlist_lookup_string(innvl, "bookname", &redactbook) != 0) 4423 return (SET_ERROR(EINVAL)); 4424 4425 return (dmu_redact_snap(snapname, redactnvl, redactbook)); 4426 } 4427 4428 /* 4429 * inputs: 4430 * zc_name old name of dataset 4431 * zc_value new name of dataset 4432 * zc_cookie recursive flag (only valid for snapshots) 4433 * 4434 * outputs: none 4435 */ 4436 static int 4437 zfs_ioc_rename(zfs_cmd_t *zc) 4438 { 4439 objset_t *os; 4440 dmu_objset_type_t ost; 4441 boolean_t recursive = zc->zc_cookie & 1; 4442 boolean_t nounmount = !!(zc->zc_cookie & 2); 4443 char *at; 4444 int err; 4445 4446 /* "zfs rename" from and to ...%recv datasets should both fail */ 4447 zc->zc_name[sizeof (zc->zc_name) - 1] = '\0'; 4448 zc->zc_value[sizeof (zc->zc_value) - 1] = '\0'; 4449 if (dataset_namecheck(zc->zc_name, NULL, NULL) != 0 || 4450 dataset_namecheck(zc->zc_value, NULL, NULL) != 0 || 4451 strchr(zc->zc_name, '%') || strchr(zc->zc_value, '%')) 4452 return (SET_ERROR(EINVAL)); 4453 4454 err = dmu_objset_hold(zc->zc_name, FTAG, &os); 4455 if (err != 0) 4456 return (err); 4457 ost = dmu_objset_type(os); 4458 dmu_objset_rele(os, FTAG); 4459 4460 at = strchr(zc->zc_name, '@'); 4461 if (at != NULL) { 4462 /* snaps must be in same fs */ 4463 int error; 4464 4465 if (strncmp(zc->zc_name, zc->zc_value, at - zc->zc_name + 1)) 4466 return (SET_ERROR(EXDEV)); 4467 *at = '\0'; 4468 if (ost == DMU_OST_ZFS && !nounmount) { 4469 error = dmu_objset_find(zc->zc_name, 4470 recursive_unmount, at + 1, 4471 recursive ? DS_FIND_CHILDREN : 0); 4472 if (error != 0) { 4473 *at = '@'; 4474 return (error); 4475 } 4476 } 4477 error = dsl_dataset_rename_snapshot(zc->zc_name, 4478 at + 1, strchr(zc->zc_value, '@') + 1, recursive); 4479 *at = '@'; 4480 4481 return (error); 4482 } else { 4483 return (dsl_dir_rename(zc->zc_name, zc->zc_value)); 4484 } 4485 } 4486 4487 static int 4488 zfs_check_settable(const char *dsname, nvpair_t *pair, cred_t *cr) 4489 { 4490 const char *propname = nvpair_name(pair); 4491 boolean_t issnap = (strchr(dsname, '@') != NULL); 4492 zfs_prop_t prop = zfs_name_to_prop(propname); 4493 uint64_t intval, compval; 4494 int err; 4495 4496 if (prop == ZPROP_INVAL) { 4497 if (zfs_prop_user(propname)) { 4498 if ((err = zfs_secpolicy_write_perms(dsname, 4499 ZFS_DELEG_PERM_USERPROP, cr))) 4500 return (err); 4501 return (0); 4502 } 4503 4504 if (!issnap && zfs_prop_userquota(propname)) { 4505 const char *perm = NULL; 4506 const char *uq_prefix = 4507 zfs_userquota_prop_prefixes[ZFS_PROP_USERQUOTA]; 4508 const char *gq_prefix = 4509 zfs_userquota_prop_prefixes[ZFS_PROP_GROUPQUOTA]; 4510 const char *uiq_prefix = 4511 zfs_userquota_prop_prefixes[ZFS_PROP_USEROBJQUOTA]; 4512 const char *giq_prefix = 4513 zfs_userquota_prop_prefixes[ZFS_PROP_GROUPOBJQUOTA]; 4514 const char *pq_prefix = 4515 zfs_userquota_prop_prefixes[ZFS_PROP_PROJECTQUOTA]; 4516 const char *piq_prefix = zfs_userquota_prop_prefixes[\ 4517 ZFS_PROP_PROJECTOBJQUOTA]; 4518 4519 if (strncmp(propname, uq_prefix, 4520 strlen(uq_prefix)) == 0) { 4521 perm = ZFS_DELEG_PERM_USERQUOTA; 4522 } else if (strncmp(propname, uiq_prefix, 4523 strlen(uiq_prefix)) == 0) { 4524 perm = ZFS_DELEG_PERM_USEROBJQUOTA; 4525 } else if (strncmp(propname, gq_prefix, 4526 strlen(gq_prefix)) == 0) { 4527 perm = ZFS_DELEG_PERM_GROUPQUOTA; 4528 } else if (strncmp(propname, giq_prefix, 4529 strlen(giq_prefix)) == 0) { 4530 perm = ZFS_DELEG_PERM_GROUPOBJQUOTA; 4531 } else if (strncmp(propname, pq_prefix, 4532 strlen(pq_prefix)) == 0) { 4533 perm = ZFS_DELEG_PERM_PROJECTQUOTA; 4534 } else if (strncmp(propname, piq_prefix, 4535 strlen(piq_prefix)) == 0) { 4536 perm = ZFS_DELEG_PERM_PROJECTOBJQUOTA; 4537 } else { 4538 /* {USER|GROUP|PROJECT}USED are read-only */ 4539 return (SET_ERROR(EINVAL)); 4540 } 4541 4542 if ((err = zfs_secpolicy_write_perms(dsname, perm, cr))) 4543 return (err); 4544 return (0); 4545 } 4546 4547 return (SET_ERROR(EINVAL)); 4548 } 4549 4550 if (issnap) 4551 return (SET_ERROR(EINVAL)); 4552 4553 if (nvpair_type(pair) == DATA_TYPE_NVLIST) { 4554 /* 4555 * dsl_prop_get_all_impl() returns properties in this 4556 * format. 4557 */ 4558 nvlist_t *attrs; 4559 VERIFY(nvpair_value_nvlist(pair, &attrs) == 0); 4560 VERIFY(nvlist_lookup_nvpair(attrs, ZPROP_VALUE, 4561 &pair) == 0); 4562 } 4563 4564 /* 4565 * Check that this value is valid for this pool version 4566 */ 4567 switch (prop) { 4568 case ZFS_PROP_COMPRESSION: 4569 /* 4570 * If the user specified gzip compression, make sure 4571 * the SPA supports it. We ignore any errors here since 4572 * we'll catch them later. 4573 */ 4574 if (nvpair_value_uint64(pair, &intval) == 0) { 4575 compval = ZIO_COMPRESS_ALGO(intval); 4576 if (compval >= ZIO_COMPRESS_GZIP_1 && 4577 compval <= ZIO_COMPRESS_GZIP_9 && 4578 zfs_earlier_version(dsname, 4579 SPA_VERSION_GZIP_COMPRESSION)) { 4580 return (SET_ERROR(ENOTSUP)); 4581 } 4582 4583 if (compval == ZIO_COMPRESS_ZLE && 4584 zfs_earlier_version(dsname, 4585 SPA_VERSION_ZLE_COMPRESSION)) 4586 return (SET_ERROR(ENOTSUP)); 4587 4588 if (compval == ZIO_COMPRESS_LZ4) { 4589 spa_t *spa; 4590 4591 if ((err = spa_open(dsname, &spa, FTAG)) != 0) 4592 return (err); 4593 4594 if (!spa_feature_is_enabled(spa, 4595 SPA_FEATURE_LZ4_COMPRESS)) { 4596 spa_close(spa, FTAG); 4597 return (SET_ERROR(ENOTSUP)); 4598 } 4599 spa_close(spa, FTAG); 4600 } 4601 4602 if (compval == ZIO_COMPRESS_ZSTD) { 4603 spa_t *spa; 4604 4605 if ((err = spa_open(dsname, &spa, FTAG)) != 0) 4606 return (err); 4607 4608 if (!spa_feature_is_enabled(spa, 4609 SPA_FEATURE_ZSTD_COMPRESS)) { 4610 spa_close(spa, FTAG); 4611 return (SET_ERROR(ENOTSUP)); 4612 } 4613 spa_close(spa, FTAG); 4614 } 4615 } 4616 break; 4617 4618 case ZFS_PROP_COPIES: 4619 if (zfs_earlier_version(dsname, SPA_VERSION_DITTO_BLOCKS)) 4620 return (SET_ERROR(ENOTSUP)); 4621 break; 4622 4623 case ZFS_PROP_VOLBLOCKSIZE: 4624 case ZFS_PROP_RECORDSIZE: 4625 /* Record sizes above 128k need the feature to be enabled */ 4626 if (nvpair_value_uint64(pair, &intval) == 0 && 4627 intval > SPA_OLD_MAXBLOCKSIZE) { 4628 spa_t *spa; 4629 4630 /* 4631 * We don't allow setting the property above 1MB, 4632 * unless the tunable has been changed. 4633 */ 4634 if (intval > zfs_max_recordsize || 4635 intval > SPA_MAXBLOCKSIZE) 4636 return (SET_ERROR(ERANGE)); 4637 4638 if ((err = spa_open(dsname, &spa, FTAG)) != 0) 4639 return (err); 4640 4641 if (!spa_feature_is_enabled(spa, 4642 SPA_FEATURE_LARGE_BLOCKS)) { 4643 spa_close(spa, FTAG); 4644 return (SET_ERROR(ENOTSUP)); 4645 } 4646 spa_close(spa, FTAG); 4647 } 4648 break; 4649 4650 case ZFS_PROP_DNODESIZE: 4651 /* Dnode sizes above 512 need the feature to be enabled */ 4652 if (nvpair_value_uint64(pair, &intval) == 0 && 4653 intval != ZFS_DNSIZE_LEGACY) { 4654 spa_t *spa; 4655 4656 if ((err = spa_open(dsname, &spa, FTAG)) != 0) 4657 return (err); 4658 4659 if (!spa_feature_is_enabled(spa, 4660 SPA_FEATURE_LARGE_DNODE)) { 4661 spa_close(spa, FTAG); 4662 return (SET_ERROR(ENOTSUP)); 4663 } 4664 spa_close(spa, FTAG); 4665 } 4666 break; 4667 4668 case ZFS_PROP_SPECIAL_SMALL_BLOCKS: 4669 /* 4670 * This property could require the allocation classes 4671 * feature to be active for setting, however we allow 4672 * it so that tests of settable properties succeed. 4673 * The CLI will issue a warning in this case. 4674 */ 4675 break; 4676 4677 case ZFS_PROP_SHARESMB: 4678 if (zpl_earlier_version(dsname, ZPL_VERSION_FUID)) 4679 return (SET_ERROR(ENOTSUP)); 4680 break; 4681 4682 case ZFS_PROP_ACLINHERIT: 4683 if (nvpair_type(pair) == DATA_TYPE_UINT64 && 4684 nvpair_value_uint64(pair, &intval) == 0) { 4685 if (intval == ZFS_ACL_PASSTHROUGH_X && 4686 zfs_earlier_version(dsname, 4687 SPA_VERSION_PASSTHROUGH_X)) 4688 return (SET_ERROR(ENOTSUP)); 4689 } 4690 break; 4691 case ZFS_PROP_CHECKSUM: 4692 case ZFS_PROP_DEDUP: 4693 { 4694 spa_feature_t feature; 4695 spa_t *spa; 4696 int err; 4697 4698 /* dedup feature version checks */ 4699 if (prop == ZFS_PROP_DEDUP && 4700 zfs_earlier_version(dsname, SPA_VERSION_DEDUP)) 4701 return (SET_ERROR(ENOTSUP)); 4702 4703 if (nvpair_type(pair) == DATA_TYPE_UINT64 && 4704 nvpair_value_uint64(pair, &intval) == 0) { 4705 /* check prop value is enabled in features */ 4706 feature = zio_checksum_to_feature( 4707 intval & ZIO_CHECKSUM_MASK); 4708 if (feature == SPA_FEATURE_NONE) 4709 break; 4710 4711 if ((err = spa_open(dsname, &spa, FTAG)) != 0) 4712 return (err); 4713 4714 if (!spa_feature_is_enabled(spa, feature)) { 4715 spa_close(spa, FTAG); 4716 return (SET_ERROR(ENOTSUP)); 4717 } 4718 spa_close(spa, FTAG); 4719 } 4720 break; 4721 } 4722 4723 default: 4724 break; 4725 } 4726 4727 return (zfs_secpolicy_setprop(dsname, prop, pair, CRED())); 4728 } 4729 4730 /* 4731 * Removes properties from the given props list that fail permission checks 4732 * needed to clear them and to restore them in case of a receive error. For each 4733 * property, make sure we have both set and inherit permissions. 4734 * 4735 * Returns the first error encountered if any permission checks fail. If the 4736 * caller provides a non-NULL errlist, it also gives the complete list of names 4737 * of all the properties that failed a permission check along with the 4738 * corresponding error numbers. The caller is responsible for freeing the 4739 * returned errlist. 4740 * 4741 * If every property checks out successfully, zero is returned and the list 4742 * pointed at by errlist is NULL. 4743 */ 4744 static int 4745 zfs_check_clearable(const char *dataset, nvlist_t *props, nvlist_t **errlist) 4746 { 4747 zfs_cmd_t *zc; 4748 nvpair_t *pair, *next_pair; 4749 nvlist_t *errors; 4750 int err, rv = 0; 4751 4752 if (props == NULL) 4753 return (0); 4754 4755 VERIFY(nvlist_alloc(&errors, NV_UNIQUE_NAME, KM_SLEEP) == 0); 4756 4757 zc = kmem_alloc(sizeof (zfs_cmd_t), KM_SLEEP); 4758 (void) strlcpy(zc->zc_name, dataset, sizeof (zc->zc_name)); 4759 pair = nvlist_next_nvpair(props, NULL); 4760 while (pair != NULL) { 4761 next_pair = nvlist_next_nvpair(props, pair); 4762 4763 (void) strlcpy(zc->zc_value, nvpair_name(pair), 4764 sizeof (zc->zc_value)); 4765 if ((err = zfs_check_settable(dataset, pair, CRED())) != 0 || 4766 (err = zfs_secpolicy_inherit_prop(zc, NULL, CRED())) != 0) { 4767 VERIFY(nvlist_remove_nvpair(props, pair) == 0); 4768 VERIFY(nvlist_add_int32(errors, 4769 zc->zc_value, err) == 0); 4770 } 4771 pair = next_pair; 4772 } 4773 kmem_free(zc, sizeof (zfs_cmd_t)); 4774 4775 if ((pair = nvlist_next_nvpair(errors, NULL)) == NULL) { 4776 nvlist_free(errors); 4777 errors = NULL; 4778 } else { 4779 VERIFY(nvpair_value_int32(pair, &rv) == 0); 4780 } 4781 4782 if (errlist == NULL) 4783 nvlist_free(errors); 4784 else 4785 *errlist = errors; 4786 4787 return (rv); 4788 } 4789 4790 static boolean_t 4791 propval_equals(nvpair_t *p1, nvpair_t *p2) 4792 { 4793 if (nvpair_type(p1) == DATA_TYPE_NVLIST) { 4794 /* dsl_prop_get_all_impl() format */ 4795 nvlist_t *attrs; 4796 VERIFY(nvpair_value_nvlist(p1, &attrs) == 0); 4797 VERIFY(nvlist_lookup_nvpair(attrs, ZPROP_VALUE, 4798 &p1) == 0); 4799 } 4800 4801 if (nvpair_type(p2) == DATA_TYPE_NVLIST) { 4802 nvlist_t *attrs; 4803 VERIFY(nvpair_value_nvlist(p2, &attrs) == 0); 4804 VERIFY(nvlist_lookup_nvpair(attrs, ZPROP_VALUE, 4805 &p2) == 0); 4806 } 4807 4808 if (nvpair_type(p1) != nvpair_type(p2)) 4809 return (B_FALSE); 4810 4811 if (nvpair_type(p1) == DATA_TYPE_STRING) { 4812 char *valstr1, *valstr2; 4813 4814 VERIFY(nvpair_value_string(p1, (char **)&valstr1) == 0); 4815 VERIFY(nvpair_value_string(p2, (char **)&valstr2) == 0); 4816 return (strcmp(valstr1, valstr2) == 0); 4817 } else { 4818 uint64_t intval1, intval2; 4819 4820 VERIFY(nvpair_value_uint64(p1, &intval1) == 0); 4821 VERIFY(nvpair_value_uint64(p2, &intval2) == 0); 4822 return (intval1 == intval2); 4823 } 4824 } 4825 4826 /* 4827 * Remove properties from props if they are not going to change (as determined 4828 * by comparison with origprops). Remove them from origprops as well, since we 4829 * do not need to clear or restore properties that won't change. 4830 */ 4831 static void 4832 props_reduce(nvlist_t *props, nvlist_t *origprops) 4833 { 4834 nvpair_t *pair, *next_pair; 4835 4836 if (origprops == NULL) 4837 return; /* all props need to be received */ 4838 4839 pair = nvlist_next_nvpair(props, NULL); 4840 while (pair != NULL) { 4841 const char *propname = nvpair_name(pair); 4842 nvpair_t *match; 4843 4844 next_pair = nvlist_next_nvpair(props, pair); 4845 4846 if ((nvlist_lookup_nvpair(origprops, propname, 4847 &match) != 0) || !propval_equals(pair, match)) 4848 goto next; /* need to set received value */ 4849 4850 /* don't clear the existing received value */ 4851 (void) nvlist_remove_nvpair(origprops, match); 4852 /* don't bother receiving the property */ 4853 (void) nvlist_remove_nvpair(props, pair); 4854 next: 4855 pair = next_pair; 4856 } 4857 } 4858 4859 /* 4860 * Extract properties that cannot be set PRIOR to the receipt of a dataset. 4861 * For example, refquota cannot be set until after the receipt of a dataset, 4862 * because in replication streams, an older/earlier snapshot may exceed the 4863 * refquota. We want to receive the older/earlier snapshot, but setting 4864 * refquota pre-receipt will set the dsl's ACTUAL quota, which will prevent 4865 * the older/earlier snapshot from being received (with EDQUOT). 4866 * 4867 * The ZFS test "zfs_receive_011_pos" demonstrates such a scenario. 4868 * 4869 * libzfs will need to be judicious handling errors encountered by props 4870 * extracted by this function. 4871 */ 4872 static nvlist_t * 4873 extract_delay_props(nvlist_t *props) 4874 { 4875 nvlist_t *delayprops; 4876 nvpair_t *nvp, *tmp; 4877 static const zfs_prop_t delayable[] = { 4878 ZFS_PROP_REFQUOTA, 4879 ZFS_PROP_KEYLOCATION, 4880 0 4881 }; 4882 int i; 4883 4884 VERIFY(nvlist_alloc(&delayprops, NV_UNIQUE_NAME, KM_SLEEP) == 0); 4885 4886 for (nvp = nvlist_next_nvpair(props, NULL); nvp != NULL; 4887 nvp = nvlist_next_nvpair(props, nvp)) { 4888 /* 4889 * strcmp() is safe because zfs_prop_to_name() always returns 4890 * a bounded string. 4891 */ 4892 for (i = 0; delayable[i] != 0; i++) { 4893 if (strcmp(zfs_prop_to_name(delayable[i]), 4894 nvpair_name(nvp)) == 0) { 4895 break; 4896 } 4897 } 4898 if (delayable[i] != 0) { 4899 tmp = nvlist_prev_nvpair(props, nvp); 4900 VERIFY(nvlist_add_nvpair(delayprops, nvp) == 0); 4901 VERIFY(nvlist_remove_nvpair(props, nvp) == 0); 4902 nvp = tmp; 4903 } 4904 } 4905 4906 if (nvlist_empty(delayprops)) { 4907 nvlist_free(delayprops); 4908 delayprops = NULL; 4909 } 4910 return (delayprops); 4911 } 4912 4913 static void 4914 zfs_allow_log_destroy(void *arg) 4915 { 4916 char *poolname = arg; 4917 4918 if (poolname != NULL) 4919 kmem_strfree(poolname); 4920 } 4921 4922 #ifdef ZFS_DEBUG 4923 static boolean_t zfs_ioc_recv_inject_err; 4924 #endif 4925 4926 /* 4927 * nvlist 'errors' is always allocated. It will contain descriptions of 4928 * encountered errors, if any. It's the callers responsibility to free. 4929 */ 4930 static int 4931 zfs_ioc_recv_impl(char *tofs, char *tosnap, char *origin, nvlist_t *recvprops, 4932 nvlist_t *localprops, nvlist_t *hidden_args, boolean_t force, 4933 boolean_t resumable, int input_fd, 4934 dmu_replay_record_t *begin_record, uint64_t *read_bytes, 4935 uint64_t *errflags, nvlist_t **errors) 4936 { 4937 dmu_recv_cookie_t drc; 4938 int error = 0; 4939 int props_error = 0; 4940 offset_t off, noff; 4941 nvlist_t *local_delayprops = NULL; 4942 nvlist_t *recv_delayprops = NULL; 4943 nvlist_t *origprops = NULL; /* existing properties */ 4944 nvlist_t *origrecvd = NULL; /* existing received properties */ 4945 boolean_t first_recvd_props = B_FALSE; 4946 boolean_t tofs_was_redacted; 4947 zfs_file_t *input_fp; 4948 4949 *read_bytes = 0; 4950 *errflags = 0; 4951 *errors = fnvlist_alloc(); 4952 off = 0; 4953 4954 if ((input_fp = zfs_file_get(input_fd)) == NULL) 4955 return (SET_ERROR(EBADF)); 4956 4957 noff = off = zfs_file_off(input_fp); 4958 error = dmu_recv_begin(tofs, tosnap, begin_record, force, 4959 resumable, localprops, hidden_args, origin, &drc, input_fp, 4960 &off); 4961 if (error != 0) 4962 goto out; 4963 tofs_was_redacted = dsl_get_redacted(drc.drc_ds); 4964 4965 /* 4966 * Set properties before we receive the stream so that they are applied 4967 * to the new data. Note that we must call dmu_recv_stream() if 4968 * dmu_recv_begin() succeeds. 4969 */ 4970 if (recvprops != NULL && !drc.drc_newfs) { 4971 if (spa_version(dsl_dataset_get_spa(drc.drc_ds)) >= 4972 SPA_VERSION_RECVD_PROPS && 4973 !dsl_prop_get_hasrecvd(tofs)) 4974 first_recvd_props = B_TRUE; 4975 4976 /* 4977 * If new received properties are supplied, they are to 4978 * completely replace the existing received properties, 4979 * so stash away the existing ones. 4980 */ 4981 if (dsl_prop_get_received(tofs, &origrecvd) == 0) { 4982 nvlist_t *errlist = NULL; 4983 /* 4984 * Don't bother writing a property if its value won't 4985 * change (and avoid the unnecessary security checks). 4986 * 4987 * The first receive after SPA_VERSION_RECVD_PROPS is a 4988 * special case where we blow away all local properties 4989 * regardless. 4990 */ 4991 if (!first_recvd_props) 4992 props_reduce(recvprops, origrecvd); 4993 if (zfs_check_clearable(tofs, origrecvd, &errlist) != 0) 4994 (void) nvlist_merge(*errors, errlist, 0); 4995 nvlist_free(errlist); 4996 4997 if (clear_received_props(tofs, origrecvd, 4998 first_recvd_props ? NULL : recvprops) != 0) 4999 *errflags |= ZPROP_ERR_NOCLEAR; 5000 } else { 5001 *errflags |= ZPROP_ERR_NOCLEAR; 5002 } 5003 } 5004 5005 /* 5006 * Stash away existing properties so we can restore them on error unless 5007 * we're doing the first receive after SPA_VERSION_RECVD_PROPS, in which 5008 * case "origrecvd" will take care of that. 5009 */ 5010 if (localprops != NULL && !drc.drc_newfs && !first_recvd_props) { 5011 objset_t *os; 5012 if (dmu_objset_hold(tofs, FTAG, &os) == 0) { 5013 if (dsl_prop_get_all(os, &origprops) != 0) { 5014 *errflags |= ZPROP_ERR_NOCLEAR; 5015 } 5016 dmu_objset_rele(os, FTAG); 5017 } else { 5018 *errflags |= ZPROP_ERR_NOCLEAR; 5019 } 5020 } 5021 5022 if (recvprops != NULL) { 5023 props_error = dsl_prop_set_hasrecvd(tofs); 5024 5025 if (props_error == 0) { 5026 recv_delayprops = extract_delay_props(recvprops); 5027 (void) zfs_set_prop_nvlist(tofs, ZPROP_SRC_RECEIVED, 5028 recvprops, *errors); 5029 } 5030 } 5031 5032 if (localprops != NULL) { 5033 nvlist_t *oprops = fnvlist_alloc(); 5034 nvlist_t *xprops = fnvlist_alloc(); 5035 nvpair_t *nvp = NULL; 5036 5037 while ((nvp = nvlist_next_nvpair(localprops, nvp)) != NULL) { 5038 if (nvpair_type(nvp) == DATA_TYPE_BOOLEAN) { 5039 /* -x property */ 5040 const char *name = nvpair_name(nvp); 5041 zfs_prop_t prop = zfs_name_to_prop(name); 5042 if (prop != ZPROP_INVAL) { 5043 if (!zfs_prop_inheritable(prop)) 5044 continue; 5045 } else if (!zfs_prop_user(name)) 5046 continue; 5047 fnvlist_add_boolean(xprops, name); 5048 } else { 5049 /* -o property=value */ 5050 fnvlist_add_nvpair(oprops, nvp); 5051 } 5052 } 5053 5054 local_delayprops = extract_delay_props(oprops); 5055 (void) zfs_set_prop_nvlist(tofs, ZPROP_SRC_LOCAL, 5056 oprops, *errors); 5057 (void) zfs_set_prop_nvlist(tofs, ZPROP_SRC_INHERITED, 5058 xprops, *errors); 5059 5060 nvlist_free(oprops); 5061 nvlist_free(xprops); 5062 } 5063 5064 error = dmu_recv_stream(&drc, &off); 5065 5066 if (error == 0) { 5067 zfsvfs_t *zfsvfs = NULL; 5068 zvol_state_handle_t *zv = NULL; 5069 5070 if (getzfsvfs(tofs, &zfsvfs) == 0) { 5071 /* online recv */ 5072 dsl_dataset_t *ds; 5073 int end_err; 5074 boolean_t stream_is_redacted = DMU_GET_FEATUREFLAGS( 5075 begin_record->drr_u.drr_begin. 5076 drr_versioninfo) & DMU_BACKUP_FEATURE_REDACTED; 5077 5078 ds = dmu_objset_ds(zfsvfs->z_os); 5079 error = zfs_suspend_fs(zfsvfs); 5080 /* 5081 * If the suspend fails, then the recv_end will 5082 * likely also fail, and clean up after itself. 5083 */ 5084 end_err = dmu_recv_end(&drc, zfsvfs); 5085 /* 5086 * If the dataset was not redacted, but we received a 5087 * redacted stream onto it, we need to unmount the 5088 * dataset. Otherwise, resume the filesystem. 5089 */ 5090 if (error == 0 && !drc.drc_newfs && 5091 stream_is_redacted && !tofs_was_redacted) { 5092 error = zfs_end_fs(zfsvfs, ds); 5093 } else if (error == 0) { 5094 error = zfs_resume_fs(zfsvfs, ds); 5095 } 5096 error = error ? error : end_err; 5097 zfs_vfs_rele(zfsvfs); 5098 } else if ((zv = zvol_suspend(tofs)) != NULL) { 5099 error = dmu_recv_end(&drc, zvol_tag(zv)); 5100 zvol_resume(zv); 5101 } else { 5102 error = dmu_recv_end(&drc, NULL); 5103 } 5104 5105 /* Set delayed properties now, after we're done receiving. */ 5106 if (recv_delayprops != NULL && error == 0) { 5107 (void) zfs_set_prop_nvlist(tofs, ZPROP_SRC_RECEIVED, 5108 recv_delayprops, *errors); 5109 } 5110 if (local_delayprops != NULL && error == 0) { 5111 (void) zfs_set_prop_nvlist(tofs, ZPROP_SRC_LOCAL, 5112 local_delayprops, *errors); 5113 } 5114 } 5115 5116 /* 5117 * Merge delayed props back in with initial props, in case 5118 * we're DEBUG and zfs_ioc_recv_inject_err is set (which means 5119 * we have to make sure clear_received_props() includes 5120 * the delayed properties). 5121 * 5122 * Since zfs_ioc_recv_inject_err is only in DEBUG kernels, 5123 * using ASSERT() will be just like a VERIFY. 5124 */ 5125 if (recv_delayprops != NULL) { 5126 ASSERT(nvlist_merge(recvprops, recv_delayprops, 0) == 0); 5127 nvlist_free(recv_delayprops); 5128 } 5129 if (local_delayprops != NULL) { 5130 ASSERT(nvlist_merge(localprops, local_delayprops, 0) == 0); 5131 nvlist_free(local_delayprops); 5132 } 5133 *read_bytes = off - noff; 5134 5135 #ifdef ZFS_DEBUG 5136 if (zfs_ioc_recv_inject_err) { 5137 zfs_ioc_recv_inject_err = B_FALSE; 5138 error = 1; 5139 } 5140 #endif 5141 5142 /* 5143 * On error, restore the original props. 5144 */ 5145 if (error != 0 && recvprops != NULL && !drc.drc_newfs) { 5146 if (clear_received_props(tofs, recvprops, NULL) != 0) { 5147 /* 5148 * We failed to clear the received properties. 5149 * Since we may have left a $recvd value on the 5150 * system, we can't clear the $hasrecvd flag. 5151 */ 5152 *errflags |= ZPROP_ERR_NORESTORE; 5153 } else if (first_recvd_props) { 5154 dsl_prop_unset_hasrecvd(tofs); 5155 } 5156 5157 if (origrecvd == NULL && !drc.drc_newfs) { 5158 /* We failed to stash the original properties. */ 5159 *errflags |= ZPROP_ERR_NORESTORE; 5160 } 5161 5162 /* 5163 * dsl_props_set() will not convert RECEIVED to LOCAL on or 5164 * after SPA_VERSION_RECVD_PROPS, so we need to specify LOCAL 5165 * explicitly if we're restoring local properties cleared in the 5166 * first new-style receive. 5167 */ 5168 if (origrecvd != NULL && 5169 zfs_set_prop_nvlist(tofs, (first_recvd_props ? 5170 ZPROP_SRC_LOCAL : ZPROP_SRC_RECEIVED), 5171 origrecvd, NULL) != 0) { 5172 /* 5173 * We stashed the original properties but failed to 5174 * restore them. 5175 */ 5176 *errflags |= ZPROP_ERR_NORESTORE; 5177 } 5178 } 5179 if (error != 0 && localprops != NULL && !drc.drc_newfs && 5180 !first_recvd_props) { 5181 nvlist_t *setprops; 5182 nvlist_t *inheritprops; 5183 nvpair_t *nvp; 5184 5185 if (origprops == NULL) { 5186 /* We failed to stash the original properties. */ 5187 *errflags |= ZPROP_ERR_NORESTORE; 5188 goto out; 5189 } 5190 5191 /* Restore original props */ 5192 setprops = fnvlist_alloc(); 5193 inheritprops = fnvlist_alloc(); 5194 nvp = NULL; 5195 while ((nvp = nvlist_next_nvpair(localprops, nvp)) != NULL) { 5196 const char *name = nvpair_name(nvp); 5197 const char *source; 5198 nvlist_t *attrs; 5199 5200 if (!nvlist_exists(origprops, name)) { 5201 /* 5202 * Property was not present or was explicitly 5203 * inherited before the receive, restore this. 5204 */ 5205 fnvlist_add_boolean(inheritprops, name); 5206 continue; 5207 } 5208 attrs = fnvlist_lookup_nvlist(origprops, name); 5209 source = fnvlist_lookup_string(attrs, ZPROP_SOURCE); 5210 5211 /* Skip received properties */ 5212 if (strcmp(source, ZPROP_SOURCE_VAL_RECVD) == 0) 5213 continue; 5214 5215 if (strcmp(source, tofs) == 0) { 5216 /* Property was locally set */ 5217 fnvlist_add_nvlist(setprops, name, attrs); 5218 } else { 5219 /* Property was implicitly inherited */ 5220 fnvlist_add_boolean(inheritprops, name); 5221 } 5222 } 5223 5224 if (zfs_set_prop_nvlist(tofs, ZPROP_SRC_LOCAL, setprops, 5225 NULL) != 0) 5226 *errflags |= ZPROP_ERR_NORESTORE; 5227 if (zfs_set_prop_nvlist(tofs, ZPROP_SRC_INHERITED, inheritprops, 5228 NULL) != 0) 5229 *errflags |= ZPROP_ERR_NORESTORE; 5230 5231 nvlist_free(setprops); 5232 nvlist_free(inheritprops); 5233 } 5234 out: 5235 zfs_file_put(input_fp); 5236 nvlist_free(origrecvd); 5237 nvlist_free(origprops); 5238 5239 if (error == 0) 5240 error = props_error; 5241 5242 return (error); 5243 } 5244 5245 /* 5246 * inputs: 5247 * zc_name name of containing filesystem (unused) 5248 * zc_nvlist_src{_size} nvlist of properties to apply 5249 * zc_nvlist_conf{_size} nvlist of properties to exclude 5250 * (DATA_TYPE_BOOLEAN) and override (everything else) 5251 * zc_value name of snapshot to create 5252 * zc_string name of clone origin (if DRR_FLAG_CLONE) 5253 * zc_cookie file descriptor to recv from 5254 * zc_begin_record the BEGIN record of the stream (not byteswapped) 5255 * zc_guid force flag 5256 * 5257 * outputs: 5258 * zc_cookie number of bytes read 5259 * zc_obj zprop_errflags_t 5260 * zc_nvlist_dst{_size} error for each unapplied received property 5261 */ 5262 static int 5263 zfs_ioc_recv(zfs_cmd_t *zc) 5264 { 5265 dmu_replay_record_t begin_record; 5266 nvlist_t *errors = NULL; 5267 nvlist_t *recvdprops = NULL; 5268 nvlist_t *localprops = NULL; 5269 char *origin = NULL; 5270 char *tosnap; 5271 char tofs[ZFS_MAX_DATASET_NAME_LEN]; 5272 int error = 0; 5273 5274 if (dataset_namecheck(zc->zc_value, NULL, NULL) != 0 || 5275 strchr(zc->zc_value, '@') == NULL || 5276 strchr(zc->zc_value, '%')) 5277 return (SET_ERROR(EINVAL)); 5278 5279 (void) strlcpy(tofs, zc->zc_value, sizeof (tofs)); 5280 tosnap = strchr(tofs, '@'); 5281 *tosnap++ = '\0'; 5282 5283 if (zc->zc_nvlist_src != 0 && 5284 (error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size, 5285 zc->zc_iflags, &recvdprops)) != 0) 5286 return (error); 5287 5288 if (zc->zc_nvlist_conf != 0 && 5289 (error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size, 5290 zc->zc_iflags, &localprops)) != 0) 5291 return (error); 5292 5293 if (zc->zc_string[0]) 5294 origin = zc->zc_string; 5295 5296 begin_record.drr_type = DRR_BEGIN; 5297 begin_record.drr_payloadlen = 0; 5298 begin_record.drr_u.drr_begin = zc->zc_begin_record; 5299 5300 error = zfs_ioc_recv_impl(tofs, tosnap, origin, recvdprops, localprops, 5301 NULL, zc->zc_guid, B_FALSE, zc->zc_cookie, &begin_record, 5302 &zc->zc_cookie, &zc->zc_obj, &errors); 5303 nvlist_free(recvdprops); 5304 nvlist_free(localprops); 5305 5306 /* 5307 * Now that all props, initial and delayed, are set, report the prop 5308 * errors to the caller. 5309 */ 5310 if (zc->zc_nvlist_dst_size != 0 && errors != NULL && 5311 (nvlist_smush(errors, zc->zc_nvlist_dst_size) != 0 || 5312 put_nvlist(zc, errors) != 0)) { 5313 /* 5314 * Caller made zc->zc_nvlist_dst less than the minimum expected 5315 * size or supplied an invalid address. 5316 */ 5317 error = SET_ERROR(EINVAL); 5318 } 5319 5320 nvlist_free(errors); 5321 5322 return (error); 5323 } 5324 5325 /* 5326 * innvl: { 5327 * "snapname" -> full name of the snapshot to create 5328 * (optional) "props" -> received properties to set (nvlist) 5329 * (optional) "localprops" -> override and exclude properties (nvlist) 5330 * (optional) "origin" -> name of clone origin (DRR_FLAG_CLONE) 5331 * "begin_record" -> non-byteswapped dmu_replay_record_t 5332 * "input_fd" -> file descriptor to read stream from (int32) 5333 * (optional) "force" -> force flag (value ignored) 5334 * (optional) "resumable" -> resumable flag (value ignored) 5335 * (optional) "cleanup_fd" -> unused 5336 * (optional) "action_handle" -> unused 5337 * (optional) "hidden_args" -> { "wkeydata" -> value } 5338 * } 5339 * 5340 * outnvl: { 5341 * "read_bytes" -> number of bytes read 5342 * "error_flags" -> zprop_errflags_t 5343 * "errors" -> error for each unapplied received property (nvlist) 5344 * } 5345 */ 5346 static const zfs_ioc_key_t zfs_keys_recv_new[] = { 5347 {"snapname", DATA_TYPE_STRING, 0}, 5348 {"props", DATA_TYPE_NVLIST, ZK_OPTIONAL}, 5349 {"localprops", DATA_TYPE_NVLIST, ZK_OPTIONAL}, 5350 {"origin", DATA_TYPE_STRING, ZK_OPTIONAL}, 5351 {"begin_record", DATA_TYPE_BYTE_ARRAY, 0}, 5352 {"input_fd", DATA_TYPE_INT32, 0}, 5353 {"force", DATA_TYPE_BOOLEAN, ZK_OPTIONAL}, 5354 {"resumable", DATA_TYPE_BOOLEAN, ZK_OPTIONAL}, 5355 {"cleanup_fd", DATA_TYPE_INT32, ZK_OPTIONAL}, 5356 {"action_handle", DATA_TYPE_UINT64, ZK_OPTIONAL}, 5357 {"hidden_args", DATA_TYPE_NVLIST, ZK_OPTIONAL}, 5358 }; 5359 5360 static int 5361 zfs_ioc_recv_new(const char *fsname, nvlist_t *innvl, nvlist_t *outnvl) 5362 { 5363 dmu_replay_record_t *begin_record; 5364 uint_t begin_record_size; 5365 nvlist_t *errors = NULL; 5366 nvlist_t *recvprops = NULL; 5367 nvlist_t *localprops = NULL; 5368 nvlist_t *hidden_args = NULL; 5369 char *snapname; 5370 char *origin = NULL; 5371 char *tosnap; 5372 char tofs[ZFS_MAX_DATASET_NAME_LEN]; 5373 boolean_t force; 5374 boolean_t resumable; 5375 uint64_t read_bytes = 0; 5376 uint64_t errflags = 0; 5377 int input_fd = -1; 5378 int error; 5379 5380 snapname = fnvlist_lookup_string(innvl, "snapname"); 5381 5382 if (dataset_namecheck(snapname, NULL, NULL) != 0 || 5383 strchr(snapname, '@') == NULL || 5384 strchr(snapname, '%')) 5385 return (SET_ERROR(EINVAL)); 5386 5387 (void) strlcpy(tofs, snapname, sizeof (tofs)); 5388 tosnap = strchr(tofs, '@'); 5389 *tosnap++ = '\0'; 5390 5391 error = nvlist_lookup_string(innvl, "origin", &origin); 5392 if (error && error != ENOENT) 5393 return (error); 5394 5395 error = nvlist_lookup_byte_array(innvl, "begin_record", 5396 (uchar_t **)&begin_record, &begin_record_size); 5397 if (error != 0 || begin_record_size != sizeof (*begin_record)) 5398 return (SET_ERROR(EINVAL)); 5399 5400 input_fd = fnvlist_lookup_int32(innvl, "input_fd"); 5401 5402 force = nvlist_exists(innvl, "force"); 5403 resumable = nvlist_exists(innvl, "resumable"); 5404 5405 /* we still use "props" here for backwards compatibility */ 5406 error = nvlist_lookup_nvlist(innvl, "props", &recvprops); 5407 if (error && error != ENOENT) 5408 return (error); 5409 5410 error = nvlist_lookup_nvlist(innvl, "localprops", &localprops); 5411 if (error && error != ENOENT) 5412 return (error); 5413 5414 error = nvlist_lookup_nvlist(innvl, ZPOOL_HIDDEN_ARGS, &hidden_args); 5415 if (error && error != ENOENT) 5416 return (error); 5417 5418 error = zfs_ioc_recv_impl(tofs, tosnap, origin, recvprops, localprops, 5419 hidden_args, force, resumable, input_fd, begin_record, 5420 &read_bytes, &errflags, &errors); 5421 5422 fnvlist_add_uint64(outnvl, "read_bytes", read_bytes); 5423 fnvlist_add_uint64(outnvl, "error_flags", errflags); 5424 fnvlist_add_nvlist(outnvl, "errors", errors); 5425 5426 nvlist_free(errors); 5427 nvlist_free(recvprops); 5428 nvlist_free(localprops); 5429 5430 return (error); 5431 } 5432 5433 typedef struct dump_bytes_io { 5434 zfs_file_t *dbi_fp; 5435 caddr_t dbi_buf; 5436 int dbi_len; 5437 int dbi_err; 5438 } dump_bytes_io_t; 5439 5440 static void 5441 dump_bytes_cb(void *arg) 5442 { 5443 dump_bytes_io_t *dbi = (dump_bytes_io_t *)arg; 5444 zfs_file_t *fp; 5445 caddr_t buf; 5446 5447 fp = dbi->dbi_fp; 5448 buf = dbi->dbi_buf; 5449 5450 dbi->dbi_err = zfs_file_write(fp, buf, dbi->dbi_len, NULL); 5451 } 5452 5453 static int 5454 dump_bytes(objset_t *os, void *buf, int len, void *arg) 5455 { 5456 dump_bytes_io_t dbi; 5457 5458 dbi.dbi_fp = arg; 5459 dbi.dbi_buf = buf; 5460 dbi.dbi_len = len; 5461 5462 #if defined(HAVE_LARGE_STACKS) 5463 dump_bytes_cb(&dbi); 5464 #else 5465 /* 5466 * The vn_rdwr() call is performed in a taskq to ensure that there is 5467 * always enough stack space to write safely to the target filesystem. 5468 * The ZIO_TYPE_FREE threads are used because there can be a lot of 5469 * them and they are used in vdev_file.c for a similar purpose. 5470 */ 5471 spa_taskq_dispatch_sync(dmu_objset_spa(os), ZIO_TYPE_FREE, 5472 ZIO_TASKQ_ISSUE, dump_bytes_cb, &dbi, TQ_SLEEP); 5473 #endif /* HAVE_LARGE_STACKS */ 5474 5475 return (dbi.dbi_err); 5476 } 5477 5478 /* 5479 * inputs: 5480 * zc_name name of snapshot to send 5481 * zc_cookie file descriptor to send stream to 5482 * zc_obj fromorigin flag (mutually exclusive with zc_fromobj) 5483 * zc_sendobj objsetid of snapshot to send 5484 * zc_fromobj objsetid of incremental fromsnap (may be zero) 5485 * zc_guid if set, estimate size of stream only. zc_cookie is ignored. 5486 * output size in zc_objset_type. 5487 * zc_flags lzc_send_flags 5488 * 5489 * outputs: 5490 * zc_objset_type estimated size, if zc_guid is set 5491 * 5492 * NOTE: This is no longer the preferred interface, any new functionality 5493 * should be added to zfs_ioc_send_new() instead. 5494 */ 5495 static int 5496 zfs_ioc_send(zfs_cmd_t *zc) 5497 { 5498 int error; 5499 offset_t off; 5500 boolean_t estimate = (zc->zc_guid != 0); 5501 boolean_t embedok = (zc->zc_flags & 0x1); 5502 boolean_t large_block_ok = (zc->zc_flags & 0x2); 5503 boolean_t compressok = (zc->zc_flags & 0x4); 5504 boolean_t rawok = (zc->zc_flags & 0x8); 5505 boolean_t savedok = (zc->zc_flags & 0x10); 5506 5507 if (zc->zc_obj != 0) { 5508 dsl_pool_t *dp; 5509 dsl_dataset_t *tosnap; 5510 5511 error = dsl_pool_hold(zc->zc_name, FTAG, &dp); 5512 if (error != 0) 5513 return (error); 5514 5515 error = dsl_dataset_hold_obj(dp, zc->zc_sendobj, FTAG, &tosnap); 5516 if (error != 0) { 5517 dsl_pool_rele(dp, FTAG); 5518 return (error); 5519 } 5520 5521 if (dsl_dir_is_clone(tosnap->ds_dir)) 5522 zc->zc_fromobj = 5523 dsl_dir_phys(tosnap->ds_dir)->dd_origin_obj; 5524 dsl_dataset_rele(tosnap, FTAG); 5525 dsl_pool_rele(dp, FTAG); 5526 } 5527 5528 if (estimate) { 5529 dsl_pool_t *dp; 5530 dsl_dataset_t *tosnap; 5531 dsl_dataset_t *fromsnap = NULL; 5532 5533 error = dsl_pool_hold(zc->zc_name, FTAG, &dp); 5534 if (error != 0) 5535 return (error); 5536 5537 error = dsl_dataset_hold_obj(dp, zc->zc_sendobj, 5538 FTAG, &tosnap); 5539 if (error != 0) { 5540 dsl_pool_rele(dp, FTAG); 5541 return (error); 5542 } 5543 5544 if (zc->zc_fromobj != 0) { 5545 error = dsl_dataset_hold_obj(dp, zc->zc_fromobj, 5546 FTAG, &fromsnap); 5547 if (error != 0) { 5548 dsl_dataset_rele(tosnap, FTAG); 5549 dsl_pool_rele(dp, FTAG); 5550 return (error); 5551 } 5552 } 5553 5554 error = dmu_send_estimate_fast(tosnap, fromsnap, NULL, 5555 compressok || rawok, savedok, &zc->zc_objset_type); 5556 5557 if (fromsnap != NULL) 5558 dsl_dataset_rele(fromsnap, FTAG); 5559 dsl_dataset_rele(tosnap, FTAG); 5560 dsl_pool_rele(dp, FTAG); 5561 } else { 5562 zfs_file_t *fp; 5563 dmu_send_outparams_t out = {0}; 5564 5565 if ((fp = zfs_file_get(zc->zc_cookie)) == NULL) 5566 return (SET_ERROR(EBADF)); 5567 5568 off = zfs_file_off(fp); 5569 out.dso_outfunc = dump_bytes; 5570 out.dso_arg = fp; 5571 out.dso_dryrun = B_FALSE; 5572 error = dmu_send_obj(zc->zc_name, zc->zc_sendobj, 5573 zc->zc_fromobj, embedok, large_block_ok, compressok, 5574 rawok, savedok, zc->zc_cookie, &off, &out); 5575 5576 zfs_file_put(fp); 5577 } 5578 return (error); 5579 } 5580 5581 /* 5582 * inputs: 5583 * zc_name name of snapshot on which to report progress 5584 * zc_cookie file descriptor of send stream 5585 * 5586 * outputs: 5587 * zc_cookie number of bytes written in send stream thus far 5588 * zc_objset_type logical size of data traversed by send thus far 5589 */ 5590 static int 5591 zfs_ioc_send_progress(zfs_cmd_t *zc) 5592 { 5593 dsl_pool_t *dp; 5594 dsl_dataset_t *ds; 5595 dmu_sendstatus_t *dsp = NULL; 5596 int error; 5597 5598 error = dsl_pool_hold(zc->zc_name, FTAG, &dp); 5599 if (error != 0) 5600 return (error); 5601 5602 error = dsl_dataset_hold(dp, zc->zc_name, FTAG, &ds); 5603 if (error != 0) { 5604 dsl_pool_rele(dp, FTAG); 5605 return (error); 5606 } 5607 5608 mutex_enter(&ds->ds_sendstream_lock); 5609 5610 /* 5611 * Iterate over all the send streams currently active on this dataset. 5612 * If there's one which matches the specified file descriptor _and_ the 5613 * stream was started by the current process, return the progress of 5614 * that stream. 5615 */ 5616 5617 for (dsp = list_head(&ds->ds_sendstreams); dsp != NULL; 5618 dsp = list_next(&ds->ds_sendstreams, dsp)) { 5619 if (dsp->dss_outfd == zc->zc_cookie && 5620 zfs_proc_is_caller(dsp->dss_proc)) 5621 break; 5622 } 5623 5624 if (dsp != NULL) { 5625 zc->zc_cookie = atomic_cas_64((volatile uint64_t *)dsp->dss_off, 5626 0, 0); 5627 /* This is the closest thing we have to atomic_read_64. */ 5628 zc->zc_objset_type = atomic_cas_64(&dsp->dss_blocks, 0, 0); 5629 } else { 5630 error = SET_ERROR(ENOENT); 5631 } 5632 5633 mutex_exit(&ds->ds_sendstream_lock); 5634 dsl_dataset_rele(ds, FTAG); 5635 dsl_pool_rele(dp, FTAG); 5636 return (error); 5637 } 5638 5639 static int 5640 zfs_ioc_inject_fault(zfs_cmd_t *zc) 5641 { 5642 int id, error; 5643 5644 error = zio_inject_fault(zc->zc_name, (int)zc->zc_guid, &id, 5645 &zc->zc_inject_record); 5646 5647 if (error == 0) 5648 zc->zc_guid = (uint64_t)id; 5649 5650 return (error); 5651 } 5652 5653 static int 5654 zfs_ioc_clear_fault(zfs_cmd_t *zc) 5655 { 5656 return (zio_clear_fault((int)zc->zc_guid)); 5657 } 5658 5659 static int 5660 zfs_ioc_inject_list_next(zfs_cmd_t *zc) 5661 { 5662 int id = (int)zc->zc_guid; 5663 int error; 5664 5665 error = zio_inject_list_next(&id, zc->zc_name, sizeof (zc->zc_name), 5666 &zc->zc_inject_record); 5667 5668 zc->zc_guid = id; 5669 5670 return (error); 5671 } 5672 5673 static int 5674 zfs_ioc_error_log(zfs_cmd_t *zc) 5675 { 5676 spa_t *spa; 5677 int error; 5678 size_t count = (size_t)zc->zc_nvlist_dst_size; 5679 5680 if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0) 5681 return (error); 5682 5683 error = spa_get_errlog(spa, (void *)(uintptr_t)zc->zc_nvlist_dst, 5684 &count); 5685 if (error == 0) 5686 zc->zc_nvlist_dst_size = count; 5687 else 5688 zc->zc_nvlist_dst_size = spa_get_errlog_size(spa); 5689 5690 spa_close(spa, FTAG); 5691 5692 return (error); 5693 } 5694 5695 static int 5696 zfs_ioc_clear(zfs_cmd_t *zc) 5697 { 5698 spa_t *spa; 5699 vdev_t *vd; 5700 int error; 5701 5702 /* 5703 * On zpool clear we also fix up missing slogs 5704 */ 5705 mutex_enter(&spa_namespace_lock); 5706 spa = spa_lookup(zc->zc_name); 5707 if (spa == NULL) { 5708 mutex_exit(&spa_namespace_lock); 5709 return (SET_ERROR(EIO)); 5710 } 5711 if (spa_get_log_state(spa) == SPA_LOG_MISSING) { 5712 /* we need to let spa_open/spa_load clear the chains */ 5713 spa_set_log_state(spa, SPA_LOG_CLEAR); 5714 } 5715 spa->spa_last_open_failed = 0; 5716 mutex_exit(&spa_namespace_lock); 5717 5718 if (zc->zc_cookie & ZPOOL_NO_REWIND) { 5719 error = spa_open(zc->zc_name, &spa, FTAG); 5720 } else { 5721 nvlist_t *policy; 5722 nvlist_t *config = NULL; 5723 5724 if (zc->zc_nvlist_src == 0) 5725 return (SET_ERROR(EINVAL)); 5726 5727 if ((error = get_nvlist(zc->zc_nvlist_src, 5728 zc->zc_nvlist_src_size, zc->zc_iflags, &policy)) == 0) { 5729 error = spa_open_rewind(zc->zc_name, &spa, FTAG, 5730 policy, &config); 5731 if (config != NULL) { 5732 int err; 5733 5734 if ((err = put_nvlist(zc, config)) != 0) 5735 error = err; 5736 nvlist_free(config); 5737 } 5738 nvlist_free(policy); 5739 } 5740 } 5741 5742 if (error != 0) 5743 return (error); 5744 5745 /* 5746 * If multihost is enabled, resuming I/O is unsafe as another 5747 * host may have imported the pool. 5748 */ 5749 if (spa_multihost(spa) && spa_suspended(spa)) 5750 return (SET_ERROR(EINVAL)); 5751 5752 spa_vdev_state_enter(spa, SCL_NONE); 5753 5754 if (zc->zc_guid == 0) { 5755 vd = NULL; 5756 } else { 5757 vd = spa_lookup_by_guid(spa, zc->zc_guid, B_TRUE); 5758 if (vd == NULL) { 5759 error = SET_ERROR(ENODEV); 5760 (void) spa_vdev_state_exit(spa, NULL, error); 5761 spa_close(spa, FTAG); 5762 return (error); 5763 } 5764 } 5765 5766 vdev_clear(spa, vd); 5767 5768 (void) spa_vdev_state_exit(spa, spa_suspended(spa) ? 5769 NULL : spa->spa_root_vdev, 0); 5770 5771 /* 5772 * Resume any suspended I/Os. 5773 */ 5774 if (zio_resume(spa) != 0) 5775 error = SET_ERROR(EIO); 5776 5777 spa_close(spa, FTAG); 5778 5779 return (error); 5780 } 5781 5782 /* 5783 * Reopen all the vdevs associated with the pool. 5784 * 5785 * innvl: { 5786 * "scrub_restart" -> when true and scrub is running, allow to restart 5787 * scrub as the side effect of the reopen (boolean). 5788 * } 5789 * 5790 * outnvl is unused 5791 */ 5792 static const zfs_ioc_key_t zfs_keys_pool_reopen[] = { 5793 {"scrub_restart", DATA_TYPE_BOOLEAN_VALUE, ZK_OPTIONAL}, 5794 }; 5795 5796 /* ARGSUSED */ 5797 static int 5798 zfs_ioc_pool_reopen(const char *pool, nvlist_t *innvl, nvlist_t *outnvl) 5799 { 5800 spa_t *spa; 5801 int error; 5802 boolean_t rc, scrub_restart = B_TRUE; 5803 5804 if (innvl) { 5805 error = nvlist_lookup_boolean_value(innvl, 5806 "scrub_restart", &rc); 5807 if (error == 0) 5808 scrub_restart = rc; 5809 } 5810 5811 error = spa_open(pool, &spa, FTAG); 5812 if (error != 0) 5813 return (error); 5814 5815 spa_vdev_state_enter(spa, SCL_NONE); 5816 5817 /* 5818 * If the scrub_restart flag is B_FALSE and a scrub is already 5819 * in progress then set spa_scrub_reopen flag to B_TRUE so that 5820 * we don't restart the scrub as a side effect of the reopen. 5821 * Otherwise, let vdev_open() decided if a resilver is required. 5822 */ 5823 5824 spa->spa_scrub_reopen = (!scrub_restart && 5825 dsl_scan_scrubbing(spa->spa_dsl_pool)); 5826 vdev_reopen(spa->spa_root_vdev); 5827 spa->spa_scrub_reopen = B_FALSE; 5828 5829 (void) spa_vdev_state_exit(spa, NULL, 0); 5830 spa_close(spa, FTAG); 5831 return (0); 5832 } 5833 5834 /* 5835 * inputs: 5836 * zc_name name of filesystem 5837 * 5838 * outputs: 5839 * zc_string name of conflicting snapshot, if there is one 5840 */ 5841 static int 5842 zfs_ioc_promote(zfs_cmd_t *zc) 5843 { 5844 dsl_pool_t *dp; 5845 dsl_dataset_t *ds, *ods; 5846 char origin[ZFS_MAX_DATASET_NAME_LEN]; 5847 char *cp; 5848 int error; 5849 5850 zc->zc_name[sizeof (zc->zc_name) - 1] = '\0'; 5851 if (dataset_namecheck(zc->zc_name, NULL, NULL) != 0 || 5852 strchr(zc->zc_name, '%')) 5853 return (SET_ERROR(EINVAL)); 5854 5855 error = dsl_pool_hold(zc->zc_name, FTAG, &dp); 5856 if (error != 0) 5857 return (error); 5858 5859 error = dsl_dataset_hold(dp, zc->zc_name, FTAG, &ds); 5860 if (error != 0) { 5861 dsl_pool_rele(dp, FTAG); 5862 return (error); 5863 } 5864 5865 if (!dsl_dir_is_clone(ds->ds_dir)) { 5866 dsl_dataset_rele(ds, FTAG); 5867 dsl_pool_rele(dp, FTAG); 5868 return (SET_ERROR(EINVAL)); 5869 } 5870 5871 error = dsl_dataset_hold_obj(dp, 5872 dsl_dir_phys(ds->ds_dir)->dd_origin_obj, FTAG, &ods); 5873 if (error != 0) { 5874 dsl_dataset_rele(ds, FTAG); 5875 dsl_pool_rele(dp, FTAG); 5876 return (error); 5877 } 5878 5879 dsl_dataset_name(ods, origin); 5880 dsl_dataset_rele(ods, FTAG); 5881 dsl_dataset_rele(ds, FTAG); 5882 dsl_pool_rele(dp, FTAG); 5883 5884 /* 5885 * We don't need to unmount *all* the origin fs's snapshots, but 5886 * it's easier. 5887 */ 5888 cp = strchr(origin, '@'); 5889 if (cp) 5890 *cp = '\0'; 5891 (void) dmu_objset_find(origin, 5892 zfs_unmount_snap_cb, NULL, DS_FIND_SNAPSHOTS); 5893 return (dsl_dataset_promote(zc->zc_name, zc->zc_string)); 5894 } 5895 5896 /* 5897 * Retrieve a single {user|group|project}{used|quota}@... property. 5898 * 5899 * inputs: 5900 * zc_name name of filesystem 5901 * zc_objset_type zfs_userquota_prop_t 5902 * zc_value domain name (eg. "S-1-234-567-89") 5903 * zc_guid RID/UID/GID 5904 * 5905 * outputs: 5906 * zc_cookie property value 5907 */ 5908 static int 5909 zfs_ioc_userspace_one(zfs_cmd_t *zc) 5910 { 5911 zfsvfs_t *zfsvfs; 5912 int error; 5913 5914 if (zc->zc_objset_type >= ZFS_NUM_USERQUOTA_PROPS) 5915 return (SET_ERROR(EINVAL)); 5916 5917 error = zfsvfs_hold(zc->zc_name, FTAG, &zfsvfs, B_FALSE); 5918 if (error != 0) 5919 return (error); 5920 5921 error = zfs_userspace_one(zfsvfs, 5922 zc->zc_objset_type, zc->zc_value, zc->zc_guid, &zc->zc_cookie); 5923 zfsvfs_rele(zfsvfs, FTAG); 5924 5925 return (error); 5926 } 5927 5928 /* 5929 * inputs: 5930 * zc_name name of filesystem 5931 * zc_cookie zap cursor 5932 * zc_objset_type zfs_userquota_prop_t 5933 * zc_nvlist_dst[_size] buffer to fill (not really an nvlist) 5934 * 5935 * outputs: 5936 * zc_nvlist_dst[_size] data buffer (array of zfs_useracct_t) 5937 * zc_cookie zap cursor 5938 */ 5939 static int 5940 zfs_ioc_userspace_many(zfs_cmd_t *zc) 5941 { 5942 zfsvfs_t *zfsvfs; 5943 int bufsize = zc->zc_nvlist_dst_size; 5944 5945 if (bufsize <= 0) 5946 return (SET_ERROR(ENOMEM)); 5947 5948 int error = zfsvfs_hold(zc->zc_name, FTAG, &zfsvfs, B_FALSE); 5949 if (error != 0) 5950 return (error); 5951 5952 void *buf = vmem_alloc(bufsize, KM_SLEEP); 5953 5954 error = zfs_userspace_many(zfsvfs, zc->zc_objset_type, &zc->zc_cookie, 5955 buf, &zc->zc_nvlist_dst_size); 5956 5957 if (error == 0) { 5958 error = xcopyout(buf, 5959 (void *)(uintptr_t)zc->zc_nvlist_dst, 5960 zc->zc_nvlist_dst_size); 5961 } 5962 vmem_free(buf, bufsize); 5963 zfsvfs_rele(zfsvfs, FTAG); 5964 5965 return (error); 5966 } 5967 5968 /* 5969 * inputs: 5970 * zc_name name of filesystem 5971 * 5972 * outputs: 5973 * none 5974 */ 5975 static int 5976 zfs_ioc_userspace_upgrade(zfs_cmd_t *zc) 5977 { 5978 int error = 0; 5979 zfsvfs_t *zfsvfs; 5980 5981 if (getzfsvfs(zc->zc_name, &zfsvfs) == 0) { 5982 if (!dmu_objset_userused_enabled(zfsvfs->z_os)) { 5983 /* 5984 * If userused is not enabled, it may be because the 5985 * objset needs to be closed & reopened (to grow the 5986 * objset_phys_t). Suspend/resume the fs will do that. 5987 */ 5988 dsl_dataset_t *ds, *newds; 5989 5990 ds = dmu_objset_ds(zfsvfs->z_os); 5991 error = zfs_suspend_fs(zfsvfs); 5992 if (error == 0) { 5993 dmu_objset_refresh_ownership(ds, &newds, 5994 B_TRUE, zfsvfs); 5995 error = zfs_resume_fs(zfsvfs, newds); 5996 } 5997 } 5998 if (error == 0) { 5999 mutex_enter(&zfsvfs->z_os->os_upgrade_lock); 6000 if (zfsvfs->z_os->os_upgrade_id == 0) { 6001 /* clear potential error code and retry */ 6002 zfsvfs->z_os->os_upgrade_status = 0; 6003 mutex_exit(&zfsvfs->z_os->os_upgrade_lock); 6004 6005 dsl_pool_config_enter( 6006 dmu_objset_pool(zfsvfs->z_os), FTAG); 6007 dmu_objset_userspace_upgrade(zfsvfs->z_os); 6008 dsl_pool_config_exit( 6009 dmu_objset_pool(zfsvfs->z_os), FTAG); 6010 } else { 6011 mutex_exit(&zfsvfs->z_os->os_upgrade_lock); 6012 } 6013 6014 taskq_wait_id(zfsvfs->z_os->os_spa->spa_upgrade_taskq, 6015 zfsvfs->z_os->os_upgrade_id); 6016 error = zfsvfs->z_os->os_upgrade_status; 6017 } 6018 zfs_vfs_rele(zfsvfs); 6019 } else { 6020 objset_t *os; 6021 6022 /* XXX kind of reading contents without owning */ 6023 error = dmu_objset_hold_flags(zc->zc_name, B_TRUE, FTAG, &os); 6024 if (error != 0) 6025 return (error); 6026 6027 mutex_enter(&os->os_upgrade_lock); 6028 if (os->os_upgrade_id == 0) { 6029 /* clear potential error code and retry */ 6030 os->os_upgrade_status = 0; 6031 mutex_exit(&os->os_upgrade_lock); 6032 6033 dmu_objset_userspace_upgrade(os); 6034 } else { 6035 mutex_exit(&os->os_upgrade_lock); 6036 } 6037 6038 dsl_pool_rele(dmu_objset_pool(os), FTAG); 6039 6040 taskq_wait_id(os->os_spa->spa_upgrade_taskq, os->os_upgrade_id); 6041 error = os->os_upgrade_status; 6042 6043 dsl_dataset_rele_flags(dmu_objset_ds(os), DS_HOLD_FLAG_DECRYPT, 6044 FTAG); 6045 } 6046 return (error); 6047 } 6048 6049 /* 6050 * inputs: 6051 * zc_name name of filesystem 6052 * 6053 * outputs: 6054 * none 6055 */ 6056 static int 6057 zfs_ioc_id_quota_upgrade(zfs_cmd_t *zc) 6058 { 6059 objset_t *os; 6060 int error; 6061 6062 error = dmu_objset_hold_flags(zc->zc_name, B_TRUE, FTAG, &os); 6063 if (error != 0) 6064 return (error); 6065 6066 if (dmu_objset_userobjspace_upgradable(os) || 6067 dmu_objset_projectquota_upgradable(os)) { 6068 mutex_enter(&os->os_upgrade_lock); 6069 if (os->os_upgrade_id == 0) { 6070 /* clear potential error code and retry */ 6071 os->os_upgrade_status = 0; 6072 mutex_exit(&os->os_upgrade_lock); 6073 6074 dmu_objset_id_quota_upgrade(os); 6075 } else { 6076 mutex_exit(&os->os_upgrade_lock); 6077 } 6078 6079 dsl_pool_rele(dmu_objset_pool(os), FTAG); 6080 6081 taskq_wait_id(os->os_spa->spa_upgrade_taskq, os->os_upgrade_id); 6082 error = os->os_upgrade_status; 6083 } else { 6084 dsl_pool_rele(dmu_objset_pool(os), FTAG); 6085 } 6086 6087 dsl_dataset_rele_flags(dmu_objset_ds(os), DS_HOLD_FLAG_DECRYPT, FTAG); 6088 6089 return (error); 6090 } 6091 6092 static int 6093 zfs_ioc_share(zfs_cmd_t *zc) 6094 { 6095 return (SET_ERROR(ENOSYS)); 6096 } 6097 6098 ace_t full_access[] = { 6099 {(uid_t)-1, ACE_ALL_PERMS, ACE_EVERYONE, 0} 6100 }; 6101 6102 /* 6103 * inputs: 6104 * zc_name name of containing filesystem 6105 * zc_obj object # beyond which we want next in-use object # 6106 * 6107 * outputs: 6108 * zc_obj next in-use object # 6109 */ 6110 static int 6111 zfs_ioc_next_obj(zfs_cmd_t *zc) 6112 { 6113 objset_t *os = NULL; 6114 int error; 6115 6116 error = dmu_objset_hold(zc->zc_name, FTAG, &os); 6117 if (error != 0) 6118 return (error); 6119 6120 error = dmu_object_next(os, &zc->zc_obj, B_FALSE, 0); 6121 6122 dmu_objset_rele(os, FTAG); 6123 return (error); 6124 } 6125 6126 /* 6127 * inputs: 6128 * zc_name name of filesystem 6129 * zc_value prefix name for snapshot 6130 * zc_cleanup_fd cleanup-on-exit file descriptor for calling process 6131 * 6132 * outputs: 6133 * zc_value short name of new snapshot 6134 */ 6135 static int 6136 zfs_ioc_tmp_snapshot(zfs_cmd_t *zc) 6137 { 6138 char *snap_name; 6139 char *hold_name; 6140 minor_t minor; 6141 6142 zfs_file_t *fp = zfs_onexit_fd_hold(zc->zc_cleanup_fd, &minor); 6143 if (fp == NULL) 6144 return (SET_ERROR(EBADF)); 6145 6146 snap_name = kmem_asprintf("%s-%016llx", zc->zc_value, 6147 (u_longlong_t)ddi_get_lbolt64()); 6148 hold_name = kmem_asprintf("%%%s", zc->zc_value); 6149 6150 int error = dsl_dataset_snapshot_tmp(zc->zc_name, snap_name, minor, 6151 hold_name); 6152 if (error == 0) 6153 (void) strlcpy(zc->zc_value, snap_name, 6154 sizeof (zc->zc_value)); 6155 kmem_strfree(snap_name); 6156 kmem_strfree(hold_name); 6157 zfs_onexit_fd_rele(fp); 6158 return (error); 6159 } 6160 6161 /* 6162 * inputs: 6163 * zc_name name of "to" snapshot 6164 * zc_value name of "from" snapshot 6165 * zc_cookie file descriptor to write diff data on 6166 * 6167 * outputs: 6168 * dmu_diff_record_t's to the file descriptor 6169 */ 6170 static int 6171 zfs_ioc_diff(zfs_cmd_t *zc) 6172 { 6173 zfs_file_t *fp; 6174 offset_t off; 6175 int error; 6176 6177 if ((fp = zfs_file_get(zc->zc_cookie)) == NULL) 6178 return (SET_ERROR(EBADF)); 6179 6180 off = zfs_file_off(fp); 6181 error = dmu_diff(zc->zc_name, zc->zc_value, fp, &off); 6182 6183 zfs_file_put(fp); 6184 6185 return (error); 6186 } 6187 6188 static int 6189 zfs_ioc_smb_acl(zfs_cmd_t *zc) 6190 { 6191 return (SET_ERROR(ENOTSUP)); 6192 } 6193 6194 /* 6195 * innvl: { 6196 * "holds" -> { snapname -> holdname (string), ... } 6197 * (optional) "cleanup_fd" -> fd (int32) 6198 * } 6199 * 6200 * outnvl: { 6201 * snapname -> error value (int32) 6202 * ... 6203 * } 6204 */ 6205 static const zfs_ioc_key_t zfs_keys_hold[] = { 6206 {"holds", DATA_TYPE_NVLIST, 0}, 6207 {"cleanup_fd", DATA_TYPE_INT32, ZK_OPTIONAL}, 6208 }; 6209 6210 /* ARGSUSED */ 6211 static int 6212 zfs_ioc_hold(const char *pool, nvlist_t *args, nvlist_t *errlist) 6213 { 6214 nvpair_t *pair; 6215 nvlist_t *holds; 6216 int cleanup_fd = -1; 6217 int error; 6218 minor_t minor = 0; 6219 zfs_file_t *fp = NULL; 6220 6221 holds = fnvlist_lookup_nvlist(args, "holds"); 6222 6223 /* make sure the user didn't pass us any invalid (empty) tags */ 6224 for (pair = nvlist_next_nvpair(holds, NULL); pair != NULL; 6225 pair = nvlist_next_nvpair(holds, pair)) { 6226 char *htag; 6227 6228 error = nvpair_value_string(pair, &htag); 6229 if (error != 0) 6230 return (SET_ERROR(error)); 6231 6232 if (strlen(htag) == 0) 6233 return (SET_ERROR(EINVAL)); 6234 } 6235 6236 if (nvlist_lookup_int32(args, "cleanup_fd", &cleanup_fd) == 0) { 6237 fp = zfs_onexit_fd_hold(cleanup_fd, &minor); 6238 if (fp == NULL) 6239 return (SET_ERROR(EBADF)); 6240 } 6241 6242 error = dsl_dataset_user_hold(holds, minor, errlist); 6243 if (fp != NULL) { 6244 ASSERT3U(minor, !=, 0); 6245 zfs_onexit_fd_rele(fp); 6246 } 6247 return (SET_ERROR(error)); 6248 } 6249 6250 /* 6251 * innvl is not used. 6252 * 6253 * outnvl: { 6254 * holdname -> time added (uint64 seconds since epoch) 6255 * ... 6256 * } 6257 */ 6258 static const zfs_ioc_key_t zfs_keys_get_holds[] = { 6259 /* no nvl keys */ 6260 }; 6261 6262 /* ARGSUSED */ 6263 static int 6264 zfs_ioc_get_holds(const char *snapname, nvlist_t *args, nvlist_t *outnvl) 6265 { 6266 return (dsl_dataset_get_holds(snapname, outnvl)); 6267 } 6268 6269 /* 6270 * innvl: { 6271 * snapname -> { holdname, ... } 6272 * ... 6273 * } 6274 * 6275 * outnvl: { 6276 * snapname -> error value (int32) 6277 * ... 6278 * } 6279 */ 6280 static const zfs_ioc_key_t zfs_keys_release[] = { 6281 {"<snapname>...", DATA_TYPE_NVLIST, ZK_WILDCARDLIST}, 6282 }; 6283 6284 /* ARGSUSED */ 6285 static int 6286 zfs_ioc_release(const char *pool, nvlist_t *holds, nvlist_t *errlist) 6287 { 6288 return (dsl_dataset_user_release(holds, errlist)); 6289 } 6290 6291 /* 6292 * inputs: 6293 * zc_guid flags (ZEVENT_NONBLOCK) 6294 * zc_cleanup_fd zevent file descriptor 6295 * 6296 * outputs: 6297 * zc_nvlist_dst next nvlist event 6298 * zc_cookie dropped events since last get 6299 */ 6300 static int 6301 zfs_ioc_events_next(zfs_cmd_t *zc) 6302 { 6303 zfs_zevent_t *ze; 6304 nvlist_t *event = NULL; 6305 minor_t minor; 6306 uint64_t dropped = 0; 6307 int error; 6308 6309 zfs_file_t *fp = zfs_zevent_fd_hold(zc->zc_cleanup_fd, &minor, &ze); 6310 if (fp == NULL) 6311 return (SET_ERROR(EBADF)); 6312 6313 do { 6314 error = zfs_zevent_next(ze, &event, 6315 &zc->zc_nvlist_dst_size, &dropped); 6316 if (event != NULL) { 6317 zc->zc_cookie = dropped; 6318 error = put_nvlist(zc, event); 6319 nvlist_free(event); 6320 } 6321 6322 if (zc->zc_guid & ZEVENT_NONBLOCK) 6323 break; 6324 6325 if ((error == 0) || (error != ENOENT)) 6326 break; 6327 6328 error = zfs_zevent_wait(ze); 6329 if (error != 0) 6330 break; 6331 } while (1); 6332 6333 zfs_zevent_fd_rele(fp); 6334 6335 return (error); 6336 } 6337 6338 /* 6339 * outputs: 6340 * zc_cookie cleared events count 6341 */ 6342 static int 6343 zfs_ioc_events_clear(zfs_cmd_t *zc) 6344 { 6345 int count; 6346 6347 zfs_zevent_drain_all(&count); 6348 zc->zc_cookie = count; 6349 6350 return (0); 6351 } 6352 6353 /* 6354 * inputs: 6355 * zc_guid eid | ZEVENT_SEEK_START | ZEVENT_SEEK_END 6356 * zc_cleanup zevent file descriptor 6357 */ 6358 static int 6359 zfs_ioc_events_seek(zfs_cmd_t *zc) 6360 { 6361 zfs_zevent_t *ze; 6362 minor_t minor; 6363 int error; 6364 6365 zfs_file_t *fp = zfs_zevent_fd_hold(zc->zc_cleanup_fd, &minor, &ze); 6366 if (fp == NULL) 6367 return (SET_ERROR(EBADF)); 6368 6369 error = zfs_zevent_seek(ze, zc->zc_guid); 6370 zfs_zevent_fd_rele(fp); 6371 6372 return (error); 6373 } 6374 6375 /* 6376 * inputs: 6377 * zc_name name of later filesystem or snapshot 6378 * zc_value full name of old snapshot or bookmark 6379 * 6380 * outputs: 6381 * zc_cookie space in bytes 6382 * zc_objset_type compressed space in bytes 6383 * zc_perm_action uncompressed space in bytes 6384 */ 6385 static int 6386 zfs_ioc_space_written(zfs_cmd_t *zc) 6387 { 6388 int error; 6389 dsl_pool_t *dp; 6390 dsl_dataset_t *new; 6391 6392 error = dsl_pool_hold(zc->zc_name, FTAG, &dp); 6393 if (error != 0) 6394 return (error); 6395 error = dsl_dataset_hold(dp, zc->zc_name, FTAG, &new); 6396 if (error != 0) { 6397 dsl_pool_rele(dp, FTAG); 6398 return (error); 6399 } 6400 if (strchr(zc->zc_value, '#') != NULL) { 6401 zfs_bookmark_phys_t bmp; 6402 error = dsl_bookmark_lookup(dp, zc->zc_value, 6403 new, &bmp); 6404 if (error == 0) { 6405 error = dsl_dataset_space_written_bookmark(&bmp, new, 6406 &zc->zc_cookie, 6407 &zc->zc_objset_type, &zc->zc_perm_action); 6408 } 6409 } else { 6410 dsl_dataset_t *old; 6411 error = dsl_dataset_hold(dp, zc->zc_value, FTAG, &old); 6412 6413 if (error == 0) { 6414 error = dsl_dataset_space_written(old, new, 6415 &zc->zc_cookie, 6416 &zc->zc_objset_type, &zc->zc_perm_action); 6417 dsl_dataset_rele(old, FTAG); 6418 } 6419 } 6420 dsl_dataset_rele(new, FTAG); 6421 dsl_pool_rele(dp, FTAG); 6422 return (error); 6423 } 6424 6425 /* 6426 * innvl: { 6427 * "firstsnap" -> snapshot name 6428 * } 6429 * 6430 * outnvl: { 6431 * "used" -> space in bytes 6432 * "compressed" -> compressed space in bytes 6433 * "uncompressed" -> uncompressed space in bytes 6434 * } 6435 */ 6436 static const zfs_ioc_key_t zfs_keys_space_snaps[] = { 6437 {"firstsnap", DATA_TYPE_STRING, 0}, 6438 }; 6439 6440 static int 6441 zfs_ioc_space_snaps(const char *lastsnap, nvlist_t *innvl, nvlist_t *outnvl) 6442 { 6443 int error; 6444 dsl_pool_t *dp; 6445 dsl_dataset_t *new, *old; 6446 char *firstsnap; 6447 uint64_t used, comp, uncomp; 6448 6449 firstsnap = fnvlist_lookup_string(innvl, "firstsnap"); 6450 6451 error = dsl_pool_hold(lastsnap, FTAG, &dp); 6452 if (error != 0) 6453 return (error); 6454 6455 error = dsl_dataset_hold(dp, lastsnap, FTAG, &new); 6456 if (error == 0 && !new->ds_is_snapshot) { 6457 dsl_dataset_rele(new, FTAG); 6458 error = SET_ERROR(EINVAL); 6459 } 6460 if (error != 0) { 6461 dsl_pool_rele(dp, FTAG); 6462 return (error); 6463 } 6464 error = dsl_dataset_hold(dp, firstsnap, FTAG, &old); 6465 if (error == 0 && !old->ds_is_snapshot) { 6466 dsl_dataset_rele(old, FTAG); 6467 error = SET_ERROR(EINVAL); 6468 } 6469 if (error != 0) { 6470 dsl_dataset_rele(new, FTAG); 6471 dsl_pool_rele(dp, FTAG); 6472 return (error); 6473 } 6474 6475 error = dsl_dataset_space_wouldfree(old, new, &used, &comp, &uncomp); 6476 dsl_dataset_rele(old, FTAG); 6477 dsl_dataset_rele(new, FTAG); 6478 dsl_pool_rele(dp, FTAG); 6479 fnvlist_add_uint64(outnvl, "used", used); 6480 fnvlist_add_uint64(outnvl, "compressed", comp); 6481 fnvlist_add_uint64(outnvl, "uncompressed", uncomp); 6482 return (error); 6483 } 6484 6485 /* 6486 * innvl: { 6487 * "fd" -> file descriptor to write stream to (int32) 6488 * (optional) "fromsnap" -> full snap name to send an incremental from 6489 * (optional) "largeblockok" -> (value ignored) 6490 * indicates that blocks > 128KB are permitted 6491 * (optional) "embedok" -> (value ignored) 6492 * presence indicates DRR_WRITE_EMBEDDED records are permitted 6493 * (optional) "compressok" -> (value ignored) 6494 * presence indicates compressed DRR_WRITE records are permitted 6495 * (optional) "rawok" -> (value ignored) 6496 * presence indicates raw encrypted records should be used. 6497 * (optional) "savedok" -> (value ignored) 6498 * presence indicates we should send a partially received snapshot 6499 * (optional) "resume_object" and "resume_offset" -> (uint64) 6500 * if present, resume send stream from specified object and offset. 6501 * (optional) "redactbook" -> (string) 6502 * if present, use this bookmark's redaction list to generate a redacted 6503 * send stream 6504 * } 6505 * 6506 * outnvl is unused 6507 */ 6508 static const zfs_ioc_key_t zfs_keys_send_new[] = { 6509 {"fd", DATA_TYPE_INT32, 0}, 6510 {"fromsnap", DATA_TYPE_STRING, ZK_OPTIONAL}, 6511 {"largeblockok", DATA_TYPE_BOOLEAN, ZK_OPTIONAL}, 6512 {"embedok", DATA_TYPE_BOOLEAN, ZK_OPTIONAL}, 6513 {"compressok", DATA_TYPE_BOOLEAN, ZK_OPTIONAL}, 6514 {"rawok", DATA_TYPE_BOOLEAN, ZK_OPTIONAL}, 6515 {"savedok", DATA_TYPE_BOOLEAN, ZK_OPTIONAL}, 6516 {"resume_object", DATA_TYPE_UINT64, ZK_OPTIONAL}, 6517 {"resume_offset", DATA_TYPE_UINT64, ZK_OPTIONAL}, 6518 {"redactbook", DATA_TYPE_STRING, ZK_OPTIONAL}, 6519 }; 6520 6521 /* ARGSUSED */ 6522 static int 6523 zfs_ioc_send_new(const char *snapname, nvlist_t *innvl, nvlist_t *outnvl) 6524 { 6525 int error; 6526 offset_t off; 6527 char *fromname = NULL; 6528 int fd; 6529 zfs_file_t *fp; 6530 boolean_t largeblockok; 6531 boolean_t embedok; 6532 boolean_t compressok; 6533 boolean_t rawok; 6534 boolean_t savedok; 6535 uint64_t resumeobj = 0; 6536 uint64_t resumeoff = 0; 6537 char *redactbook = NULL; 6538 6539 fd = fnvlist_lookup_int32(innvl, "fd"); 6540 6541 (void) nvlist_lookup_string(innvl, "fromsnap", &fromname); 6542 6543 largeblockok = nvlist_exists(innvl, "largeblockok"); 6544 embedok = nvlist_exists(innvl, "embedok"); 6545 compressok = nvlist_exists(innvl, "compressok"); 6546 rawok = nvlist_exists(innvl, "rawok"); 6547 savedok = nvlist_exists(innvl, "savedok"); 6548 6549 (void) nvlist_lookup_uint64(innvl, "resume_object", &resumeobj); 6550 (void) nvlist_lookup_uint64(innvl, "resume_offset", &resumeoff); 6551 6552 (void) nvlist_lookup_string(innvl, "redactbook", &redactbook); 6553 6554 if ((fp = zfs_file_get(fd)) == NULL) 6555 return (SET_ERROR(EBADF)); 6556 6557 off = zfs_file_off(fp); 6558 6559 dmu_send_outparams_t out = {0}; 6560 out.dso_outfunc = dump_bytes; 6561 out.dso_arg = fp; 6562 out.dso_dryrun = B_FALSE; 6563 error = dmu_send(snapname, fromname, embedok, largeblockok, 6564 compressok, rawok, savedok, resumeobj, resumeoff, 6565 redactbook, fd, &off, &out); 6566 6567 zfs_file_put(fp); 6568 return (error); 6569 } 6570 6571 /* ARGSUSED */ 6572 static int 6573 send_space_sum(objset_t *os, void *buf, int len, void *arg) 6574 { 6575 uint64_t *size = arg; 6576 *size += len; 6577 return (0); 6578 } 6579 6580 /* 6581 * Determine approximately how large a zfs send stream will be -- the number 6582 * of bytes that will be written to the fd supplied to zfs_ioc_send_new(). 6583 * 6584 * innvl: { 6585 * (optional) "from" -> full snap or bookmark name to send an incremental 6586 * from 6587 * (optional) "largeblockok" -> (value ignored) 6588 * indicates that blocks > 128KB are permitted 6589 * (optional) "embedok" -> (value ignored) 6590 * presence indicates DRR_WRITE_EMBEDDED records are permitted 6591 * (optional) "compressok" -> (value ignored) 6592 * presence indicates compressed DRR_WRITE records are permitted 6593 * (optional) "rawok" -> (value ignored) 6594 * presence indicates raw encrypted records should be used. 6595 * (optional) "resume_object" and "resume_offset" -> (uint64) 6596 * if present, resume send stream from specified object and offset. 6597 * (optional) "fd" -> file descriptor to use as a cookie for progress 6598 * tracking (int32) 6599 * } 6600 * 6601 * outnvl: { 6602 * "space" -> bytes of space (uint64) 6603 * } 6604 */ 6605 static const zfs_ioc_key_t zfs_keys_send_space[] = { 6606 {"from", DATA_TYPE_STRING, ZK_OPTIONAL}, 6607 {"fromsnap", DATA_TYPE_STRING, ZK_OPTIONAL}, 6608 {"largeblockok", DATA_TYPE_BOOLEAN, ZK_OPTIONAL}, 6609 {"embedok", DATA_TYPE_BOOLEAN, ZK_OPTIONAL}, 6610 {"compressok", DATA_TYPE_BOOLEAN, ZK_OPTIONAL}, 6611 {"rawok", DATA_TYPE_BOOLEAN, ZK_OPTIONAL}, 6612 {"fd", DATA_TYPE_INT32, ZK_OPTIONAL}, 6613 {"redactbook", DATA_TYPE_STRING, ZK_OPTIONAL}, 6614 {"resume_object", DATA_TYPE_UINT64, ZK_OPTIONAL}, 6615 {"resume_offset", DATA_TYPE_UINT64, ZK_OPTIONAL}, 6616 {"bytes", DATA_TYPE_UINT64, ZK_OPTIONAL}, 6617 }; 6618 6619 static int 6620 zfs_ioc_send_space(const char *snapname, nvlist_t *innvl, nvlist_t *outnvl) 6621 { 6622 dsl_pool_t *dp; 6623 dsl_dataset_t *tosnap; 6624 dsl_dataset_t *fromsnap = NULL; 6625 int error; 6626 char *fromname = NULL; 6627 char *redactlist_book = NULL; 6628 boolean_t largeblockok; 6629 boolean_t embedok; 6630 boolean_t compressok; 6631 boolean_t rawok; 6632 boolean_t savedok; 6633 uint64_t space = 0; 6634 boolean_t full_estimate = B_FALSE; 6635 uint64_t resumeobj = 0; 6636 uint64_t resumeoff = 0; 6637 uint64_t resume_bytes = 0; 6638 int32_t fd = -1; 6639 zfs_bookmark_phys_t zbm = {0}; 6640 6641 error = dsl_pool_hold(snapname, FTAG, &dp); 6642 if (error != 0) 6643 return (error); 6644 6645 error = dsl_dataset_hold(dp, snapname, FTAG, &tosnap); 6646 if (error != 0) { 6647 dsl_pool_rele(dp, FTAG); 6648 return (error); 6649 } 6650 (void) nvlist_lookup_int32(innvl, "fd", &fd); 6651 6652 largeblockok = nvlist_exists(innvl, "largeblockok"); 6653 embedok = nvlist_exists(innvl, "embedok"); 6654 compressok = nvlist_exists(innvl, "compressok"); 6655 rawok = nvlist_exists(innvl, "rawok"); 6656 savedok = nvlist_exists(innvl, "savedok"); 6657 boolean_t from = (nvlist_lookup_string(innvl, "from", &fromname) == 0); 6658 boolean_t altbook = (nvlist_lookup_string(innvl, "redactbook", 6659 &redactlist_book) == 0); 6660 6661 (void) nvlist_lookup_uint64(innvl, "resume_object", &resumeobj); 6662 (void) nvlist_lookup_uint64(innvl, "resume_offset", &resumeoff); 6663 (void) nvlist_lookup_uint64(innvl, "bytes", &resume_bytes); 6664 6665 if (altbook) { 6666 full_estimate = B_TRUE; 6667 } else if (from) { 6668 if (strchr(fromname, '#')) { 6669 error = dsl_bookmark_lookup(dp, fromname, tosnap, &zbm); 6670 6671 /* 6672 * dsl_bookmark_lookup() will fail with EXDEV if 6673 * the from-bookmark and tosnap are at the same txg. 6674 * However, it's valid to do a send (and therefore, 6675 * a send estimate) from and to the same time point, 6676 * if the bookmark is redacted (the incremental send 6677 * can change what's redacted on the target). In 6678 * this case, dsl_bookmark_lookup() fills in zbm 6679 * but returns EXDEV. Ignore this error. 6680 */ 6681 if (error == EXDEV && zbm.zbm_redaction_obj != 0 && 6682 zbm.zbm_guid == 6683 dsl_dataset_phys(tosnap)->ds_guid) 6684 error = 0; 6685 6686 if (error != 0) { 6687 dsl_dataset_rele(tosnap, FTAG); 6688 dsl_pool_rele(dp, FTAG); 6689 return (error); 6690 } 6691 if (zbm.zbm_redaction_obj != 0 || !(zbm.zbm_flags & 6692 ZBM_FLAG_HAS_FBN)) { 6693 full_estimate = B_TRUE; 6694 } 6695 } else if (strchr(fromname, '@')) { 6696 error = dsl_dataset_hold(dp, fromname, FTAG, &fromsnap); 6697 if (error != 0) { 6698 dsl_dataset_rele(tosnap, FTAG); 6699 dsl_pool_rele(dp, FTAG); 6700 return (error); 6701 } 6702 6703 if (!dsl_dataset_is_before(tosnap, fromsnap, 0)) { 6704 full_estimate = B_TRUE; 6705 dsl_dataset_rele(fromsnap, FTAG); 6706 } 6707 } else { 6708 /* 6709 * from is not properly formatted as a snapshot or 6710 * bookmark 6711 */ 6712 dsl_dataset_rele(tosnap, FTAG); 6713 dsl_pool_rele(dp, FTAG); 6714 return (SET_ERROR(EINVAL)); 6715 } 6716 } 6717 6718 if (full_estimate) { 6719 dmu_send_outparams_t out = {0}; 6720 offset_t off = 0; 6721 out.dso_outfunc = send_space_sum; 6722 out.dso_arg = &space; 6723 out.dso_dryrun = B_TRUE; 6724 /* 6725 * We have to release these holds so dmu_send can take them. It 6726 * will do all the error checking we need. 6727 */ 6728 dsl_dataset_rele(tosnap, FTAG); 6729 dsl_pool_rele(dp, FTAG); 6730 error = dmu_send(snapname, fromname, embedok, largeblockok, 6731 compressok, rawok, savedok, resumeobj, resumeoff, 6732 redactlist_book, fd, &off, &out); 6733 } else { 6734 error = dmu_send_estimate_fast(tosnap, fromsnap, 6735 (from && strchr(fromname, '#') != NULL ? &zbm : NULL), 6736 compressok || rawok, savedok, &space); 6737 space -= resume_bytes; 6738 if (fromsnap != NULL) 6739 dsl_dataset_rele(fromsnap, FTAG); 6740 dsl_dataset_rele(tosnap, FTAG); 6741 dsl_pool_rele(dp, FTAG); 6742 } 6743 6744 fnvlist_add_uint64(outnvl, "space", space); 6745 6746 return (error); 6747 } 6748 6749 /* 6750 * Sync the currently open TXG to disk for the specified pool. 6751 * This is somewhat similar to 'zfs_sync()'. 6752 * For cases that do not result in error this ioctl will wait for 6753 * the currently open TXG to commit before returning back to the caller. 6754 * 6755 * innvl: { 6756 * "force" -> when true, force uberblock update even if there is no dirty data. 6757 * In addition this will cause the vdev configuration to be written 6758 * out including updating the zpool cache file. (boolean_t) 6759 * } 6760 * 6761 * onvl is unused 6762 */ 6763 static const zfs_ioc_key_t zfs_keys_pool_sync[] = { 6764 {"force", DATA_TYPE_BOOLEAN_VALUE, 0}, 6765 }; 6766 6767 /* ARGSUSED */ 6768 static int 6769 zfs_ioc_pool_sync(const char *pool, nvlist_t *innvl, nvlist_t *onvl) 6770 { 6771 int err; 6772 boolean_t rc, force = B_FALSE; 6773 spa_t *spa; 6774 6775 if ((err = spa_open(pool, &spa, FTAG)) != 0) 6776 return (err); 6777 6778 if (innvl) { 6779 err = nvlist_lookup_boolean_value(innvl, "force", &rc); 6780 if (err == 0) 6781 force = rc; 6782 } 6783 6784 if (force) { 6785 spa_config_enter(spa, SCL_CONFIG, FTAG, RW_WRITER); 6786 vdev_config_dirty(spa->spa_root_vdev); 6787 spa_config_exit(spa, SCL_CONFIG, FTAG); 6788 } 6789 txg_wait_synced(spa_get_dsl(spa), 0); 6790 6791 spa_close(spa, FTAG); 6792 6793 return (0); 6794 } 6795 6796 /* 6797 * Load a user's wrapping key into the kernel. 6798 * innvl: { 6799 * "hidden_args" -> { "wkeydata" -> value } 6800 * raw uint8_t array of encryption wrapping key data (32 bytes) 6801 * (optional) "noop" -> (value ignored) 6802 * presence indicated key should only be verified, not loaded 6803 * } 6804 */ 6805 static const zfs_ioc_key_t zfs_keys_load_key[] = { 6806 {"hidden_args", DATA_TYPE_NVLIST, 0}, 6807 {"noop", DATA_TYPE_BOOLEAN, ZK_OPTIONAL}, 6808 }; 6809 6810 /* ARGSUSED */ 6811 static int 6812 zfs_ioc_load_key(const char *dsname, nvlist_t *innvl, nvlist_t *outnvl) 6813 { 6814 int ret; 6815 dsl_crypto_params_t *dcp = NULL; 6816 nvlist_t *hidden_args; 6817 boolean_t noop = nvlist_exists(innvl, "noop"); 6818 6819 if (strchr(dsname, '@') != NULL || strchr(dsname, '%') != NULL) { 6820 ret = SET_ERROR(EINVAL); 6821 goto error; 6822 } 6823 6824 hidden_args = fnvlist_lookup_nvlist(innvl, ZPOOL_HIDDEN_ARGS); 6825 6826 ret = dsl_crypto_params_create_nvlist(DCP_CMD_NONE, NULL, 6827 hidden_args, &dcp); 6828 if (ret != 0) 6829 goto error; 6830 6831 ret = spa_keystore_load_wkey(dsname, dcp, noop); 6832 if (ret != 0) 6833 goto error; 6834 6835 dsl_crypto_params_free(dcp, noop); 6836 6837 return (0); 6838 6839 error: 6840 dsl_crypto_params_free(dcp, B_TRUE); 6841 return (ret); 6842 } 6843 6844 /* 6845 * Unload a user's wrapping key from the kernel. 6846 * Both innvl and outnvl are unused. 6847 */ 6848 static const zfs_ioc_key_t zfs_keys_unload_key[] = { 6849 /* no nvl keys */ 6850 }; 6851 6852 /* ARGSUSED */ 6853 static int 6854 zfs_ioc_unload_key(const char *dsname, nvlist_t *innvl, nvlist_t *outnvl) 6855 { 6856 int ret = 0; 6857 6858 if (strchr(dsname, '@') != NULL || strchr(dsname, '%') != NULL) { 6859 ret = (SET_ERROR(EINVAL)); 6860 goto out; 6861 } 6862 6863 ret = spa_keystore_unload_wkey(dsname); 6864 if (ret != 0) 6865 goto out; 6866 6867 out: 6868 return (ret); 6869 } 6870 6871 /* 6872 * Changes a user's wrapping key used to decrypt a dataset. The keyformat, 6873 * keylocation, pbkdf2salt, and pbkdf2iters properties can also be specified 6874 * here to change how the key is derived in userspace. 6875 * 6876 * innvl: { 6877 * "hidden_args" (optional) -> { "wkeydata" -> value } 6878 * raw uint8_t array of new encryption wrapping key data (32 bytes) 6879 * "props" (optional) -> { prop -> value } 6880 * } 6881 * 6882 * outnvl is unused 6883 */ 6884 static const zfs_ioc_key_t zfs_keys_change_key[] = { 6885 {"crypt_cmd", DATA_TYPE_UINT64, ZK_OPTIONAL}, 6886 {"hidden_args", DATA_TYPE_NVLIST, ZK_OPTIONAL}, 6887 {"props", DATA_TYPE_NVLIST, ZK_OPTIONAL}, 6888 }; 6889 6890 /* ARGSUSED */ 6891 static int 6892 zfs_ioc_change_key(const char *dsname, nvlist_t *innvl, nvlist_t *outnvl) 6893 { 6894 int ret; 6895 uint64_t cmd = DCP_CMD_NONE; 6896 dsl_crypto_params_t *dcp = NULL; 6897 nvlist_t *args = NULL, *hidden_args = NULL; 6898 6899 if (strchr(dsname, '@') != NULL || strchr(dsname, '%') != NULL) { 6900 ret = (SET_ERROR(EINVAL)); 6901 goto error; 6902 } 6903 6904 (void) nvlist_lookup_uint64(innvl, "crypt_cmd", &cmd); 6905 (void) nvlist_lookup_nvlist(innvl, "props", &args); 6906 (void) nvlist_lookup_nvlist(innvl, ZPOOL_HIDDEN_ARGS, &hidden_args); 6907 6908 ret = dsl_crypto_params_create_nvlist(cmd, args, hidden_args, &dcp); 6909 if (ret != 0) 6910 goto error; 6911 6912 ret = spa_keystore_change_key(dsname, dcp); 6913 if (ret != 0) 6914 goto error; 6915 6916 dsl_crypto_params_free(dcp, B_FALSE); 6917 6918 return (0); 6919 6920 error: 6921 dsl_crypto_params_free(dcp, B_TRUE); 6922 return (ret); 6923 } 6924 6925 static zfs_ioc_vec_t zfs_ioc_vec[ZFS_IOC_LAST - ZFS_IOC_FIRST]; 6926 6927 static void 6928 zfs_ioctl_register_legacy(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func, 6929 zfs_secpolicy_func_t *secpolicy, zfs_ioc_namecheck_t namecheck, 6930 boolean_t log_history, zfs_ioc_poolcheck_t pool_check) 6931 { 6932 zfs_ioc_vec_t *vec = &zfs_ioc_vec[ioc - ZFS_IOC_FIRST]; 6933 6934 ASSERT3U(ioc, >=, ZFS_IOC_FIRST); 6935 ASSERT3U(ioc, <, ZFS_IOC_LAST); 6936 ASSERT3P(vec->zvec_legacy_func, ==, NULL); 6937 ASSERT3P(vec->zvec_func, ==, NULL); 6938 6939 vec->zvec_legacy_func = func; 6940 vec->zvec_secpolicy = secpolicy; 6941 vec->zvec_namecheck = namecheck; 6942 vec->zvec_allow_log = log_history; 6943 vec->zvec_pool_check = pool_check; 6944 } 6945 6946 /* 6947 * See the block comment at the beginning of this file for details on 6948 * each argument to this function. 6949 */ 6950 void 6951 zfs_ioctl_register(const char *name, zfs_ioc_t ioc, zfs_ioc_func_t *func, 6952 zfs_secpolicy_func_t *secpolicy, zfs_ioc_namecheck_t namecheck, 6953 zfs_ioc_poolcheck_t pool_check, boolean_t smush_outnvlist, 6954 boolean_t allow_log, const zfs_ioc_key_t *nvl_keys, size_t num_keys) 6955 { 6956 zfs_ioc_vec_t *vec = &zfs_ioc_vec[ioc - ZFS_IOC_FIRST]; 6957 6958 ASSERT3U(ioc, >=, ZFS_IOC_FIRST); 6959 ASSERT3U(ioc, <, ZFS_IOC_LAST); 6960 ASSERT3P(vec->zvec_legacy_func, ==, NULL); 6961 ASSERT3P(vec->zvec_func, ==, NULL); 6962 6963 /* if we are logging, the name must be valid */ 6964 ASSERT(!allow_log || namecheck != NO_NAME); 6965 6966 vec->zvec_name = name; 6967 vec->zvec_func = func; 6968 vec->zvec_secpolicy = secpolicy; 6969 vec->zvec_namecheck = namecheck; 6970 vec->zvec_pool_check = pool_check; 6971 vec->zvec_smush_outnvlist = smush_outnvlist; 6972 vec->zvec_allow_log = allow_log; 6973 vec->zvec_nvl_keys = nvl_keys; 6974 vec->zvec_nvl_key_count = num_keys; 6975 } 6976 6977 static void 6978 zfs_ioctl_register_pool(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func, 6979 zfs_secpolicy_func_t *secpolicy, boolean_t log_history, 6980 zfs_ioc_poolcheck_t pool_check) 6981 { 6982 zfs_ioctl_register_legacy(ioc, func, secpolicy, 6983 POOL_NAME, log_history, pool_check); 6984 } 6985 6986 void 6987 zfs_ioctl_register_dataset_nolog(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func, 6988 zfs_secpolicy_func_t *secpolicy, zfs_ioc_poolcheck_t pool_check) 6989 { 6990 zfs_ioctl_register_legacy(ioc, func, secpolicy, 6991 DATASET_NAME, B_FALSE, pool_check); 6992 } 6993 6994 static void 6995 zfs_ioctl_register_pool_modify(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func) 6996 { 6997 zfs_ioctl_register_legacy(ioc, func, zfs_secpolicy_config, 6998 POOL_NAME, B_TRUE, POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY); 6999 } 7000 7001 static void 7002 zfs_ioctl_register_pool_meta(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func, 7003 zfs_secpolicy_func_t *secpolicy) 7004 { 7005 zfs_ioctl_register_legacy(ioc, func, secpolicy, 7006 NO_NAME, B_FALSE, POOL_CHECK_NONE); 7007 } 7008 7009 static void 7010 zfs_ioctl_register_dataset_read_secpolicy(zfs_ioc_t ioc, 7011 zfs_ioc_legacy_func_t *func, zfs_secpolicy_func_t *secpolicy) 7012 { 7013 zfs_ioctl_register_legacy(ioc, func, secpolicy, 7014 DATASET_NAME, B_FALSE, POOL_CHECK_SUSPENDED); 7015 } 7016 7017 static void 7018 zfs_ioctl_register_dataset_read(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func) 7019 { 7020 zfs_ioctl_register_dataset_read_secpolicy(ioc, func, 7021 zfs_secpolicy_read); 7022 } 7023 7024 static void 7025 zfs_ioctl_register_dataset_modify(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func, 7026 zfs_secpolicy_func_t *secpolicy) 7027 { 7028 zfs_ioctl_register_legacy(ioc, func, secpolicy, 7029 DATASET_NAME, B_TRUE, POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY); 7030 } 7031 7032 static void 7033 zfs_ioctl_init(void) 7034 { 7035 zfs_ioctl_register("snapshot", ZFS_IOC_SNAPSHOT, 7036 zfs_ioc_snapshot, zfs_secpolicy_snapshot, POOL_NAME, 7037 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE, 7038 zfs_keys_snapshot, ARRAY_SIZE(zfs_keys_snapshot)); 7039 7040 zfs_ioctl_register("log_history", ZFS_IOC_LOG_HISTORY, 7041 zfs_ioc_log_history, zfs_secpolicy_log_history, NO_NAME, 7042 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_FALSE, B_FALSE, 7043 zfs_keys_log_history, ARRAY_SIZE(zfs_keys_log_history)); 7044 7045 zfs_ioctl_register("space_snaps", ZFS_IOC_SPACE_SNAPS, 7046 zfs_ioc_space_snaps, zfs_secpolicy_read, DATASET_NAME, 7047 POOL_CHECK_SUSPENDED, B_FALSE, B_FALSE, 7048 zfs_keys_space_snaps, ARRAY_SIZE(zfs_keys_space_snaps)); 7049 7050 zfs_ioctl_register("send", ZFS_IOC_SEND_NEW, 7051 zfs_ioc_send_new, zfs_secpolicy_send_new, DATASET_NAME, 7052 POOL_CHECK_SUSPENDED, B_FALSE, B_FALSE, 7053 zfs_keys_send_new, ARRAY_SIZE(zfs_keys_send_new)); 7054 7055 zfs_ioctl_register("send_space", ZFS_IOC_SEND_SPACE, 7056 zfs_ioc_send_space, zfs_secpolicy_read, DATASET_NAME, 7057 POOL_CHECK_SUSPENDED, B_FALSE, B_FALSE, 7058 zfs_keys_send_space, ARRAY_SIZE(zfs_keys_send_space)); 7059 7060 zfs_ioctl_register("create", ZFS_IOC_CREATE, 7061 zfs_ioc_create, zfs_secpolicy_create_clone, DATASET_NAME, 7062 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE, 7063 zfs_keys_create, ARRAY_SIZE(zfs_keys_create)); 7064 7065 zfs_ioctl_register("clone", ZFS_IOC_CLONE, 7066 zfs_ioc_clone, zfs_secpolicy_create_clone, DATASET_NAME, 7067 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE, 7068 zfs_keys_clone, ARRAY_SIZE(zfs_keys_clone)); 7069 7070 zfs_ioctl_register("remap", ZFS_IOC_REMAP, 7071 zfs_ioc_remap, zfs_secpolicy_none, DATASET_NAME, 7072 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_FALSE, B_TRUE, 7073 zfs_keys_remap, ARRAY_SIZE(zfs_keys_remap)); 7074 7075 zfs_ioctl_register("destroy_snaps", ZFS_IOC_DESTROY_SNAPS, 7076 zfs_ioc_destroy_snaps, zfs_secpolicy_destroy_snaps, POOL_NAME, 7077 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE, 7078 zfs_keys_destroy_snaps, ARRAY_SIZE(zfs_keys_destroy_snaps)); 7079 7080 zfs_ioctl_register("hold", ZFS_IOC_HOLD, 7081 zfs_ioc_hold, zfs_secpolicy_hold, POOL_NAME, 7082 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE, 7083 zfs_keys_hold, ARRAY_SIZE(zfs_keys_hold)); 7084 zfs_ioctl_register("release", ZFS_IOC_RELEASE, 7085 zfs_ioc_release, zfs_secpolicy_release, POOL_NAME, 7086 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE, 7087 zfs_keys_release, ARRAY_SIZE(zfs_keys_release)); 7088 7089 zfs_ioctl_register("get_holds", ZFS_IOC_GET_HOLDS, 7090 zfs_ioc_get_holds, zfs_secpolicy_read, DATASET_NAME, 7091 POOL_CHECK_SUSPENDED, B_FALSE, B_FALSE, 7092 zfs_keys_get_holds, ARRAY_SIZE(zfs_keys_get_holds)); 7093 7094 zfs_ioctl_register("rollback", ZFS_IOC_ROLLBACK, 7095 zfs_ioc_rollback, zfs_secpolicy_rollback, DATASET_NAME, 7096 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_FALSE, B_TRUE, 7097 zfs_keys_rollback, ARRAY_SIZE(zfs_keys_rollback)); 7098 7099 zfs_ioctl_register("bookmark", ZFS_IOC_BOOKMARK, 7100 zfs_ioc_bookmark, zfs_secpolicy_bookmark, POOL_NAME, 7101 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE, 7102 zfs_keys_bookmark, ARRAY_SIZE(zfs_keys_bookmark)); 7103 7104 zfs_ioctl_register("get_bookmarks", ZFS_IOC_GET_BOOKMARKS, 7105 zfs_ioc_get_bookmarks, zfs_secpolicy_read, DATASET_NAME, 7106 POOL_CHECK_SUSPENDED, B_FALSE, B_FALSE, 7107 zfs_keys_get_bookmarks, ARRAY_SIZE(zfs_keys_get_bookmarks)); 7108 7109 zfs_ioctl_register("get_bookmark_props", ZFS_IOC_GET_BOOKMARK_PROPS, 7110 zfs_ioc_get_bookmark_props, zfs_secpolicy_read, ENTITY_NAME, 7111 POOL_CHECK_SUSPENDED, B_FALSE, B_FALSE, zfs_keys_get_bookmark_props, 7112 ARRAY_SIZE(zfs_keys_get_bookmark_props)); 7113 7114 zfs_ioctl_register("destroy_bookmarks", ZFS_IOC_DESTROY_BOOKMARKS, 7115 zfs_ioc_destroy_bookmarks, zfs_secpolicy_destroy_bookmarks, 7116 POOL_NAME, 7117 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE, 7118 zfs_keys_destroy_bookmarks, 7119 ARRAY_SIZE(zfs_keys_destroy_bookmarks)); 7120 7121 zfs_ioctl_register("receive", ZFS_IOC_RECV_NEW, 7122 zfs_ioc_recv_new, zfs_secpolicy_recv_new, DATASET_NAME, 7123 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE, 7124 zfs_keys_recv_new, ARRAY_SIZE(zfs_keys_recv_new)); 7125 zfs_ioctl_register("load-key", ZFS_IOC_LOAD_KEY, 7126 zfs_ioc_load_key, zfs_secpolicy_load_key, 7127 DATASET_NAME, POOL_CHECK_SUSPENDED, B_TRUE, B_TRUE, 7128 zfs_keys_load_key, ARRAY_SIZE(zfs_keys_load_key)); 7129 zfs_ioctl_register("unload-key", ZFS_IOC_UNLOAD_KEY, 7130 zfs_ioc_unload_key, zfs_secpolicy_load_key, 7131 DATASET_NAME, POOL_CHECK_SUSPENDED, B_TRUE, B_TRUE, 7132 zfs_keys_unload_key, ARRAY_SIZE(zfs_keys_unload_key)); 7133 zfs_ioctl_register("change-key", ZFS_IOC_CHANGE_KEY, 7134 zfs_ioc_change_key, zfs_secpolicy_change_key, 7135 DATASET_NAME, POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, 7136 B_TRUE, B_TRUE, zfs_keys_change_key, 7137 ARRAY_SIZE(zfs_keys_change_key)); 7138 7139 zfs_ioctl_register("sync", ZFS_IOC_POOL_SYNC, 7140 zfs_ioc_pool_sync, zfs_secpolicy_none, POOL_NAME, 7141 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_FALSE, B_FALSE, 7142 zfs_keys_pool_sync, ARRAY_SIZE(zfs_keys_pool_sync)); 7143 zfs_ioctl_register("reopen", ZFS_IOC_POOL_REOPEN, zfs_ioc_pool_reopen, 7144 zfs_secpolicy_config, POOL_NAME, POOL_CHECK_SUSPENDED, B_TRUE, 7145 B_TRUE, zfs_keys_pool_reopen, ARRAY_SIZE(zfs_keys_pool_reopen)); 7146 7147 zfs_ioctl_register("channel_program", ZFS_IOC_CHANNEL_PROGRAM, 7148 zfs_ioc_channel_program, zfs_secpolicy_config, 7149 POOL_NAME, POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, 7150 B_TRUE, zfs_keys_channel_program, 7151 ARRAY_SIZE(zfs_keys_channel_program)); 7152 7153 zfs_ioctl_register("redact", ZFS_IOC_REDACT, 7154 zfs_ioc_redact, zfs_secpolicy_config, DATASET_NAME, 7155 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE, 7156 zfs_keys_redact, ARRAY_SIZE(zfs_keys_redact)); 7157 7158 zfs_ioctl_register("zpool_checkpoint", ZFS_IOC_POOL_CHECKPOINT, 7159 zfs_ioc_pool_checkpoint, zfs_secpolicy_config, POOL_NAME, 7160 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE, 7161 zfs_keys_pool_checkpoint, ARRAY_SIZE(zfs_keys_pool_checkpoint)); 7162 7163 zfs_ioctl_register("zpool_discard_checkpoint", 7164 ZFS_IOC_POOL_DISCARD_CHECKPOINT, zfs_ioc_pool_discard_checkpoint, 7165 zfs_secpolicy_config, POOL_NAME, 7166 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE, 7167 zfs_keys_pool_discard_checkpoint, 7168 ARRAY_SIZE(zfs_keys_pool_discard_checkpoint)); 7169 7170 zfs_ioctl_register("initialize", ZFS_IOC_POOL_INITIALIZE, 7171 zfs_ioc_pool_initialize, zfs_secpolicy_config, POOL_NAME, 7172 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE, 7173 zfs_keys_pool_initialize, ARRAY_SIZE(zfs_keys_pool_initialize)); 7174 7175 zfs_ioctl_register("trim", ZFS_IOC_POOL_TRIM, 7176 zfs_ioc_pool_trim, zfs_secpolicy_config, POOL_NAME, 7177 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_TRUE, B_TRUE, 7178 zfs_keys_pool_trim, ARRAY_SIZE(zfs_keys_pool_trim)); 7179 7180 zfs_ioctl_register("wait", ZFS_IOC_WAIT, 7181 zfs_ioc_wait, zfs_secpolicy_none, POOL_NAME, 7182 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_FALSE, B_FALSE, 7183 zfs_keys_pool_wait, ARRAY_SIZE(zfs_keys_pool_wait)); 7184 7185 zfs_ioctl_register("wait_fs", ZFS_IOC_WAIT_FS, 7186 zfs_ioc_wait_fs, zfs_secpolicy_none, DATASET_NAME, 7187 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_FALSE, B_FALSE, 7188 zfs_keys_fs_wait, ARRAY_SIZE(zfs_keys_fs_wait)); 7189 7190 zfs_ioctl_register("set_bootenv", ZFS_IOC_SET_BOOTENV, 7191 zfs_ioc_set_bootenv, zfs_secpolicy_config, POOL_NAME, 7192 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_FALSE, B_TRUE, 7193 zfs_keys_set_bootenv, ARRAY_SIZE(zfs_keys_set_bootenv)); 7194 7195 zfs_ioctl_register("get_bootenv", ZFS_IOC_GET_BOOTENV, 7196 zfs_ioc_get_bootenv, zfs_secpolicy_none, POOL_NAME, 7197 POOL_CHECK_SUSPENDED, B_FALSE, B_TRUE, 7198 zfs_keys_get_bootenv, ARRAY_SIZE(zfs_keys_get_bootenv)); 7199 7200 zfs_ioctl_register("zpool_vdev_get_props", ZFS_IOC_VDEV_GET_PROPS, 7201 zfs_ioc_vdev_get_props, zfs_secpolicy_read, POOL_NAME, 7202 POOL_CHECK_NONE, B_FALSE, B_FALSE, zfs_keys_vdev_get_props, 7203 ARRAY_SIZE(zfs_keys_vdev_get_props)); 7204 7205 zfs_ioctl_register("zpool_vdev_set_props", ZFS_IOC_VDEV_SET_PROPS, 7206 zfs_ioc_vdev_set_props, zfs_secpolicy_config, POOL_NAME, 7207 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY, B_FALSE, B_FALSE, 7208 zfs_keys_vdev_set_props, ARRAY_SIZE(zfs_keys_vdev_set_props)); 7209 7210 /* IOCTLS that use the legacy function signature */ 7211 7212 zfs_ioctl_register_legacy(ZFS_IOC_POOL_FREEZE, zfs_ioc_pool_freeze, 7213 zfs_secpolicy_config, NO_NAME, B_FALSE, POOL_CHECK_READONLY); 7214 7215 zfs_ioctl_register_pool(ZFS_IOC_POOL_CREATE, zfs_ioc_pool_create, 7216 zfs_secpolicy_config, B_TRUE, POOL_CHECK_NONE); 7217 zfs_ioctl_register_pool_modify(ZFS_IOC_POOL_SCAN, 7218 zfs_ioc_pool_scan); 7219 zfs_ioctl_register_pool_modify(ZFS_IOC_POOL_UPGRADE, 7220 zfs_ioc_pool_upgrade); 7221 zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_ADD, 7222 zfs_ioc_vdev_add); 7223 zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_REMOVE, 7224 zfs_ioc_vdev_remove); 7225 zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_SET_STATE, 7226 zfs_ioc_vdev_set_state); 7227 zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_ATTACH, 7228 zfs_ioc_vdev_attach); 7229 zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_DETACH, 7230 zfs_ioc_vdev_detach); 7231 zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_SETPATH, 7232 zfs_ioc_vdev_setpath); 7233 zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_SETFRU, 7234 zfs_ioc_vdev_setfru); 7235 zfs_ioctl_register_pool_modify(ZFS_IOC_POOL_SET_PROPS, 7236 zfs_ioc_pool_set_props); 7237 zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_SPLIT, 7238 zfs_ioc_vdev_split); 7239 zfs_ioctl_register_pool_modify(ZFS_IOC_POOL_REGUID, 7240 zfs_ioc_pool_reguid); 7241 7242 zfs_ioctl_register_pool_meta(ZFS_IOC_POOL_CONFIGS, 7243 zfs_ioc_pool_configs, zfs_secpolicy_none); 7244 zfs_ioctl_register_pool_meta(ZFS_IOC_POOL_TRYIMPORT, 7245 zfs_ioc_pool_tryimport, zfs_secpolicy_config); 7246 zfs_ioctl_register_pool_meta(ZFS_IOC_INJECT_FAULT, 7247 zfs_ioc_inject_fault, zfs_secpolicy_inject); 7248 zfs_ioctl_register_pool_meta(ZFS_IOC_CLEAR_FAULT, 7249 zfs_ioc_clear_fault, zfs_secpolicy_inject); 7250 zfs_ioctl_register_pool_meta(ZFS_IOC_INJECT_LIST_NEXT, 7251 zfs_ioc_inject_list_next, zfs_secpolicy_inject); 7252 7253 /* 7254 * pool destroy, and export don't log the history as part of 7255 * zfsdev_ioctl, but rather zfs_ioc_pool_export 7256 * does the logging of those commands. 7257 */ 7258 zfs_ioctl_register_pool(ZFS_IOC_POOL_DESTROY, zfs_ioc_pool_destroy, 7259 zfs_secpolicy_config, B_FALSE, POOL_CHECK_SUSPENDED); 7260 zfs_ioctl_register_pool(ZFS_IOC_POOL_EXPORT, zfs_ioc_pool_export, 7261 zfs_secpolicy_config, B_FALSE, POOL_CHECK_SUSPENDED); 7262 7263 zfs_ioctl_register_pool(ZFS_IOC_POOL_STATS, zfs_ioc_pool_stats, 7264 zfs_secpolicy_read, B_FALSE, POOL_CHECK_NONE); 7265 zfs_ioctl_register_pool(ZFS_IOC_POOL_GET_PROPS, zfs_ioc_pool_get_props, 7266 zfs_secpolicy_read, B_FALSE, POOL_CHECK_NONE); 7267 7268 zfs_ioctl_register_pool(ZFS_IOC_ERROR_LOG, zfs_ioc_error_log, 7269 zfs_secpolicy_inject, B_FALSE, POOL_CHECK_SUSPENDED); 7270 zfs_ioctl_register_pool(ZFS_IOC_DSOBJ_TO_DSNAME, 7271 zfs_ioc_dsobj_to_dsname, 7272 zfs_secpolicy_diff, B_FALSE, POOL_CHECK_SUSPENDED); 7273 zfs_ioctl_register_pool(ZFS_IOC_POOL_GET_HISTORY, 7274 zfs_ioc_pool_get_history, 7275 zfs_secpolicy_config, B_FALSE, POOL_CHECK_SUSPENDED); 7276 7277 zfs_ioctl_register_pool(ZFS_IOC_POOL_IMPORT, zfs_ioc_pool_import, 7278 zfs_secpolicy_config, B_TRUE, POOL_CHECK_NONE); 7279 7280 zfs_ioctl_register_pool(ZFS_IOC_CLEAR, zfs_ioc_clear, 7281 zfs_secpolicy_config, B_TRUE, POOL_CHECK_READONLY); 7282 7283 zfs_ioctl_register_dataset_read(ZFS_IOC_SPACE_WRITTEN, 7284 zfs_ioc_space_written); 7285 zfs_ioctl_register_dataset_read(ZFS_IOC_OBJSET_RECVD_PROPS, 7286 zfs_ioc_objset_recvd_props); 7287 zfs_ioctl_register_dataset_read(ZFS_IOC_NEXT_OBJ, 7288 zfs_ioc_next_obj); 7289 zfs_ioctl_register_dataset_read(ZFS_IOC_GET_FSACL, 7290 zfs_ioc_get_fsacl); 7291 zfs_ioctl_register_dataset_read(ZFS_IOC_OBJSET_STATS, 7292 zfs_ioc_objset_stats); 7293 zfs_ioctl_register_dataset_read(ZFS_IOC_OBJSET_ZPLPROPS, 7294 zfs_ioc_objset_zplprops); 7295 zfs_ioctl_register_dataset_read(ZFS_IOC_DATASET_LIST_NEXT, 7296 zfs_ioc_dataset_list_next); 7297 zfs_ioctl_register_dataset_read(ZFS_IOC_SNAPSHOT_LIST_NEXT, 7298 zfs_ioc_snapshot_list_next); 7299 zfs_ioctl_register_dataset_read(ZFS_IOC_SEND_PROGRESS, 7300 zfs_ioc_send_progress); 7301 7302 zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_DIFF, 7303 zfs_ioc_diff, zfs_secpolicy_diff); 7304 zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_OBJ_TO_STATS, 7305 zfs_ioc_obj_to_stats, zfs_secpolicy_diff); 7306 zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_OBJ_TO_PATH, 7307 zfs_ioc_obj_to_path, zfs_secpolicy_diff); 7308 zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_USERSPACE_ONE, 7309 zfs_ioc_userspace_one, zfs_secpolicy_userspace_one); 7310 zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_USERSPACE_MANY, 7311 zfs_ioc_userspace_many, zfs_secpolicy_userspace_many); 7312 zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_SEND, 7313 zfs_ioc_send, zfs_secpolicy_send); 7314 7315 zfs_ioctl_register_dataset_modify(ZFS_IOC_SET_PROP, zfs_ioc_set_prop, 7316 zfs_secpolicy_none); 7317 zfs_ioctl_register_dataset_modify(ZFS_IOC_DESTROY, zfs_ioc_destroy, 7318 zfs_secpolicy_destroy); 7319 zfs_ioctl_register_dataset_modify(ZFS_IOC_RENAME, zfs_ioc_rename, 7320 zfs_secpolicy_rename); 7321 zfs_ioctl_register_dataset_modify(ZFS_IOC_RECV, zfs_ioc_recv, 7322 zfs_secpolicy_recv); 7323 zfs_ioctl_register_dataset_modify(ZFS_IOC_PROMOTE, zfs_ioc_promote, 7324 zfs_secpolicy_promote); 7325 zfs_ioctl_register_dataset_modify(ZFS_IOC_INHERIT_PROP, 7326 zfs_ioc_inherit_prop, zfs_secpolicy_inherit_prop); 7327 zfs_ioctl_register_dataset_modify(ZFS_IOC_SET_FSACL, zfs_ioc_set_fsacl, 7328 zfs_secpolicy_set_fsacl); 7329 7330 zfs_ioctl_register_dataset_nolog(ZFS_IOC_SHARE, zfs_ioc_share, 7331 zfs_secpolicy_share, POOL_CHECK_NONE); 7332 zfs_ioctl_register_dataset_nolog(ZFS_IOC_SMB_ACL, zfs_ioc_smb_acl, 7333 zfs_secpolicy_smb_acl, POOL_CHECK_NONE); 7334 zfs_ioctl_register_dataset_nolog(ZFS_IOC_USERSPACE_UPGRADE, 7335 zfs_ioc_userspace_upgrade, zfs_secpolicy_userspace_upgrade, 7336 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY); 7337 zfs_ioctl_register_dataset_nolog(ZFS_IOC_TMP_SNAPSHOT, 7338 zfs_ioc_tmp_snapshot, zfs_secpolicy_tmp_snapshot, 7339 POOL_CHECK_SUSPENDED | POOL_CHECK_READONLY); 7340 7341 zfs_ioctl_register_legacy(ZFS_IOC_EVENTS_NEXT, zfs_ioc_events_next, 7342 zfs_secpolicy_config, NO_NAME, B_FALSE, POOL_CHECK_NONE); 7343 zfs_ioctl_register_legacy(ZFS_IOC_EVENTS_CLEAR, zfs_ioc_events_clear, 7344 zfs_secpolicy_config, NO_NAME, B_FALSE, POOL_CHECK_NONE); 7345 zfs_ioctl_register_legacy(ZFS_IOC_EVENTS_SEEK, zfs_ioc_events_seek, 7346 zfs_secpolicy_config, NO_NAME, B_FALSE, POOL_CHECK_NONE); 7347 7348 zfs_ioctl_init_os(); 7349 } 7350 7351 /* 7352 * Verify that for non-legacy ioctls the input nvlist 7353 * pairs match against the expected input. 7354 * 7355 * Possible errors are: 7356 * ZFS_ERR_IOC_ARG_UNAVAIL An unrecognized nvpair was encountered 7357 * ZFS_ERR_IOC_ARG_REQUIRED A required nvpair is missing 7358 * ZFS_ERR_IOC_ARG_BADTYPE Invalid type for nvpair 7359 */ 7360 static int 7361 zfs_check_input_nvpairs(nvlist_t *innvl, const zfs_ioc_vec_t *vec) 7362 { 7363 const zfs_ioc_key_t *nvl_keys = vec->zvec_nvl_keys; 7364 boolean_t required_keys_found = B_FALSE; 7365 7366 /* 7367 * examine each input pair 7368 */ 7369 for (nvpair_t *pair = nvlist_next_nvpair(innvl, NULL); 7370 pair != NULL; pair = nvlist_next_nvpair(innvl, pair)) { 7371 char *name = nvpair_name(pair); 7372 data_type_t type = nvpair_type(pair); 7373 boolean_t identified = B_FALSE; 7374 7375 /* 7376 * check pair against the documented names and type 7377 */ 7378 for (int k = 0; k < vec->zvec_nvl_key_count; k++) { 7379 /* if not a wild card name, check for an exact match */ 7380 if ((nvl_keys[k].zkey_flags & ZK_WILDCARDLIST) == 0 && 7381 strcmp(nvl_keys[k].zkey_name, name) != 0) 7382 continue; 7383 7384 identified = B_TRUE; 7385 7386 if (nvl_keys[k].zkey_type != DATA_TYPE_ANY && 7387 nvl_keys[k].zkey_type != type) { 7388 return (SET_ERROR(ZFS_ERR_IOC_ARG_BADTYPE)); 7389 } 7390 7391 if (nvl_keys[k].zkey_flags & ZK_OPTIONAL) 7392 continue; 7393 7394 required_keys_found = B_TRUE; 7395 break; 7396 } 7397 7398 /* allow an 'optional' key, everything else is invalid */ 7399 if (!identified && 7400 (strcmp(name, "optional") != 0 || 7401 type != DATA_TYPE_NVLIST)) { 7402 return (SET_ERROR(ZFS_ERR_IOC_ARG_UNAVAIL)); 7403 } 7404 } 7405 7406 /* verify that all required keys were found */ 7407 for (int k = 0; k < vec->zvec_nvl_key_count; k++) { 7408 if (nvl_keys[k].zkey_flags & ZK_OPTIONAL) 7409 continue; 7410 7411 if (nvl_keys[k].zkey_flags & ZK_WILDCARDLIST) { 7412 /* at least one non-optional key is expected here */ 7413 if (!required_keys_found) 7414 return (SET_ERROR(ZFS_ERR_IOC_ARG_REQUIRED)); 7415 continue; 7416 } 7417 7418 if (!nvlist_exists(innvl, nvl_keys[k].zkey_name)) 7419 return (SET_ERROR(ZFS_ERR_IOC_ARG_REQUIRED)); 7420 } 7421 7422 return (0); 7423 } 7424 7425 static int 7426 pool_status_check(const char *name, zfs_ioc_namecheck_t type, 7427 zfs_ioc_poolcheck_t check) 7428 { 7429 spa_t *spa; 7430 int error; 7431 7432 ASSERT(type == POOL_NAME || type == DATASET_NAME || 7433 type == ENTITY_NAME); 7434 7435 if (check & POOL_CHECK_NONE) 7436 return (0); 7437 7438 error = spa_open(name, &spa, FTAG); 7439 if (error == 0) { 7440 if ((check & POOL_CHECK_SUSPENDED) && spa_suspended(spa)) 7441 error = SET_ERROR(EAGAIN); 7442 else if ((check & POOL_CHECK_READONLY) && !spa_writeable(spa)) 7443 error = SET_ERROR(EROFS); 7444 spa_close(spa, FTAG); 7445 } 7446 return (error); 7447 } 7448 7449 int 7450 zfsdev_getminor(zfs_file_t *fp, minor_t *minorp) 7451 { 7452 zfsdev_state_t *zs, *fpd; 7453 7454 ASSERT(!MUTEX_HELD(&zfsdev_state_lock)); 7455 7456 fpd = zfs_file_private(fp); 7457 if (fpd == NULL) 7458 return (SET_ERROR(EBADF)); 7459 7460 mutex_enter(&zfsdev_state_lock); 7461 7462 for (zs = zfsdev_state_list; zs != NULL; zs = zs->zs_next) { 7463 7464 if (zs->zs_minor == -1) 7465 continue; 7466 7467 if (fpd == zs) { 7468 *minorp = fpd->zs_minor; 7469 mutex_exit(&zfsdev_state_lock); 7470 return (0); 7471 } 7472 } 7473 7474 mutex_exit(&zfsdev_state_lock); 7475 7476 return (SET_ERROR(EBADF)); 7477 } 7478 7479 void * 7480 zfsdev_get_state(minor_t minor, enum zfsdev_state_type which) 7481 { 7482 zfsdev_state_t *zs; 7483 7484 for (zs = zfsdev_state_list; zs != NULL; zs = zs->zs_next) { 7485 if (zs->zs_minor == minor) { 7486 smp_rmb(); 7487 switch (which) { 7488 case ZST_ONEXIT: 7489 return (zs->zs_onexit); 7490 case ZST_ZEVENT: 7491 return (zs->zs_zevent); 7492 case ZST_ALL: 7493 return (zs); 7494 } 7495 } 7496 } 7497 7498 return (NULL); 7499 } 7500 7501 /* 7502 * Find a free minor number. The zfsdev_state_list is expected to 7503 * be short since it is only a list of currently open file handles. 7504 */ 7505 static minor_t 7506 zfsdev_minor_alloc(void) 7507 { 7508 static minor_t last_minor = 0; 7509 minor_t m; 7510 7511 ASSERT(MUTEX_HELD(&zfsdev_state_lock)); 7512 7513 for (m = last_minor + 1; m != last_minor; m++) { 7514 if (m > ZFSDEV_MAX_MINOR) 7515 m = 1; 7516 if (zfsdev_get_state(m, ZST_ALL) == NULL) { 7517 last_minor = m; 7518 return (m); 7519 } 7520 } 7521 7522 return (0); 7523 } 7524 7525 int 7526 zfsdev_state_init(void *priv) 7527 { 7528 zfsdev_state_t *zs, *zsprev = NULL; 7529 minor_t minor; 7530 boolean_t newzs = B_FALSE; 7531 7532 ASSERT(MUTEX_HELD(&zfsdev_state_lock)); 7533 7534 minor = zfsdev_minor_alloc(); 7535 if (minor == 0) 7536 return (SET_ERROR(ENXIO)); 7537 7538 for (zs = zfsdev_state_list; zs != NULL; zs = zs->zs_next) { 7539 if (zs->zs_minor == -1) 7540 break; 7541 zsprev = zs; 7542 } 7543 7544 if (!zs) { 7545 zs = kmem_zalloc(sizeof (zfsdev_state_t), KM_SLEEP); 7546 newzs = B_TRUE; 7547 } 7548 7549 zfsdev_private_set_state(priv, zs); 7550 7551 zfs_onexit_init((zfs_onexit_t **)&zs->zs_onexit); 7552 zfs_zevent_init((zfs_zevent_t **)&zs->zs_zevent); 7553 7554 /* 7555 * In order to provide for lock-free concurrent read access 7556 * to the minor list in zfsdev_get_state(), new entries 7557 * must be completely written before linking them into the 7558 * list whereas existing entries are already linked; the last 7559 * operation must be updating zs_minor (from -1 to the new 7560 * value). 7561 */ 7562 if (newzs) { 7563 zs->zs_minor = minor; 7564 membar_producer(); 7565 zsprev->zs_next = zs; 7566 } else { 7567 membar_producer(); 7568 zs->zs_minor = minor; 7569 } 7570 7571 return (0); 7572 } 7573 7574 void 7575 zfsdev_state_destroy(void *priv) 7576 { 7577 zfsdev_state_t *zs = zfsdev_private_get_state(priv); 7578 7579 ASSERT(zs != NULL); 7580 ASSERT3S(zs->zs_minor, >, 0); 7581 7582 /* 7583 * The last reference to this zfsdev file descriptor is being dropped. 7584 * We don't have to worry about lookup grabbing this state object, and 7585 * zfsdev_state_init() will not try to reuse this object until it is 7586 * invalidated by setting zs_minor to -1. Invalidation must be done 7587 * last, with a memory barrier to ensure ordering. This lets us avoid 7588 * taking the global zfsdev state lock around destruction. 7589 */ 7590 zfs_onexit_destroy(zs->zs_onexit); 7591 zfs_zevent_destroy(zs->zs_zevent); 7592 zs->zs_onexit = NULL; 7593 zs->zs_zevent = NULL; 7594 membar_producer(); 7595 zs->zs_minor = -1; 7596 } 7597 7598 long 7599 zfsdev_ioctl_common(uint_t vecnum, zfs_cmd_t *zc, int flag) 7600 { 7601 int error, cmd; 7602 const zfs_ioc_vec_t *vec; 7603 char *saved_poolname = NULL; 7604 uint64_t max_nvlist_src_size; 7605 size_t saved_poolname_len = 0; 7606 nvlist_t *innvl = NULL; 7607 fstrans_cookie_t cookie; 7608 hrtime_t start_time = gethrtime(); 7609 7610 cmd = vecnum; 7611 error = 0; 7612 if (vecnum >= sizeof (zfs_ioc_vec) / sizeof (zfs_ioc_vec[0])) 7613 return (SET_ERROR(ZFS_ERR_IOC_CMD_UNAVAIL)); 7614 7615 vec = &zfs_ioc_vec[vecnum]; 7616 7617 /* 7618 * The registered ioctl list may be sparse, verify that either 7619 * a normal or legacy handler are registered. 7620 */ 7621 if (vec->zvec_func == NULL && vec->zvec_legacy_func == NULL) 7622 return (SET_ERROR(ZFS_ERR_IOC_CMD_UNAVAIL)); 7623 7624 zc->zc_iflags = flag & FKIOCTL; 7625 max_nvlist_src_size = zfs_max_nvlist_src_size_os(); 7626 if (zc->zc_nvlist_src_size > max_nvlist_src_size) { 7627 /* 7628 * Make sure the user doesn't pass in an insane value for 7629 * zc_nvlist_src_size. We have to check, since we will end 7630 * up allocating that much memory inside of get_nvlist(). This 7631 * prevents a nefarious user from allocating tons of kernel 7632 * memory. 7633 * 7634 * Also, we return EINVAL instead of ENOMEM here. The reason 7635 * being that returning ENOMEM from an ioctl() has a special 7636 * connotation; that the user's size value is too small and 7637 * needs to be expanded to hold the nvlist. See 7638 * zcmd_expand_dst_nvlist() for details. 7639 */ 7640 error = SET_ERROR(EINVAL); /* User's size too big */ 7641 7642 } else if (zc->zc_nvlist_src_size != 0) { 7643 error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size, 7644 zc->zc_iflags, &innvl); 7645 if (error != 0) 7646 goto out; 7647 } 7648 7649 /* 7650 * Ensure that all pool/dataset names are valid before we pass down to 7651 * the lower layers. 7652 */ 7653 zc->zc_name[sizeof (zc->zc_name) - 1] = '\0'; 7654 switch (vec->zvec_namecheck) { 7655 case POOL_NAME: 7656 if (pool_namecheck(zc->zc_name, NULL, NULL) != 0) 7657 error = SET_ERROR(EINVAL); 7658 else 7659 error = pool_status_check(zc->zc_name, 7660 vec->zvec_namecheck, vec->zvec_pool_check); 7661 break; 7662 7663 case DATASET_NAME: 7664 if (dataset_namecheck(zc->zc_name, NULL, NULL) != 0) 7665 error = SET_ERROR(EINVAL); 7666 else 7667 error = pool_status_check(zc->zc_name, 7668 vec->zvec_namecheck, vec->zvec_pool_check); 7669 break; 7670 7671 case ENTITY_NAME: 7672 if (entity_namecheck(zc->zc_name, NULL, NULL) != 0) { 7673 error = SET_ERROR(EINVAL); 7674 } else { 7675 error = pool_status_check(zc->zc_name, 7676 vec->zvec_namecheck, vec->zvec_pool_check); 7677 } 7678 break; 7679 7680 case NO_NAME: 7681 break; 7682 } 7683 /* 7684 * Ensure that all input pairs are valid before we pass them down 7685 * to the lower layers. 7686 * 7687 * The vectored functions can use fnvlist_lookup_{type} for any 7688 * required pairs since zfs_check_input_nvpairs() confirmed that 7689 * they exist and are of the correct type. 7690 */ 7691 if (error == 0 && vec->zvec_func != NULL) { 7692 error = zfs_check_input_nvpairs(innvl, vec); 7693 if (error != 0) 7694 goto out; 7695 } 7696 7697 if (error == 0) { 7698 cookie = spl_fstrans_mark(); 7699 error = vec->zvec_secpolicy(zc, innvl, CRED()); 7700 spl_fstrans_unmark(cookie); 7701 } 7702 7703 if (error != 0) 7704 goto out; 7705 7706 /* legacy ioctls can modify zc_name */ 7707 /* 7708 * Can't use kmem_strdup() as we might truncate the string and 7709 * kmem_strfree() would then free with incorrect size. 7710 */ 7711 saved_poolname_len = strlen(zc->zc_name) + 1; 7712 saved_poolname = kmem_alloc(saved_poolname_len, KM_SLEEP); 7713 7714 strlcpy(saved_poolname, zc->zc_name, saved_poolname_len); 7715 saved_poolname[strcspn(saved_poolname, "/@#")] = '\0'; 7716 7717 if (vec->zvec_func != NULL) { 7718 nvlist_t *outnvl; 7719 int puterror = 0; 7720 spa_t *spa; 7721 nvlist_t *lognv = NULL; 7722 7723 ASSERT(vec->zvec_legacy_func == NULL); 7724 7725 /* 7726 * Add the innvl to the lognv before calling the func, 7727 * in case the func changes the innvl. 7728 */ 7729 if (vec->zvec_allow_log) { 7730 lognv = fnvlist_alloc(); 7731 fnvlist_add_string(lognv, ZPOOL_HIST_IOCTL, 7732 vec->zvec_name); 7733 if (!nvlist_empty(innvl)) { 7734 fnvlist_add_nvlist(lognv, ZPOOL_HIST_INPUT_NVL, 7735 innvl); 7736 } 7737 } 7738 7739 outnvl = fnvlist_alloc(); 7740 cookie = spl_fstrans_mark(); 7741 error = vec->zvec_func(zc->zc_name, innvl, outnvl); 7742 spl_fstrans_unmark(cookie); 7743 7744 /* 7745 * Some commands can partially execute, modify state, and still 7746 * return an error. In these cases, attempt to record what 7747 * was modified. 7748 */ 7749 if ((error == 0 || 7750 (cmd == ZFS_IOC_CHANNEL_PROGRAM && error != EINVAL)) && 7751 vec->zvec_allow_log && 7752 spa_open(zc->zc_name, &spa, FTAG) == 0) { 7753 if (!nvlist_empty(outnvl)) { 7754 size_t out_size = fnvlist_size(outnvl); 7755 if (out_size > zfs_history_output_max) { 7756 fnvlist_add_int64(lognv, 7757 ZPOOL_HIST_OUTPUT_SIZE, out_size); 7758 } else { 7759 fnvlist_add_nvlist(lognv, 7760 ZPOOL_HIST_OUTPUT_NVL, outnvl); 7761 } 7762 } 7763 if (error != 0) { 7764 fnvlist_add_int64(lognv, ZPOOL_HIST_ERRNO, 7765 error); 7766 } 7767 fnvlist_add_int64(lognv, ZPOOL_HIST_ELAPSED_NS, 7768 gethrtime() - start_time); 7769 (void) spa_history_log_nvl(spa, lognv); 7770 spa_close(spa, FTAG); 7771 } 7772 fnvlist_free(lognv); 7773 7774 if (!nvlist_empty(outnvl) || zc->zc_nvlist_dst_size != 0) { 7775 int smusherror = 0; 7776 if (vec->zvec_smush_outnvlist) { 7777 smusherror = nvlist_smush(outnvl, 7778 zc->zc_nvlist_dst_size); 7779 } 7780 if (smusherror == 0) 7781 puterror = put_nvlist(zc, outnvl); 7782 } 7783 7784 if (puterror != 0) 7785 error = puterror; 7786 7787 nvlist_free(outnvl); 7788 } else { 7789 cookie = spl_fstrans_mark(); 7790 error = vec->zvec_legacy_func(zc); 7791 spl_fstrans_unmark(cookie); 7792 } 7793 7794 out: 7795 nvlist_free(innvl); 7796 if (error == 0 && vec->zvec_allow_log) { 7797 char *s = tsd_get(zfs_allow_log_key); 7798 if (s != NULL) 7799 kmem_strfree(s); 7800 (void) tsd_set(zfs_allow_log_key, kmem_strdup(saved_poolname)); 7801 } 7802 if (saved_poolname != NULL) 7803 kmem_free(saved_poolname, saved_poolname_len); 7804 7805 return (error); 7806 } 7807 7808 int 7809 zfs_kmod_init(void) 7810 { 7811 int error; 7812 7813 if ((error = zvol_init()) != 0) 7814 return (error); 7815 7816 spa_init(SPA_MODE_READ | SPA_MODE_WRITE); 7817 zfs_init(); 7818 7819 zfs_ioctl_init(); 7820 7821 mutex_init(&zfsdev_state_lock, NULL, MUTEX_DEFAULT, NULL); 7822 zfsdev_state_list = kmem_zalloc(sizeof (zfsdev_state_t), KM_SLEEP); 7823 zfsdev_state_list->zs_minor = -1; 7824 7825 if ((error = zfsdev_attach()) != 0) 7826 goto out; 7827 7828 tsd_create(&zfs_fsyncer_key, NULL); 7829 tsd_create(&rrw_tsd_key, rrw_tsd_destroy); 7830 tsd_create(&zfs_allow_log_key, zfs_allow_log_destroy); 7831 7832 return (0); 7833 out: 7834 zfs_fini(); 7835 spa_fini(); 7836 zvol_fini(); 7837 7838 return (error); 7839 } 7840 7841 void 7842 zfs_kmod_fini(void) 7843 { 7844 zfsdev_state_t *zs, *zsnext = NULL; 7845 7846 zfsdev_detach(); 7847 7848 mutex_destroy(&zfsdev_state_lock); 7849 7850 for (zs = zfsdev_state_list; zs != NULL; zs = zsnext) { 7851 zsnext = zs->zs_next; 7852 if (zs->zs_onexit) 7853 zfs_onexit_destroy(zs->zs_onexit); 7854 if (zs->zs_zevent) 7855 zfs_zevent_destroy(zs->zs_zevent); 7856 kmem_free(zs, sizeof (zfsdev_state_t)); 7857 } 7858 7859 zfs_ereport_taskq_fini(); /* run before zfs_fini() on Linux */ 7860 zfs_fini(); 7861 spa_fini(); 7862 zvol_fini(); 7863 7864 tsd_destroy(&zfs_fsyncer_key); 7865 tsd_destroy(&rrw_tsd_key); 7866 tsd_destroy(&zfs_allow_log_key); 7867 } 7868 7869 /* BEGIN CSTYLED */ 7870 ZFS_MODULE_PARAM(zfs, zfs_, max_nvlist_src_size, ULONG, ZMOD_RW, 7871 "Maximum size in bytes allowed for src nvlist passed with ZFS ioctls"); 7872 7873 ZFS_MODULE_PARAM(zfs, zfs_, history_output_max, ULONG, ZMOD_RW, 7874 "Maximum size in bytes of ZFS ioctl output that will be logged"); 7875 /* END CSTYLED */ 7876