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